Files
gns3-server/tests/controller/test_project.py
tikD1337andClaude Opus 5.5 dd69a01fba fix(controller): make node names from template names valid hostnames
Creating a node from a template whose name has characters invalid in a
hostname, such as "MikroTik CCR1072-1G-8S+", failed on the compute with
"'MikroTikCCR1072-1G-8S+-1' is an invalid name to create a Qemu node":
the template name was only stripped of spaces.

Replace the other invalid characters by hyphens, following the rules the
compute validates node names with (RFC 1123 for Qemu and Docker, IOS for
Dynamips and IOU), as project import already does for existing nodes.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-23 09:56:49 +02:00

1400 lines
46 KiB
Python

#!/usr/bin/env python
#
# Copyright (C) 2020 GNS3 Technologies Inc.
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
import json
import os
import uuid
from unittest.mock import MagicMock, patch
from uuid import uuid4
import pytest
import pytest_asyncio
from gns3server.controller.controller_error import (
ComputeConflictError,
ControllerError,
ControllerForbiddenError,
ControllerNotFoundError,
)
from gns3server.controller.node import Node
from gns3server.controller.ports.ethernet_port import EthernetPort
from gns3server.controller.project import Project
from tests.utils import AsyncioMagicMock, asyncio_patch
@pytest_asyncio.fixture
async def node(controller, project):
compute = MagicMock()
compute.id = "local"
response = MagicMock()
response.json = {"console": 2048}
compute.post = AsyncioMagicMock(return_value=response)
node = await project.add_node(compute, "test", None, node_type="vpcs", properties={"startup_config": "test.cfg"})
return node
@pytest.mark.asyncio
async def test_affect_uuid():
with patch("gns3server.controller.project.Project.emit_controller_notification") as mock_notification:
p = Project(name="Test")
mock_notification.assert_called()
assert len(p.id) == 36
p = Project(project_id="00010203-0405-0607-0809-0a0b0c0d0e0f", name="Test 2")
assert p.id == "00010203-0405-0607-0809-0a0b0c0d0e0f"
@pytest.mark.asyncio
async def test_json():
with patch("gns3server.controller.project.Project.emit_controller_notification") as mock_notification:
p = Project(name="Test")
mock_notification.assert_called()
assert p.asdict() == {
"name": "Test",
"project_id": p.id,
"path": p.path,
"status": "opened",
"filename": "Test.gns3",
"auto_start": False,
"auto_close": True,
"auto_open": False,
"scene_width": 2000,
"scene_height": 1000,
"zoom": 100,
"show_grid": False,
"show_interface_labels": True,
"show_layers": False,
"snap_to_grid": False,
"grid_size": 75,
"drawing_grid_size": 25,
"supplier": None,
"variables": None,
"marker_definitions": {},
"created_by": None,
}
@pytest.mark.asyncio
async def test_created_by():
with patch("gns3server.controller.project.Project.emit_controller_notification"):
p = Project(name="Test", created_by="admin")
assert p.created_by == "admin"
assert p.asdict()["created_by"] == "admin"
@pytest.mark.asyncio
async def test_update(controller):
project = Project(controller=controller, name="Hello")
project.emit_controller_notification = MagicMock()
assert project.name == "Hello"
await project.update(name="World")
assert project.name == "World"
project.emit_controller_notification.assert_any_call("project.updated", project.asdict())
@pytest.mark.asyncio
async def test_update_on_compute(controller):
variables = [{"name": "TEST", "value": "VAL1"}]
compute = MagicMock()
compute.id = "local"
project = Project(controller=controller, name="Test")
project._project_created_on_compute = [compute]
project.emit_notification = MagicMock()
await project.update(variables=variables)
compute.put.assert_any_call(f"/projects/{project.id}", {"variables": variables})
@pytest.mark.asyncio
async def test_path(projects_dir):
directory = projects_dir
with patch("gns3server.utils.path.get_default_project_directory", return_value=directory):
with patch("gns3server.controller.project.Project.emit_controller_notification") as mock_notification:
p = Project(project_id=str(uuid4()), name="Test")
mock_notification.assert_called()
assert p.path == os.path.join(directory, p.id)
assert os.path.exists(os.path.join(directory, p.id))
def test_path_exist(tmpdir):
"""
Should raise an error when you try to overwrite
an existing project
"""
os.makedirs(str(tmpdir / "demo"))
with pytest.raises(ControllerForbiddenError):
Project(name="Test", path=str(tmpdir / "demo"))
@pytest.mark.asyncio
async def test_init_path(projects_dir):
with patch("gns3server.controller.project.Project.emit_controller_notification") as mock_notification:
project_id = str(uuid4())
p = Project(project_id=project_id, name="Test")
mock_notification.assert_called()
assert p.path == os.path.join(projects_dir, project_id)
@pytest.mark.asyncio
async def test_changing_path_with_quote_not_allowed(projects_dir):
with pytest.raises(ControllerForbiddenError):
with patch("gns3server.controller.project.Project.emit_controller_notification"):
p = Project(project_id=str(uuid4()), name="Test")
p.path = os.path.join(projects_dir, 'project"53')
@pytest.mark.asyncio
async def test_captures_directory(tmpdir):
with patch("gns3server.controller.project.Project.emit_controller_notification"):
p = Project(name="Test")
assert p.captures_directory == str(p.path + os.path.sep + "project-files" + os.path.sep + "captures")
assert os.path.exists(p.captures_directory)
@pytest.mark.asyncio
async def test_add_node_local(controller):
"""
For a local server we send the project path
"""
compute = MagicMock()
compute.id = "local"
project = Project(controller=controller, name="Test")
project.emit_notification = MagicMock()
response = MagicMock()
response.json = {"console": 2048}
compute.post = AsyncioMagicMock(return_value=response)
node = await project.add_node(compute, "test", None, node_type="vpcs", properties={"startup_script": "test.cfg"})
assert node.id in project._nodes
compute.post.assert_any_call(
"/projects",
data={
"name": project._name,
"project_id": project._id,
"path": project._path,
},
)
compute.post.assert_any_call(
f"/projects/{project.id}/vpcs/nodes",
data={"node_id": node.id, "startup_script": "test.cfg", "name": "test"},
timeout=1200,
)
assert compute in project._project_created_on_compute
project.emit_notification.assert_any_call("node.created", node.asdict())
@pytest.mark.asyncio
async def test_add_node_from_template_seeds_default_credentials(controller):
"""
The appliance metadata stays template level: creating a node from a
template seeds the default credentials on the node and must not leak
the metadata into the node properties sent to the compute.
"""
compute = MagicMock()
compute.id = "local"
controller._computes["local"] = compute
project = Project(controller=controller, name="Test")
project.emit_notification = MagicMock()
response = MagicMock()
response.json = {"console": 2048}
compute.post = AsyncioMagicMock(return_value=response)
template = {
"name": "VPCS_TEST",
"template_type": "vpcs",
"compute_id": "local",
"default_name_format": "PC{0}",
"properties": {"startup_script": "test.cfg"},
"appliance_metadata": {
"vendor_name": "Test vendor",
"default_username": "admin",
"default_password": "secret",
},
}
node = await project.add_node_from_template(template)
# credentials seeded from the appliance metadata
assert node.default_username == "admin"
assert node.default_password == "secret"
# the metadata itself never reaches the node properties
assert "appliance_metadata" not in node.properties
assert "default_username" not in node.properties
assert "default_password" not in node.properties
@pytest.mark.asyncio
async def test_add_node_from_template_name_invalid_in_hostname(controller):
"""
A template name with characters invalid in a hostname (e.g. "+" in a model name)
gives node names the compute accepts.
"""
compute = MagicMock()
compute.id = "local"
controller._computes["local"] = compute
project = Project(controller=controller, name="Test")
project.emit_notification = MagicMock()
response = MagicMock()
response.json = {"console": 2048}
compute.post = AsyncioMagicMock(return_value=response)
template = {
"name": "MikroTik CCR1072-1G-8S+",
"template_type": "qemu",
"compute_id": "local",
"default_name_format": "{name}-{0}",
"properties": {},
}
node = await project.add_node_from_template(template)
assert node.name == "MikroTikCCR1072-1G-8S-1"
@pytest.mark.asyncio
async def test_add_node_non_local(controller):
"""
For a non local server we do not send the project path
"""
compute = MagicMock()
compute.id = "remote"
project = Project(controller=controller, name="Test")
project.emit_notification = MagicMock()
response = MagicMock()
response.json = {"console": 2048}
compute.post = AsyncioMagicMock(return_value=response)
node = await project.add_node(compute, "test", None, node_type="vpcs", properties={"startup_script": "test.cfg"})
compute.post.assert_any_call("/projects", data={"name": project._name, "project_id": project._id})
compute.post.assert_any_call(
f"/projects/{project.id}/vpcs/nodes",
data={"node_id": node.id, "startup_script": "test.cfg", "name": "test"},
timeout=1200,
)
assert compute in project._project_created_on_compute
project.emit_notification.assert_any_call("node.created", node.asdict())
@pytest.mark.asyncio
async def test_add_node_iou(controller):
"""
Test if an application ID is allocated for IOU nodes
"""
compute = MagicMock()
compute.id = "local"
project = await controller.add_project(project_id=str(uuid.uuid4()), name="test1")
project.emit_notification = MagicMock()
response = MagicMock()
compute.post = AsyncioMagicMock(return_value=response)
node1 = await project.add_node(compute, "test1", None, node_type="iou")
node2 = await project.add_node(compute, "test2", None, node_type="iou")
node3 = await project.add_node(compute, "test3", None, node_type="iou")
assert node1.properties["application_id"] == 1
assert node2.properties["application_id"] == 2
assert node3.properties["application_id"] == 3
@pytest.mark.asyncio
async def test_add_node_iol_docker(controller):
"""
IOL Docker nodes (GNS3_IOL_RUNNER marker) get an application ID from the
upper half of the id space, disjoint from IOU's lower half
"""
compute = MagicMock()
compute.id = "local"
project = await controller.add_project(project_id=str(uuid.uuid4()), name="test1")
project.emit_notification = MagicMock()
response = MagicMock()
compute.post = AsyncioMagicMock(return_value=response)
# template shape: environment as a top-level kwarg
node1 = await project.add_node(
compute, "iol1", None, node_type="docker", image="iol-xe/iol-xe:17-18-02", environment="GNS3_IOL_RUNNER=1"
)
# raw API shape: environment nested in properties
node2 = await project.add_node(
compute,
"iol2",
None,
node_type="docker",
properties={"image": "iol-xe/iol-xe:17-18-02", "environment": "GNS3_IOL_RUNNER=1"},
)
# plain docker nodes are left alone
node3 = await project.add_node(
compute, "web", None, node_type="docker", image="nginx", environment="FOO=1", adapters=1
)
assert node1.properties["application_id"] == 512
assert node2.properties["application_id"] == 513
assert "application_id" not in node3.properties
# IOU keeps its own pool: a subsequent IOU node still gets the lower half
node4 = await project.add_node(compute, "iou1", None, node_type="iou")
assert node4.properties["application_id"] == 1
@pytest.mark.asyncio
async def test_add_node_iou_with_multiple_projects(controller):
"""
Test if an application ID is allocated for IOU nodes with different projects already opened
"""
compute = MagicMock()
compute.id = "local"
project1 = await controller.add_project(project_id=str(uuid.uuid4()), name="test1")
project1.emit_notification = MagicMock()
project2 = await controller.add_project(project_id=str(uuid.uuid4()), name="test2")
project2.emit_notification = MagicMock()
project3 = await controller.add_project(project_id=str(uuid.uuid4()), name="test3")
project3.emit_notification = MagicMock()
response = MagicMock()
compute.post = AsyncioMagicMock(return_value=response)
node1 = await project1.add_node(compute, "test1", None, node_type="iou")
node2 = await project1.add_node(compute, "test2", None, node_type="iou")
node3 = await project1.add_node(compute, "test3", None, node_type="iou")
node4 = await project2.add_node(compute, "test4", None, node_type="iou")
node5 = await project2.add_node(compute, "test5", None, node_type="iou")
node6 = await project2.add_node(compute, "test6", None, node_type="iou")
node7 = await project3.add_node(compute, "test7", None, node_type="iou")
node8 = await project3.add_node(compute, "test8", None, node_type="iou")
node9 = await project3.add_node(compute, "test9", None, node_type="iou")
assert node1.properties["application_id"] == 1
assert node2.properties["application_id"] == 2
assert node3.properties["application_id"] == 3
assert node4.properties["application_id"] == 4
assert node5.properties["application_id"] == 5
assert node6.properties["application_id"] == 6
assert node7.properties["application_id"] == 7
assert node8.properties["application_id"] == 8
assert node9.properties["application_id"] == 9
controller.remove_project(project1)
project4 = await controller.add_project(project_id=str(uuid.uuid4()), name="test4")
project4.emit_notification = MagicMock()
node10 = await project3.add_node(compute, "test10", None, node_type="iou")
node11 = await project3.add_node(compute, "test11", None, node_type="iou")
node12 = await project3.add_node(compute, "test12", None, node_type="iou")
assert node10.properties["application_id"] == 1
assert node11.properties["application_id"] == 2
assert node12.properties["application_id"] == 3
@pytest.mark.asyncio
async def test_add_node_iou_with_multiple_projects_different_computes(controller):
"""
Test if an application ID is allocated for IOU nodes with different projects already opened
"""
compute1 = MagicMock()
compute1.id = "remote1"
compute2 = MagicMock()
compute2.id = "remote2"
project1 = await controller.add_project(project_id=str(uuid.uuid4()), name="test1")
project1.emit_notification = MagicMock()
project2 = await controller.add_project(project_id=str(uuid.uuid4()), name="test2")
project2.emit_notification = MagicMock()
response = MagicMock()
compute1.post = AsyncioMagicMock(return_value=response)
compute2.post = AsyncioMagicMock(return_value=response)
node1 = await project1.add_node(compute1, "test1", None, node_type="iou")
node2 = await project1.add_node(compute1, "test2", None, node_type="iou")
node3 = await project2.add_node(compute2, "test3", None, node_type="iou")
node4 = await project2.add_node(compute2, "test4", None, node_type="iou")
assert node1.properties["application_id"] == 1
assert node2.properties["application_id"] == 2
assert node3.properties["application_id"] == 1
assert node4.properties["application_id"] == 2
node5 = await project1.add_node(compute2, "test5", None, node_type="iou")
node6 = await project2.add_node(compute1, "test6", None, node_type="iou")
assert node5.properties["application_id"] == 3
assert node6.properties["application_id"] == 4
@pytest.mark.asyncio
async def test_add_node_iou_no_id_available(controller):
"""
Test if an application ID is allocated for IOU nodes
"""
compute = MagicMock()
compute.id = "local"
project = await controller.add_project(project_id=str(uuid.uuid4()), name="test")
project.emit_notification = MagicMock()
response = MagicMock()
compute.post = AsyncioMagicMock(return_value=response)
with pytest.raises(ControllerError):
for i in range(1, 513):
prop = {"properties": {"application_id": i}}
project._nodes[i] = Node(project, compute, f"Node{i}", node_id=i, node_type="iou", **prop)
await project.add_node(compute, "test1", None, node_type="iou")
# @pytest.mark.asyncio
# async def test_add_node_from_template(controller):
# """
# For a local server we send the project path
# """
#
# compute = MagicMock()
# compute.id = "local"
# project = Project(controller=controller, name="Test")
# project.emit_notification = MagicMock()
# template = Template(str(uuid.uuid4()), {
# "compute_id": "local",
# "name": "Test",
# "template_type": "vpcs",
# "builtin": False,
# })
# controller.template_manager.templates[template.id] = template
# controller._computes["local"] = compute
#
# response = MagicMock()
# response.json = {"console": 2048}
# compute.post = AsyncioMagicMock(return_value=response)
#
# node = await project.add_node_from_template(template.id, x=23, y=12)
# compute.post.assert_any_call('/projects', data={
# "name": project._name,
# "project_id": project._id,
# "path": project._path
# })
#
# assert compute in project._project_created_on_compute
# project.emit_notification.assert_any_call("node.created", node.asdict())
#
#
# @pytest.mark.asyncio
# async def test_add_builtin_node_from_template(controller):
# """
# For a local server we send the project path
# """
#
# compute = MagicMock()
# compute.id = "local"
# project = Project(controller=controller, name="Test")
# project.emit_notification = MagicMock()
# template = Template(str(uuid.uuid4()), {
# "name": "Builtin-switch",
# "template_type": "ethernet_switch",
# }, builtin=True)
#
# controller.template_manager.templates[template.id] = template
# template.asdict()
# controller._computes["local"] = compute
#
# response = MagicMock()
# response.json = {"console": 2048}
# compute.post = AsyncioMagicMock(return_value=response)
#
# node = await project.add_node_from_template(template.id, x=23, y=12, compute_id="local")
# compute.post.assert_any_call('/projects', data={
# "name": project._name,
# "project_id": project._id,
# "path": project._path
# })
#
# assert compute in project._project_created_on_compute
# project.emit_notification.assert_any_call("node.created", node.asdict())
@pytest.mark.asyncio
async def test_delete_node(controller):
"""
For a local server we send the project path
"""
compute = MagicMock()
project = Project(controller=controller, name="Test")
project.emit_notification = MagicMock()
response = MagicMock()
response.json = {"console": 2048}
compute.post = AsyncioMagicMock(return_value=response)
node = await project.add_node(compute, "test", None, node_type="vpcs", properties={"startup_config": "test.cfg"})
assert node.id in project._nodes
await project.delete_node(node.id)
assert node.id not in project._nodes
compute.delete.assert_any_call(f"/projects/{project.id}/vpcs/nodes/{node.id}")
project.emit_notification.assert_any_call("node.deleted", node.asdict())
@pytest.mark.asyncio
async def test_delete_locked_node(controller):
"""
For a local server we send the project path
"""
compute = MagicMock()
project = Project(controller=controller, name="Test")
project.emit_notification = MagicMock()
response = MagicMock()
response.json = {"console": 2048}
compute.post = AsyncioMagicMock(return_value=response)
node = await project.add_node(compute, "test", None, node_type="vpcs", properties={"startup_config": "test.cfg"})
assert node.id in project._nodes
node.locked = True
with pytest.raises(ControllerError):
await project.delete_node(node.id)
@pytest.mark.asyncio
async def test_delete_node_delete_link(controller):
"""
Delete a node delete all the node connected
"""
compute = MagicMock()
project = Project(controller=controller, name="Test")
project.emit_notification = MagicMock()
response = MagicMock()
response.json = {"console": 2048}
compute.post = AsyncioMagicMock(return_value=response)
node = await project.add_node(compute, "test", None, node_type="vpcs", properties={"startup_config": "test.cfg"})
link = await project.add_link()
await link.add_node(node, 0, 0)
await project.delete_node(node.id)
assert node.id not in project._nodes
assert link.id not in project._links
compute.delete.assert_any_call(f"/projects/{project.id}/vpcs/nodes/{node.id}")
project.emit_notification.assert_any_call("node.deleted", node.asdict())
project.emit_notification.assert_any_call("link.deleted", link.asdict())
@pytest.mark.asyncio
async def test_get_node(controller):
compute = MagicMock()
project = Project(controller=controller, name="Test")
response = MagicMock()
response.json = {"console": 2048}
compute.post = AsyncioMagicMock(return_value=response)
vm = await project.add_node(compute, "test", None, node_type="vpcs", properties={"startup_config": "test.cfg"})
assert project.get_node(vm.id) == vm
with pytest.raises(ControllerNotFoundError):
project.get_node("test")
# Raise an error if the project is not opened
await project.close()
with pytest.raises(ControllerForbiddenError):
project.get_node(vm.id)
@pytest.mark.asyncio
async def test_list_nodes(controller):
compute = MagicMock()
project = Project(controller=controller, name="Test")
response = MagicMock()
response.json = {"console": 2048}
compute.post = AsyncioMagicMock(return_value=response)
vm = await project.add_node(compute, "test", None, node_type="vpcs", properties={"startup_config": "test.cfg"})
assert len(project.nodes) == 1
assert isinstance(project.nodes, dict)
await project.close()
assert len(project.nodes) == 1
assert isinstance(project.nodes, dict)
@pytest.mark.asyncio
async def test_add_link(project):
compute = MagicMock()
response = MagicMock()
response.json = {"console": 2048}
compute.post = AsyncioMagicMock(return_value=response)
vm1 = await project.add_node(compute, "test1", None, node_type="vpcs", properties={"startup_config": "test.cfg"})
vm1._ports = [EthernetPort("E0", 0, 3, 1)]
vm2 = await project.add_node(compute, "test2", None, node_type="vpcs", properties={"startup_config": "test.cfg"})
vm2._ports = [EthernetPort("E0", 0, 4, 2)]
project.emit_notification = MagicMock()
link = await project.add_link()
await link.add_node(vm1, 3, 1)
with asyncio_patch("gns3server.controller.udp_link.UDPLink.create") as mock_udp_create:
await link.add_node(vm2, 4, 2)
assert mock_udp_create.called
assert len(link._nodes) == 2
project.emit_notification.assert_any_call("link.created", link.asdict())
@pytest.mark.asyncio
async def test_list_links(project):
compute = MagicMock()
response = MagicMock()
response.json = {"console": 2048}
compute.post = AsyncioMagicMock(return_value=response)
await project.add_link()
assert len(project.links) == 1
await project.close()
assert len(project.links) == 1
@pytest.mark.asyncio
async def test_get_link(project):
compute = MagicMock()
response = MagicMock()
response.json = {"console": 2048}
compute.post = AsyncioMagicMock(return_value=response)
link = await project.add_link()
assert project.get_link(link.id) == link
with pytest.raises(ControllerNotFoundError):
project.get_link("test")
@pytest.mark.asyncio
async def test_delete_link(project):
compute = MagicMock()
response = MagicMock()
response.json = {"console": 2048}
compute.post = AsyncioMagicMock(return_value=response)
assert len(project._links) == 0
link = await project.add_link()
assert len(project._links) == 1
project.emit_notification = MagicMock()
await project.delete_link(link.id)
project.emit_notification.assert_any_call("link.deleted", link.asdict())
assert len(project._links) == 0
@pytest.mark.asyncio
async def test_add_drawing(project):
project.emit_notification = MagicMock()
drawing = await project.add_drawing(None, svg="<svg></svg>")
assert len(project._drawings) == 1
project.emit_notification.assert_any_call("drawing.created", drawing.asdict())
@pytest.mark.asyncio
async def test_get_drawing(project):
drawing = await project.add_drawing(None)
assert project.get_drawing(drawing.id) == drawing
with pytest.raises(ControllerNotFoundError):
project.get_drawing("test")
@pytest.mark.asyncio
async def test_list_drawing(project):
await project.add_drawing(None)
assert len(project.drawings) == 1
await project.close()
assert len(project.drawings) == 1
@pytest.mark.asyncio
async def test_delete_drawing(project):
assert len(project._drawings) == 0
drawing = await project.add_drawing()
assert len(project._drawings) == 1
project.emit_notification = MagicMock()
await project.delete_drawing(drawing.id)
project.emit_notification.assert_any_call("drawing.deleted", drawing.asdict())
assert len(project._drawings) == 0
@pytest.mark.asyncio
async def test_clean_pictures(project):
"""
When a project is close old pictures should be removed
"""
drawing = await project.add_drawing()
drawing._svg = "test.png"
open(os.path.join(project.pictures_directory, "test.png"), "w+").close()
open(os.path.join(project.pictures_directory, "test2.png"), "w+").close()
await project.close()
assert os.path.exists(os.path.join(project.pictures_directory, "test.png"))
assert not os.path.exists(os.path.join(project.pictures_directory, "test2.png"))
@pytest.mark.asyncio
async def test_clean_pictures_and_keep_supplier_logo(project):
"""
When a project is close old pictures should be removed
"""
project.supplier = {"logo": "logo.png", "url": "http://acme.com"}
drawing = await project.add_drawing()
drawing._svg = "test.png"
open(os.path.join(project.pictures_directory, "test.png"), "w+").close()
open(os.path.join(project.pictures_directory, "test2.png"), "w+").close()
open(os.path.join(project.pictures_directory, "logo.png"), "w+").close()
await project.close()
assert os.path.exists(os.path.join(project.pictures_directory, "test.png"))
assert not os.path.exists(os.path.join(project.pictures_directory, "test2.png"))
assert os.path.exists(os.path.join(project.pictures_directory, "logo.png"))
@pytest.mark.asyncio
async def test_delete(project):
assert os.path.exists(project.path)
await project.delete()
assert not os.path.exists(project.path)
@pytest.mark.asyncio
async def test_delete_refuses_to_delete_projects_directory(project, projects_dir):
"""
A poisoned entry whose path is the projects directory itself (a .gns3
loaded directly from the projects root before the guard existed) must
not be deletable: rmtree would wipe every project on the controller.
"""
other_project = os.path.join(projects_dir, "another-project")
os.makedirs(other_project, exist_ok=True)
# Simulate the poisoned in-memory state directly: the path setter now
# rejects such an assignment, but a long-running server can still hold
# an entry created before the fix.
project._path = projects_dir
with pytest.raises(ControllerError):
await project.delete()
assert os.path.exists(other_project)
def test_path_setter_rejects_projects_directory(project, projects_dir):
"""
The projects directory itself must never become a project directory.
"""
with pytest.raises(ControllerForbiddenError):
project.path = projects_dir
assert project.path == os.path.join(projects_dir, project.id)
@pytest.mark.asyncio
async def test_delete_does_not_start_nodes(project):
"""
Deleting a project must not start its nodes, even when auto_start is enabled.
"""
project.auto_start = True
project.dump()
await project.close()
project.start_all = AsyncioMagicMock()
await project.delete()
assert not project.start_all.called
@pytest.mark.asyncio
async def test_dump(projects_dir):
directory = projects_dir
with patch("gns3server.utils.path.get_default_project_directory", return_value=directory):
with patch("gns3server.controller.project.Project.emit_controller_notification"):
p = Project(project_id="00010203-0405-0607-0809-0a0b0c0d0e0f", name="Test")
p.dump()
with open(os.path.join(directory, p.id, "Test.gns3")) as f:
content = f.read()
assert "00010203-0405-0607-0809-0a0b0c0d0e0f" in content
@pytest.mark.asyncio
async def test_open_close(controller):
with patch("gns3server.controller.project.Project.emit_controller_notification"):
project = Project(controller=controller, name="Test")
assert project.status == "opened"
await project.close()
project.start_all = AsyncioMagicMock()
await project.open()
assert not project.start_all.called
assert project.status == "opened"
project.emit_controller_notification = MagicMock()
await project.close()
assert project.status == "closed"
project.emit_controller_notification.assert_any_call("project.closed", project.asdict())
@pytest.mark.asyncio
async def test_open_auto_start(controller):
with patch("gns3server.controller.project.Project.emit_controller_notification"):
project = Project(controller=controller, name="Test", auto_start=True)
assert project.status == "opened"
await project.close()
# project.start_all = AsyncioMagicMock()
# await project.open()
# assert project.start_all.called
def test_is_running(project, node):
"""
If a node is started or paused return True
"""
assert project.is_running() is False
node._status = "started"
assert project.is_running() is True
@pytest.mark.asyncio
async def test_duplicate(project, controller):
"""
Duplicate a project, the node should remain on the remote server
if they were on remote server
"""
compute = MagicMock()
compute.id = "remote"
compute.list_files = AsyncioMagicMock(return_value=[])
controller._computes["remote"] = compute
response = MagicMock()
response.json = {"console": 2048}
compute.post = AsyncioMagicMock(return_value=response)
remote_vpcs = await project.add_node(
compute, "test", None, node_type="vpcs", properties={"startup_config": "test.cfg"}
)
# We allow node not allowed for standard import / export
remote_virtualbox = await project.add_node(
compute, "test", None, node_type="vmware", properties={"startup_config": "test.cfg"}
)
new_project = await project.duplicate(name="Hello")
assert new_project.id != project.id
assert new_project.name == "Hello"
await new_project.open()
assert list(new_project.nodes.values())[0].compute.id == "remote"
assert list(new_project.nodes.values())[1].compute.id == "remote"
def test_snapshots(project):
"""
List the snapshots
"""
os.makedirs(os.path.join(project.path, "snapshots"))
open(os.path.join(project.path, "snapshots", "test1_260716_103713.gns3project"), "w+").close()
project.reset()
assert len(project.snapshots) == 1
assert list(project.snapshots.values())[0].name == "test1"
def test_get_snapshot(project):
os.makedirs(os.path.join(project.path, "snapshots"))
open(os.path.join(project.path, "snapshots", "test1_260716_103713.gns3project"), "w+").close()
project.reset()
snapshot = list(project.snapshots.values())[0]
assert project.get_snapshot(snapshot.id) == snapshot
with pytest.raises(ControllerNotFoundError):
project.get_snapshot("BLU")
@pytest.mark.asyncio
async def test_delete_snapshot(project):
os.makedirs(os.path.join(project.path, "snapshots"))
open(os.path.join(project.path, "snapshots", "test1_260716_103713.gns3project"), "w+").close()
project.reset()
snapshot = list(project.snapshots.values())[0]
assert project.get_snapshot(snapshot.id) == snapshot
await project.delete_snapshot(snapshot.id)
with pytest.raises(ControllerNotFoundError):
project.get_snapshot(snapshot.id)
assert not os.path.exists(os.path.join(project.path, "snapshots", "test1.gns3project"))
@pytest.mark.asyncio
async def test_snapshot(project):
"""
Create a snapshot
"""
assert len(project.snapshots) == 0
snapshot = await project.snapshot("test1")
assert snapshot.name == "test1"
assert len(project.snapshots) == 1
assert list(project.snapshots.values())[0].name == "test1"
# Raise a conflict if name is already use
with pytest.raises(ControllerError):
snapshot = await project.snapshot("test1")
@pytest.mark.asyncio
async def test_start_all(project):
compute = MagicMock()
compute.id = "local"
response = MagicMock()
response.json = {"console": 2048}
compute.post = AsyncioMagicMock(return_value=response)
for node_i in range(0, 10):
await project.add_node(compute, "test", None, node_type="vpcs", properties={"startup_config": "test.cfg"})
compute.post = AsyncioMagicMock()
await project.start_all()
assert len(compute.post.call_args_list) == 10
@pytest.mark.asyncio
async def test_stop_all(project):
compute = MagicMock()
compute.id = "local"
response = MagicMock()
response.json = {"console": 2048}
compute.post = AsyncioMagicMock(return_value=response)
for node_i in range(0, 10):
await project.add_node(compute, "test", None, node_type="vpcs", properties={"startup_config": "test.cfg"})
compute.post = AsyncioMagicMock()
await project.stop_all()
assert len(compute.post.call_args_list) == 10
@pytest.mark.asyncio
async def test_stop_all_skips_nodes_with_missing_images(project):
node = MagicMock()
node.is_always_running.return_value = False
node.missing_image = True
node.stop = AsyncioMagicMock()
project._nodes[node.id] = node
await project.stop_all()
node.stop.assert_not_called()
@pytest.mark.asyncio
async def test_suspend_all(project):
compute = MagicMock()
compute.id = "local"
response = MagicMock()
response.json = {"console": 2048}
compute.post = AsyncioMagicMock(return_value=response)
for node_i in range(0, 10):
await project.add_node(compute, "test", None, node_type="vpcs", properties={"startup_config": "test.cfg"})
compute.post = AsyncioMagicMock()
await project.suspend_all()
assert len(compute.post.call_args_list) == 10
@pytest.mark.asyncio
async def test_suspend_all_skips_nodes_with_missing_images(project):
node = MagicMock()
node.missing_image = True
node.suspend = AsyncioMagicMock()
project._nodes[node.id] = node
await project.suspend_all()
node.suspend.assert_not_called()
@pytest.mark.asyncio
async def test_console_reset_all(project):
compute = MagicMock()
compute.id = "local"
response = MagicMock()
response.json = {"console": 2048, "console_type": "telnet"}
compute.post = AsyncioMagicMock(return_value=response)
for node_i in range(0, 10):
await project.add_node(compute, "test", None, node_type="vpcs", properties={"startup_config": "test.cfg"})
compute.post = AsyncioMagicMock()
await project.reset_console_all()
assert len(compute.post.call_args_list) == 10
@pytest.mark.asyncio
async def test_console_reset_all_skips_nodes_with_missing_images(project):
node = MagicMock()
node.missing_image = True
node.reset_console = AsyncioMagicMock()
project._nodes[node.id] = node
await project.reset_console_all()
node.reset_console.assert_not_called()
@pytest.mark.asyncio
async def test_node_name(project):
compute = MagicMock()
compute.id = "local"
response = MagicMock()
response.json = {"console": 2048}
compute.post = AsyncioMagicMock(return_value=response)
node = await project.add_node(
compute, "test-{0}", None, node_type="vpcs", properties={"startup_config": "test.cfg"}
)
assert node.name == "test-1"
node = await project.add_node(
compute, "test-{0}", None, node_type="vpcs", properties={"startup_config": "test.cfg"}
)
assert node.name == "test-2"
node = await project.add_node(
compute, "hello world-{0}", None, node_type="vpcs", properties={"startup_config": "test.cfg"}
)
assert node.name == "helloworld-1"
node = await project.add_node(
compute, "hello world-{0}", None, node_type="vpcs", properties={"startup_config": "test.cfg"}
)
assert node.name == "helloworld-2"
node = await project.add_node(compute, "VPCS-1", None, node_type="vpcs", properties={"startup_config": "test.cfg"})
assert node.name == "VPCS-1"
node = await project.add_node(compute, "VPCS-1", None, node_type="vpcs", properties={"startup_config": "test.cfg"})
assert node.name == "VPCS-2"
node = await project.add_node(compute, "R3", None, node_type="vpcs", properties={"startup_config": "test.cfg"})
assert node.name == "R3"
@pytest.mark.asyncio
async def test_node_name_strict(project):
compute = MagicMock()
compute.id = "local"
response = MagicMock()
response.json = {"console": 2048}
compute.post = AsyncioMagicMock(return_value=response)
node = await project.add_node(compute, "R1", None, node_type="vpcs", strict_names=True)
assert node.name == "R1"
with pytest.raises(ControllerError):
await project.add_node(compute, "R1", None, node_type="vpcs", strict_names=True)
assert len(project.nodes) == 1
node = await project.add_node(compute, "R1", None, node_type="vpcs", strict_names=False)
assert node.name == "R2"
node = await project.add_node(compute, "T{0}", None, node_type="vpcs", strict_names=True)
assert node.name == "T1"
node = await project.add_node(compute, "T{0}", None, node_type="vpcs", strict_names=True)
assert node.name == "T2"
@pytest.mark.asyncio
async def test_node_name_released_when_creation_fails(project):
compute = MagicMock()
compute.id = "local"
compute.post = AsyncioMagicMock(side_effect=ControllerError("failure"))
with pytest.raises(ControllerError):
await project.add_node(compute, "R1", None, node_type="vpcs")
response = MagicMock()
response.json = {"console": 2048}
compute.post = AsyncioMagicMock(return_value=response)
node = await project.add_node(compute, "R1", None, node_type="vpcs", strict_names=True)
assert node.name == "R1"
@pytest.mark.asyncio
async def test_duplicate_node(project):
compute = MagicMock()
compute.id = "local"
response = MagicMock()
response.json = {"console": 2048}
compute.post = AsyncioMagicMock(return_value=response)
original = await project.add_node(
compute, "test", None, node_type="vpcs", properties={"startup_config": "test.cfg"}
)
new_node = await project.duplicate_node(original, 42, 10, 11)
assert new_node.x == 42
@pytest.mark.asyncio
async def test_add_node_missing_image_kept_in_degraded_state(controller):
"""
A node whose image is missing is kept on the controller with the missing
image list instead of failing, when allow_missing_image is set.
"""
compute = MagicMock()
compute.id = "local"
compute.connected = True
project = Project(controller=controller, name="Test")
project.emit_notification = MagicMock()
async def post(url, data=None, **kwargs):
if url.endswith("/qemu/nodes"):
raise ComputeConflictError(
url, {"message": "missing", "image": "missing.qcow2", "exception": "ImageMissingError"}
)
response = MagicMock()
response.json = {}
return response
compute.post = AsyncioMagicMock(side_effect=post)
node = await project.add_node(
compute,
"r1",
None,
node_type="qemu",
allow_missing_image=True,
properties={"hda_disk_image": "missing.qcow2", "ram": 256},
)
assert node.missing_image is True
assert node.id in project._nodes
assert node.missing_images == [{"property": "hda_disk_image", "image": "missing.qcow2", "image_type": "qemu"}]
@pytest.mark.asyncio
async def test_open_with_missing_image_defers_links(controller, projects_dir):
"""
Opening a project with a missing image succeeds, keeps the degraded node
and its links in the topology, but does not create the NIOs.
"""
project_id = "3c1be6f9-b4ba-4737-b209-63c47c23359f"
qemu_id = "11111111-1111-1111-1111-111111111111"
iou_id = "33333333-3333-3333-3333-333333333333"
vpcs_id = "22222222-2222-2222-2222-222222222222"
link_id = "5a3e3a64-e853-4055-9503-4a14e01290f1"
topology = {
"auto_close": True,
"auto_open": False,
"auto_start": False,
"name": "demo",
"project_id": project_id,
"revision": 5,
"topology": {
"computes": [],
"drawings": [],
"links": [
{
"link_id": link_id,
"nodes": [
{"adapter_number": 0, "node_id": qemu_id, "port_number": 0},
{"adapter_number": 0, "node_id": vpcs_id, "port_number": 0},
],
}
],
"nodes": [
{
"compute_id": "local",
"name": "R1",
"node_id": qemu_id,
"node_type": "qemu",
"properties": {"hda_disk_image": "missing.qcow2", "adapters": 1, "ram": 256},
"symbol": ":/symbols/router.svg",
"x": 0,
"y": 0,
},
{
"compute_id": "local",
"name": "IOU1",
"node_id": iou_id,
"node_type": "iou",
"properties": {"path": "missing.bin"},
"symbol": ":/symbols/router.svg",
"x": 200,
"y": 0,
},
{
"compute_id": "local",
"name": "PC1",
"node_id": vpcs_id,
"node_type": "vpcs",
"properties": {},
"symbol": ":/symbols/computer.svg",
"x": 100,
"y": 0,
},
],
},
"type": "topology",
"version": "2.0.0",
}
project_dir = os.path.join(projects_dir, "demo")
os.makedirs(project_dir, exist_ok=True)
with open(os.path.join(project_dir, "demo.gns3"), "w+") as f:
json.dump(topology, f)
compute = MagicMock()
compute.id = "local"
compute.connected = True
compute.name = "local"
compute.console_host = "127.0.0.1"
controller._computes["local"] = compute
async def post(url, data=None, **kwargs):
if url.endswith("/qemu/nodes"):
raise ComputeConflictError(
url, {"message": "missing", "image": "missing.qcow2", "exception": "ImageMissingError"}
)
if url.endswith("/iou/nodes"):
raise ComputeConflictError(
url, {"message": "missing", "image": "missing.bin", "exception": "ImageMissingError"}
)
response = MagicMock()
if "ports/udp/batch" in url:
response.json = {"udp_ports": [20000]}
else:
response.json = {}
return response
compute.post = AsyncioMagicMock(side_effect=post)
project = Project(
name="demo",
project_id=project_id,
path=project_dir,
controller=controller,
filename="demo.gns3",
status="closed",
)
await project.open()
assert project.status == "opened"
qemu_node = project.get_node(qemu_id)
assert qemu_node.missing_image is True
assert qemu_node.missing_images[0]["image"] == "missing.qcow2"
iou_node = project.get_node(iou_id)
assert iou_node.missing_image is True
assert iou_node.missing_images[0]["image"] == "missing.bin"
assert iou_node.missing_images[0]["image_type"] == "iou"
link = project._links[link_id]
assert link._deferred is True
assert link.created is False
assert link in qemu_node.links
@pytest.mark.asyncio
async def test_restore_deferred_links(project):
"""
Once a degraded node is created, the deferred links are created on the
computes and no longer flagged as deferred.
"""
compute = MagicMock()
compute.id = "local"
response = MagicMock()
response.json = {"console": 2048}
compute.post = AsyncioMagicMock(return_value=response)
node1 = await project.add_node(compute, "n1", None, node_type="vpcs", properties={})
node2 = await project.add_node(compute, "n2", None, node_type="vpcs", properties={})
link = await project.add_link()
await link.add_node(node1, 0, 0, batch=True)
await link.add_node(node2, 0, 0, batch=True)
link._nodes[0]["port"].link = link
link._nodes[1]["port"].link = link
node1.add_link(link)
node2.add_link(link)
link._deferred = True
link.create = AsyncioMagicMock()
project.emit_notification = MagicMock()
await project.restore_deferred_links(node1)
assert link._deferred is False
assert link.create.called is True