Check topology schema when loading/saving it

Fix #583

tests/controller/test_compute.py

@@ -160,7 +160,7 @@ def test_compute_httpQuery_project(compute, async_run):
     with asyncio_patch("aiohttp.ClientSession.request", return_value=response) as mock:
         response.status = 200
 
-        project = Project()
+        project = Project(name="Test")
         async_run(compute.post("/projects", project))
         mock.assert_called_with("POST", "https://example.com:84/v2/compute/projects", data=json.dumps(project.__json__()), headers={'content-type': 'application/json'}, auth=None, chunked=False)
 

tests/controller/test_controller.py

@@ -168,15 +168,15 @@ def test_initControllerLocal(controller, controller_config_path, async_run):
     assert len(c._computes) == 1
 
 
-def test_addProject(controller, async_run):
+def test_add_project(controller, async_run):
     uuid1 = str(uuid.uuid4())
     uuid2 = str(uuid.uuid4())
 
-    async_run(controller.add_project(project_id=uuid1))
+    async_run(controller.add_project(project_id=uuid1, name="Test"))
     assert len(controller.projects) == 1
-    async_run(controller.add_project(project_id=uuid1))
+    async_run(controller.add_project(project_id=uuid1, name="Test"))
     assert len(controller.projects) == 1
-    async_run(controller.add_project(project_id=uuid2))
+    async_run(controller.add_project(project_id=uuid2, name="Test 2"))
     assert len(controller.projects) == 2
 
 
@@ -193,7 +193,7 @@ def test_addDuplicateProject(controller, async_run):
 def test_remove_project(controller, async_run):
     uuid1 = str(uuid.uuid4())
 
-    project1 = async_run(controller.add_project(project_id=uuid1))
+    project1 = async_run(controller.add_project(project_id=uuid1, name="Test"))
     assert len(controller.projects) == 1
 
     controller.remove_project(project1)
@@ -207,13 +207,13 @@ def test_addProject_with_compute(controller, async_run):
     compute.post = MagicMock()
     controller._computes = {"test1": compute}
 
-    project1 = async_run(controller.add_project(project_id=uuid1))
+    project1 = async_run(controller.add_project(project_id=uuid1, name="Test"))
 
 
 def test_getProject(controller, async_run):
     uuid1 = str(uuid.uuid4())
 
-    project = async_run(controller.add_project(project_id=uuid1))
+    project = async_run(controller.add_project(project_id=uuid1, name="Test"))
     assert controller.get_project(uuid1) == project
     with pytest.raises(aiohttp.web.HTTPNotFound):
         assert controller.get_project("dsdssd")
@@ -234,6 +234,7 @@ def test_load_project(controller, async_run, tmpdir):
         "type": "topology",
         "version": "2.0.0dev1",
         "topology": {
+            "drawings": [],
             "computes": [
                 {
                     "compute_id": "my_remote",

tests/controller/test_drawing.py

@@ -28,7 +28,7 @@ from gns3server.controller.project import Project
 
 @pytest.fixture
 def project(controller, async_run):
-    return async_run(controller.add_project())
+    return async_run(controller.add_project(name="Test"))
 
 
 @pytest.fixture

tests/controller/test_link.py

@@ -31,7 +31,7 @@ from tests.utils import AsyncioBytesIO, AsyncioMagicMock
 
 @pytest.fixture
 def project(controller):
-    return Project(controller=controller)
+    return Project(controller=controller, name="Test")
 
 
 @pytest.fixture
@@ -41,8 +41,8 @@ def compute():
 
 @pytest.fixture
 def link(async_run, project, compute):
-    node1 = Node(project, compute, "node1")
-    node2 = Node(project, compute, "node2")
+    node1 = Node(project, compute, "node1", node_type="qemu")
+    node2 = Node(project, compute, "node2", node_type="qemu")
 
     link = Link(project)
     async_run(link.add_node(node1, 0, 4))
@@ -57,7 +57,7 @@ def test_eq(project, link, controller):
 
 
 def test_add_node(async_run, project, compute):
-    node1 = Node(project, compute, "node1")
+    node1 = Node(project, compute, "node1", node_type="qemu")
 
     link = Link(project)
     link._project.controller.notification.emit = MagicMock()
@@ -81,14 +81,14 @@ def test_add_node(async_run, project, compute):
     assert not link._project.controller.notification.emit.called
 
     # We call link.created only when both side are created
-    node2 = Node(project, compute, "node2")
+    node2 = Node(project, compute, "node2", node_type="qemu")
     async_run(link.add_node(node2, 0, 4))
 
     link._project.controller.notification.emit.assert_called_with("link.created", link.__json__())
 
 
 def test_update_nodes(async_run, project, compute):
-    node1 = Node(project, compute, "node1")
+    node1 = Node(project, compute, "node1", node_type="qemu")
     project._nodes[node1.id] = node1
 
     link = Link(project)
@@ -109,8 +109,8 @@ def test_update_nodes(async_run, project, compute):
 
 
 def test_json(async_run, project, compute):
-    node1 = Node(project, compute, "node1")
-    node2 = Node(project, compute, "node2")
+    node1 = Node(project, compute, "node1", node_type="qemu")
+    node2 = Node(project, compute, "node2", node_type="qemu")
 
     link = Link(project)
     async_run(link.add_node(node1, 0, 4))
@@ -197,8 +197,8 @@ def test_start_streaming_pcap(link, async_run, tmpdir, project):
 
 
 def test_default_capture_file_name(project, compute, async_run):
-    node1 = Node(project, compute, "Hello@")
-    node2 = Node(project, compute, "w0.rld")
+    node1 = Node(project, compute, "Hello@", node_type="qemu")
+    node2 = Node(project, compute, "w0.rld", node_type="qemu")
 
     link = Link(project)
     async_run(link.add_node(node1, 0, 4))

tests/controller/test_node.py

@@ -51,10 +51,10 @@ def node(compute, project):
 
 
 def test_eq(compute, project, node, controller):
-    assert node == Node(project, compute, "demo", node_id=node.id)
+    assert node == Node(project, compute, "demo", node_id=node.id, node_type="qemu")
     assert node != "a"
-    assert node != Node(project, compute, "demo", node_id=str(uuid.uuid4()))
-    assert node != Node( Project(str(uuid.uuid4()), controller=controller), compute, "demo", node_id=node.id)
+    assert node != Node(project, compute, "demo", node_id=str(uuid.uuid4()), node_type="qemu")
+    assert node != Node(Project(str(uuid.uuid4()), controller=controller), compute, "demo", node_id=node.id, node_type="qemu")
 
 
 def test_json(node, compute):

tests/controller/test_notification.py

@@ -25,7 +25,7 @@ from tests.utils import AsyncioMagicMock
 
 @pytest.fixture
 def project(async_run):
-    return async_run(Controller.instance().add_project())
+    return async_run(Controller.instance().add_project(name="Test"))
 
 
 @pytest.fixture

tests/controller/test_project.py

@@ -30,20 +30,20 @@ from gns3server.config import Config
 
 @pytest.fixture
 def project(controller):
-    return Project(controller=controller)
+    return Project(controller=controller, name="Test")
 
 
 def test_affect_uuid():
-    p = Project()
+    p = Project(name="Test")
     assert len(p.id) == 36
 
-    p = Project(project_id='00010203-0405-0607-0809-0a0b0c0d0e0f')
+    p = Project(project_id='00010203-0405-0607-0809-0a0b0c0d0e0f', name="Test 2")
     assert p.id == '00010203-0405-0607-0809-0a0b0c0d0e0f'
 
 
 def test_json(tmpdir):
-    p = Project()
-    assert p.__json__() == {"name": p.name, "project_id": p.id, "path": p.path, "status": "opened", "filename": "project.gns3"}
+    p = Project(name="Test")
+    assert p.__json__() == {"name": "Test", "project_id": p.id, "path": p.path, "status": "opened", "filename": "Test.gns3"}
 
 
 def test_path(tmpdir):
@@ -51,25 +51,25 @@ def test_path(tmpdir):
     directory = Config.instance().get_section_config("Server").get("projects_path")
 
     with patch("gns3server.utils.path.get_default_project_directory", return_value=directory):
-        p = Project(project_id=str(uuid4()))
+        p = Project(project_id=str(uuid4()), name="Test")
         assert p.path == os.path.join(directory, p.id)
         assert os.path.exists(os.path.join(directory, p.id))
 
 
 def test_init_path(tmpdir):
 
-    p = Project(path=str(tmpdir), project_id=str(uuid4()))
+    p = Project(path=str(tmpdir), project_id=str(uuid4()), name="Test")
     assert p.path == str(tmpdir)
 
 
 def test_changing_path_with_quote_not_allowed(tmpdir):
     with pytest.raises(aiohttp.web.HTTPForbidden):
-        p = Project(project_id=str(uuid4()))
+        p = Project(project_id=str(uuid4()), name="Test")
         p.path = str(tmpdir / "project\"53")
 
 
 def test_captures_directory(tmpdir):
-    p = Project(path=str(tmpdir))
+    p = Project(path=str(tmpdir), name="Test")
     assert p.captures_directory == str(tmpdir / "project-files" / "captures")
     assert os.path.exists(p.captures_directory)
 
@@ -80,7 +80,7 @@ def test_add_node_local(async_run, controller):
     """
     compute = MagicMock()
     compute.id = "local"
-    project = Project(controller=controller)
+    project = Project(controller=controller, name="Test")
     controller._notification = MagicMock()
 
     response = MagicMock()
@@ -109,7 +109,7 @@ def test_add_node_non_local(async_run, controller):
     """
     compute = MagicMock()
     compute.id = "remote"
-    project = Project(controller=controller)
+    project = Project(controller=controller, name="Test")
     controller._notification = MagicMock()
 
     response = MagicMock()
@@ -135,7 +135,7 @@ def test_delete_node(async_run, controller):
     For a local server we send the project path
     """
     compute = MagicMock()
-    project = Project(controller=controller)
+    project = Project(controller=controller, name="Test")
     controller._notification = MagicMock()
 
     response = MagicMock()
@@ -156,7 +156,7 @@ def test_delete_node_delete_link(async_run, controller):
     Delete a node delete all the node connected
     """
     compute = MagicMock()
-    project = Project(controller=controller)
+    project = Project(controller=controller, name="Test")
     controller._notification = MagicMock()
 
     response = MagicMock()
@@ -179,7 +179,7 @@ def test_delete_node_delete_link(async_run, controller):
 
 def test_getVM(async_run, controller):
     compute = MagicMock()
-    project = Project(controller=controller)
+    project = Project(controller=controller, name="Test")
 
     response = MagicMock()
     response.json = {"console": 2048}
@@ -283,7 +283,7 @@ def test_dump():
 
 
 def test_open_close(async_run, controller):
-    project = Project(controller=controller, status="closed")
+    project = Project(controller=controller, status="closed", name="Test")
     assert project.status == "closed"
     async_run(project.open())
     assert project.status == "opened"

tests/controller/test_topology.py

@@ -16,6 +16,7 @@
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 import json
+import uuid
 import pytest
 import aiohttp
 from unittest.mock import MagicMock
@@ -23,7 +24,7 @@ from tests.utils import asyncio_patch
 
 from gns3server.controller.project import Project
 from gns3server.controller.compute import Compute
-from gns3server.controller.topology import project_to_topology, load_topology
+from gns3server.controller.topology import project_to_topology, load_topology, GNS3_FILE_FORMAT_REVISION
 from gns3server.version import __version__
 
 
@@ -51,8 +52,8 @@ def test_basic_topology(tmpdir, async_run, controller):
     compute.http_query = MagicMock()
 
     with asyncio_patch("gns3server.controller.node.Node.create"):
-        node1 = async_run(project.add_node(compute, "Node 1", "node_1"))
-        node2 = async_run(project.add_node(compute, "Node 2", "node_2"))
+        node1 = async_run(project.add_node(compute, "Node 1", str(uuid.uuid4()), node_type="qemu"))
+        node2 = async_run(project.add_node(compute, "Node 2", str(uuid.uuid4()), node_type="qemu"))
 
     link = async_run(project.add_link())
     async_run(link.add_node(node1, 0, 0))
@@ -95,6 +96,16 @@ def test_load_topology_file_error(tmpdir):
         topo = load_topology(path)
 
 
+def test_load_topology_file_error_schema_error(tmpdir):
+    path = str(tmpdir / "test.gns3")
+    with open(path, "w+") as f:
+        json.dump({
+            "revision": GNS3_FILE_FORMAT_REVISION
+        }, f)
+    with pytest.raises(aiohttp.web.HTTPConflict):
+        topo = load_topology(path)
+
+
 def test_load_old_topology(tmpdir):
     data = {
         "project_id": "69f26504-7aa3-48aa-9f29-798d44841211",

tests/controller/test_udp_link.py

@@ -28,7 +28,7 @@ from gns3server.controller.node import Node
 
 @pytest.fixture
 def project(controller):
-    return Project(controller=controller)
+    return Project(controller=controller, name="Test")
 
 
 def test_create(async_run, project):

tests/handlers/api/controller/test_drawing.py

@@ -35,7 +35,7 @@ from gns3server.controller.drawing import Drawing
 
 @pytest.fixture
 def project(http_controller, async_run):
-    return async_run(Controller.instance().add_project())
+    return async_run(Controller.instance().add_project(name="Test"))
 
 
 def test_create_drawing(http_controller, tmpdir, project, async_run):

tests/handlers/api/controller/test_link.py

@@ -45,7 +45,7 @@ def compute(http_controller, async_run):
 
 @pytest.fixture
 def project(http_controller, async_run):
-    return async_run(Controller.instance().add_project())
+    return async_run(Controller.instance().add_project(name="Test"))
 
 
 def test_create_link(http_controller, tmpdir, project, compute, async_run):
@@ -53,8 +53,8 @@ def test_create_link(http_controller, tmpdir, project, compute, async_run):
     response.json = {"console": 2048}
     compute.post = AsyncioMagicMock(return_value=response)
 
-    node1 = async_run(project.add_node(compute, "node1", None))
-    node2 = async_run(project.add_node(compute, "node2", None))
+    node1 = async_run(project.add_node(compute, "node1", None, node_type="qemu"))
+    node2 = async_run(project.add_node(compute, "node2", None, node_type="qemu"))
 
     with asyncio_patch("gns3server.controller.udp_link.UDPLink.create") as mock:
         response = http_controller.post("/projects/{}/links".format(project.id), {
@@ -88,8 +88,8 @@ def test_update_link(http_controller, tmpdir, project, compute, async_run):
     response.json = {"console": 2048}
     compute.post = AsyncioMagicMock(return_value=response)
 
-    node1 = async_run(project.add_node(compute, "node1", None))
-    node2 = async_run(project.add_node(compute, "node2", None))
+    node1 = async_run(project.add_node(compute, "node1", None, node_type="qemu"))
+    node2 = async_run(project.add_node(compute, "node2", None, node_type="qemu"))
 
     with asyncio_patch("gns3server.controller.udp_link.UDPLink.create") as mock:
         response = http_controller.post("/projects/{}/links".format(project.id), {
@@ -141,8 +141,8 @@ def test_list_link(http_controller, tmpdir, project, compute, async_run):
     response.json = {"console": 2048}
     compute.post = AsyncioMagicMock(return_value=response)
 
-    node1 = async_run(project.add_node(compute, "node1", None))
-    node2 = async_run(project.add_node(compute, "node2", None))
+    node1 = async_run(project.add_node(compute, "node1", None, node_type="qemu"))
+    node2 = async_run(project.add_node(compute, "node2", None, node_type="qemu"))
 
     with asyncio_patch("gns3server.controller.udp_link.UDPLink.create") as mock:
         response = http_controller.post("/projects/{}/links".format(project.id), {

tests/handlers/api/controller/test_node.py

@@ -45,7 +45,7 @@ def compute(http_controller, async_run):
 
 @pytest.fixture
 def project(http_controller, async_run):
-    return async_run(Controller.instance().add_project())
+    return async_run(Controller.instance().add_project(name="Test"))
 
 
 @pytest.fixture