Explicit ID names, remove {uuid} from URLs and add vms in URLs for VMs.

tests/api/test_project.py

@@ -80,7 +80,7 @@ def test_update_temporary_project(server):
 
 def test_commit_project(server, project):
     with asyncio_patch("gns3server.modules.project.Project.commit", return_value=True) as mock:
-        response = server.post("/projects/{project_id}/commit".format(project_id=project.uuid), example=True)
+        response = server.post("/projects/{project_id}/commit".format(project_id=project.id), example=True)
     assert response.status == 204
     assert mock.called
 
@@ -92,7 +92,7 @@ def test_commit_project_invalid_uuid(server):
 
 def test_delete_project(server, project):
     with asyncio_patch("gns3server.modules.project.Project.delete", return_value=True) as mock:
-        response = server.delete("/projects/{project_id}".format(project_id=project.uuid), example=True)
+        response = server.delete("/projects/{project_id}".format(project_id=project.id), example=True)
         assert response.status == 204
         assert mock.called
 
@@ -104,7 +104,7 @@ def test_delete_project_invalid_uuid(server):
 
 def test_close_project(server, project):
     with asyncio_patch("gns3server.modules.project.Project.close", return_value=True) as mock:
-        response = server.post("/projects/{project_id}/close".format(project_id=project.uuid), example=True)
+        response = server.post("/projects/{project_id}/close".format(project_id=project.id), example=True)
         assert response.status == 204
         assert mock.called
 

tests/api/test_virtualbox.py

@@ -22,10 +22,10 @@ from tests.utils import asyncio_patch
 @pytest.fixture(scope="module")
 def vm(server, project):
     with asyncio_patch("gns3server.modules.virtualbox.virtualbox_vm.VirtualBoxVM.create", return_value=True) as mock:
-        response = server.post("/virtualbox", {"name": "VMTEST",
-                                               "vmname": "VMTEST",
-                                               "linked_clone": False,
-                                               "project_id": project.uuid})
+        response = server.post("/virtualbox/vms", {"name": "VMTEST",
+                                                   "vmname": "VMTEST",
+                                                   "linked_clone": False,
+                                                   "project_id": project.id})
     assert mock.called
     assert response.status == 201
     return response.json
@@ -34,83 +34,83 @@ def vm(server, project):
 def test_vbox_create(server, project):
 
     with asyncio_patch("gns3server.modules.virtualbox.virtualbox_vm.VirtualBoxVM.create", return_value=True):
-        response = server.post("/virtualbox", {"name": "VM1",
-                                               "vmname": "VM1",
-                                               "linked_clone": False,
-                                               "project_id": project.uuid},
+        response = server.post("/virtualbox/vms", {"name": "VM1",
+                                                   "vmname": "VM1",
+                                                   "linked_clone": False,
+                                                   "project_id": project.id},
                                example=True)
         assert response.status == 201
         assert response.json["name"] == "VM1"
-        assert response.json["project_id"] == project.uuid
+        assert response.json["project_id"] == project.id
 
 
 def test_vbox_get(server, project, vm):
-    response = server.get("/virtualbox/{}".format(vm["uuid"]), example=True)
+    response = server.get("/virtualbox/vms/{}".format(vm["vm_id"]), example=True)
     assert response.status == 200
-    assert response.route == "/virtualbox/{uuid}"
+    assert response.route == "/virtualbox/vms/{vm_id}"
     assert response.json["name"] == "VMTEST"
-    assert response.json["project_id"] == project.uuid
+    assert response.json["project_id"] == project.id
 
 
 def test_vbox_start(server, vm):
     with asyncio_patch("gns3server.modules.virtualbox.virtualbox_vm.VirtualBoxVM.start", return_value=True) as mock:
-        response = server.post("/virtualbox/{}/start".format(vm["uuid"]))
+        response = server.post("/virtualbox/vms/{}/start".format(vm["vm_id"]))
         assert mock.called
         assert response.status == 204
 
 
 def test_vbox_stop(server, vm):
     with asyncio_patch("gns3server.modules.virtualbox.virtualbox_vm.VirtualBoxVM.stop", return_value=True) as mock:
-        response = server.post("/virtualbox/{}/stop".format(vm["uuid"]))
+        response = server.post("/virtualbox/vms/{}/stop".format(vm["vm_id"]))
         assert mock.called
         assert response.status == 204
 
 
 def test_vbox_suspend(server, vm):
     with asyncio_patch("gns3server.modules.virtualbox.virtualbox_vm.VirtualBoxVM.suspend", return_value=True) as mock:
-        response = server.post("/virtualbox/{}/suspend".format(vm["uuid"]))
+        response = server.post("/virtualbox/vms/{}/suspend".format(vm["vm_id"]))
         assert mock.called
         assert response.status == 204
 
 
 def test_vbox_resume(server, vm):
     with asyncio_patch("gns3server.modules.virtualbox.virtualbox_vm.VirtualBoxVM.resume", return_value=True) as mock:
-        response = server.post("/virtualbox/{}/resume".format(vm["uuid"]))
+        response = server.post("/virtualbox/vms/{}/resume".format(vm["vm_id"]))
         assert mock.called
         assert response.status == 204
 
 
 def test_vbox_reload(server, vm):
     with asyncio_patch("gns3server.modules.virtualbox.virtualbox_vm.VirtualBoxVM.reload", return_value=True) as mock:
-        response = server.post("/virtualbox/{}/reload".format(vm["uuid"]))
+        response = server.post("/virtualbox/vms/{}/reload".format(vm["vm_id"]))
         assert mock.called
         assert response.status == 204
 
 
 def test_vbox_nio_create_udp(server, vm):
-    response = server.post("/virtualbox/{}/adapters/0/nio".format(vm["uuid"]), {"type": "nio_udp",
-                                                                                "lport": 4242,
-                                                                                "rport": 4343,
-                                                                                "rhost": "127.0.0.1"},
+    response = server.post("/virtualbox/vms/{}/adapters/0/nio".format(vm["vm_id"]), {"type": "nio_udp",
+                                                                                     "lport": 4242,
+                                                                                     "rport": 4343,
+                                                                                     "rhost": "127.0.0.1"},
                            example=True)
     assert response.status == 201
-    assert response.route == "/virtualbox/{uuid}/adapters/{adapter_id:\d+}/nio"
+    assert response.route == "/virtualbox/vms/{vm_id}/adapters/{adapter_id:\d+}/nio"
     assert response.json["type"] == "nio_udp"
 
 
 def test_vbox_delete_nio(server, vm):
-    server.post("/virtualbox/{}/adapters/0/nio".format(vm["uuid"]), {"type": "nio_udp",
-                                                                     "lport": 4242,
-                                                                     "rport": 4343,
-                                                                     "rhost": "127.0.0.1"})
-    response = server.delete("/virtualbox/{}/adapters/0/nio".format(vm["uuid"]), example=True)
+    server.post("/virtualbox/vms/{}/adapters/0/nio".format(vm["vm_id"]), {"type": "nio_udp",
+                                                                          "lport": 4242,
+                                                                          "rport": 4343,
+                                                                          "rhost": "127.0.0.1"})
+    response = server.delete("/virtualbox/vms/{}/adapters/0/nio".format(vm["vm_id"]), example=True)
     assert response.status == 204
-    assert response.route == "/virtualbox/{uuid}/adapters/{adapter_id:\d+}/nio"
+    assert response.route == "/virtualbox/vms/{vm_id}/adapters/{adapter_id:\d+}/nio"
 
 
 def test_vpcs_update(server, vm, free_console_port):
-    response = server.put("/virtualbox/{}".format(vm["uuid"]), {"name": "test",
-                                                                "console": free_console_port})
+    response = server.put("/virtualbox/vms/{}".format(vm["vm_id"]), {"name": "test",
+                                                                     "console": free_console_port})
     assert response.status == 200
     assert response.json["name"] == "test"
     assert response.json["console"] == free_console_port

tests/api/test_vpcs.py

@@ -23,108 +23,108 @@ from unittest.mock import patch
 
 @pytest.fixture(scope="module")
 def vm(server, project):
-    response = server.post("/vpcs", {"name": "PC TEST 1", "project_id": project.uuid})
+    response = server.post("/vpcs/vms", {"name": "PC TEST 1", "project_id": project.id})
     assert response.status == 201
     return response.json
 
 
 def test_vpcs_create(server, project):
-    response = server.post("/vpcs", {"name": "PC TEST 1", "project_id": project.uuid}, example=True)
+    response = server.post("/vpcs/vms", {"name": "PC TEST 1", "project_id": project.id}, example=True)
     assert response.status == 201
-    assert response.route == "/vpcs"
+    assert response.route == "/vpcs/vms"
     assert response.json["name"] == "PC TEST 1"
-    assert response.json["project_id"] == project.uuid
+    assert response.json["project_id"] == project.id
     assert response.json["script_file"] is None
 
 
 def test_vpcs_get(server, project, vm):
-    response = server.get("/vpcs/{}".format(vm["uuid"]), example=True)
+    response = server.get("/vpcs/vms/{}".format(vm["vm_id"]), example=True)
     assert response.status == 200
-    assert response.route == "/vpcs/{uuid}"
+    assert response.route == "/vpcs/vms/{vm_id}"
     assert response.json["name"] == "PC TEST 1"
-    assert response.json["project_id"] == project.uuid
+    assert response.json["project_id"] == project.id
 
 
 def test_vpcs_create_startup_script(server, project):
-    response = server.post("/vpcs", {"name": "PC TEST 1", "project_id": project.uuid, "startup_script": "ip 192.168.1.2\necho TEST"})
+    response = server.post("/vpcs/vms", {"name": "PC TEST 1", "project_id": project.id, "startup_script": "ip 192.168.1.2\necho TEST"})
     assert response.status == 201
-    assert response.route == "/vpcs"
+    assert response.route == "/vpcs/vms"
     assert response.json["name"] == "PC TEST 1"
-    assert response.json["project_id"] == project.uuid
+    assert response.json["project_id"] == project.id
     assert response.json["startup_script"] == "ip 192.168.1.2\necho TEST"
 
 
 def test_vpcs_create_port(server, project, free_console_port):
-    response = server.post("/vpcs", {"name": "PC TEST 1", "project_id": project.uuid, "console": free_console_port})
+    response = server.post("/vpcs/vms", {"name": "PC TEST 1", "project_id": project.id, "console": free_console_port})
     assert response.status == 201
-    assert response.route == "/vpcs"
+    assert response.route == "/vpcs/vms"
     assert response.json["name"] == "PC TEST 1"
-    assert response.json["project_id"] == project.uuid
+    assert response.json["project_id"] == project.id
     assert response.json["console"] == free_console_port
 
 
 def test_vpcs_nio_create_udp(server, vm):
-    response = server.post("/vpcs/{}/ports/0/nio".format(vm["uuid"]), {"type": "nio_udp",
-                                                                       "lport": 4242,
-                                                                       "rport": 4343,
-                                                                       "rhost": "127.0.0.1"},
+    response = server.post("/vpcs/vms/{}/ports/0/nio".format(vm["vm_id"]), {"type": "nio_udp",
+                                                                            "lport": 4242,
+                                                                            "rport": 4343,
+                                                                            "rhost": "127.0.0.1"},
                            example=True)
     assert response.status == 201
-    assert response.route == "/vpcs/{uuid}/ports/{port_number:\d+}/nio"
+    assert response.route == "/vpcs/vms/{vm_id}/ports/{port_number:\d+}/nio"
     assert response.json["type"] == "nio_udp"
 
 
 def test_vpcs_nio_create_tap(server, vm):
     with patch("gns3server.modules.base_manager.BaseManager._has_privileged_access", return_value=True):
-        response = server.post("/vpcs/{}/ports/0/nio".format(vm["uuid"]), {"type": "nio_tap",
-                                                                           "tap_device": "test"})
+        response = server.post("/vpcs/vms/{}/ports/0/nio".format(vm["vm_id"]), {"type": "nio_tap",
+                                                                                "tap_device": "test"})
         assert response.status == 201
-        assert response.route == "/vpcs/{uuid}/ports/{port_number:\d+}/nio"
+        assert response.route == "/vpcs/vms/{vm_id}/ports/{port_number:\d+}/nio"
         assert response.json["type"] == "nio_tap"
 
 
 def test_vpcs_delete_nio(server, vm):
-    server.post("/vpcs/{}/ports/0/nio".format(vm["uuid"]), {"type": "nio_udp",
-                                                            "lport": 4242,
-                                                            "rport": 4343,
-                                                            "rhost": "127.0.0.1"})
-    response = server.delete("/vpcs/{}/ports/0/nio".format(vm["uuid"]), example=True)
+    server.post("/vpcs/vms/{}/ports/0/nio".format(vm["vm_id"]), {"type": "nio_udp",
+                                                                 "lport": 4242,
+                                                                 "rport": 4343,
+                                                                 "rhost": "127.0.0.1"})
+    response = server.delete("/vpcs/vms/{}/ports/0/nio".format(vm["vm_id"]), example=True)
     assert response.status == 204
-    assert response.route == "/vpcs/{uuid}/ports/{port_number:\d+}/nio"
+    assert response.route == "/vpcs/vms/{vm_id}/ports/{port_number:\d+}/nio"
 
 
 def test_vpcs_start(server, vm):
     with asyncio_patch("gns3server.modules.vpcs.vpcs_vm.VPCSVM.start", return_value=True) as mock:
-        response = server.post("/vpcs/{}/start".format(vm["uuid"]))
+        response = server.post("/vpcs/vms/{}/start".format(vm["vm_id"]))
         assert mock.called
         assert response.status == 204
 
 
 def test_vpcs_stop(server, vm):
     with asyncio_patch("gns3server.modules.vpcs.vpcs_vm.VPCSVM.stop", return_value=True) as mock:
-        response = server.post("/vpcs/{}/stop".format(vm["uuid"]))
+        response = server.post("/vpcs/vms/{}/stop".format(vm["vm_id"]))
         assert mock.called
         assert response.status == 204
 
 
 def test_vpcs_reload(server, vm):
     with asyncio_patch("gns3server.modules.vpcs.vpcs_vm.VPCSVM.reload", return_value=True) as mock:
-        response = server.post("/vpcs/{}/reload".format(vm["uuid"]))
+        response = server.post("/vpcs/vms/{}/reload".format(vm["vm_id"]))
         assert mock.called
         assert response.status == 204
 
 
 def test_vpcs_delete(server, vm):
     with asyncio_patch("gns3server.modules.vpcs.VPCS.delete_vm", return_value=True) as mock:
-        response = server.delete("/vpcs/{}".format(vm["uuid"]))
+        response = server.delete("/vpcs/vms/{}".format(vm["vm_id"]))
         assert mock.called
         assert response.status == 204
 
 
 def test_vpcs_update(server, vm, tmpdir, free_console_port):
-    response = server.put("/vpcs/{}".format(vm["uuid"]), {"name": "test",
-                                                          "console": free_console_port,
-                                                          "startup_script": "ip 192.168.1.1"})
+    response = server.put("/vpcs/vms/{}".format(vm["vm_id"]), {"name": "test",
+                                                               "console": free_console_port,
+                                                               "startup_script": "ip 192.168.1.1"})
     assert response.status == 200
     assert response.json["name"] == "test"
     assert response.json["console"] == free_console_port

tests/conftest.py

@@ -84,7 +84,7 @@ def server(request, loop, port_manager):
 def project():
     """A GNS3 lab"""
 
-    return ProjectManager.instance().create_project(uuid="a1e920ca-338a-4e9f-b363-aa607b09dd80")
+    return ProjectManager.instance().create_project(project_id="a1e920ca-338a-4e9f-b363-aa607b09dd80")
 
 
 @pytest.fixture(scope="session")

tests/modules/test_project.py

@@ -42,18 +42,18 @@ def vm(project, manager):
 
 def test_affect_uuid():
     p = Project()
-    assert len(p.uuid) == 36
+    assert len(p.id) == 36
 
-    p = Project(uuid='00010203-0405-0607-0809-0a0b0c0d0e0f')
-    assert p.uuid == '00010203-0405-0607-0809-0a0b0c0d0e0f'
+    p = Project(project_id='00010203-0405-0607-0809-0a0b0c0d0e0f')
+    assert p.id == '00010203-0405-0607-0809-0a0b0c0d0e0f'
 
 
 def test_path(tmpdir):
     with patch("gns3server.config.Config.get_section_config", return_value={"local": True}):
         p = Project(location=str(tmpdir))
-        assert p.path == os.path.join(str(tmpdir), p.uuid)
-        assert os.path.exists(os.path.join(str(tmpdir), p.uuid))
-        assert os.path.exists(os.path.join(str(tmpdir), p.uuid, 'vms'))
+        assert p.path == os.path.join(str(tmpdir), p.id)
+        assert os.path.exists(os.path.join(str(tmpdir), p.id))
+        assert os.path.exists(os.path.join(str(tmpdir), p.id, 'vms'))
         assert not os.path.exists(os.path.join(p.path, '.gns3_temporary'))
 
 
@@ -79,14 +79,14 @@ def test_changing_location_not_allowed(tmpdir):
 
 def test_json(tmpdir):
     p = Project()
-    assert p.__json__() == {"location": p.location, "project_id": p.uuid, "temporary": False}
+    assert p.__json__() == {"location": p.location, "project_id": p.id, "temporary": False}
 
 
 def test_vm_working_directory(tmpdir, vm):
     with patch("gns3server.config.Config.get_section_config", return_value={"local": True}):
         p = Project(location=str(tmpdir))
         assert os.path.exists(p.vm_working_directory(vm))
-        assert os.path.exists(os.path.join(str(tmpdir), p.uuid, vm.module_name, vm.uuid))
+        assert os.path.exists(os.path.join(str(tmpdir), p.id, vm.module_name, vm.id))
 
 
 def test_mark_vm_for_destruction(vm):

tests/modules/test_project_manager.py

@@ -22,7 +22,7 @@ from gns3server.modules.project_manager import ProjectManager
 
 def test_create_project():
     pm = ProjectManager.instance()
-    project = pm.create_project(uuid='00010203-0405-0607-0809-0a0b0c0d0e0f')
+    project = pm.create_project(project_id='00010203-0405-0607-0809-0a0b0c0d0e0f')
     assert project == pm.get_project('00010203-0405-0607-0809-0a0b0c0d0e0f')
 
 

tests/modules/virtualbox/test_virtualbox_vm.py

@@ -39,7 +39,7 @@ def vm(project, manager):
 def test_vm(project, manager):
     vm = VirtualBoxVM("test", "00010203-0405-0607-0809-0a0b0c0d0e0f", project, manager, "test", False)
     assert vm.name == "test"
-    assert vm.uuid == "00010203-0405-0607-0809-0a0b0c0d0e0f"
+    assert vm.id == "00010203-0405-0607-0809-0a0b0c0d0e0f"
     assert vm.vmname == "test"
 
 

tests/modules/vpcs/test_vpcs_manager.py

@@ -30,17 +30,17 @@ def test_get_mac_id(loop, project, port_manager):
     VPCS._instance = None
     vpcs = VPCS.instance()
     vpcs.port_manager = port_manager
-    vm1_uuid = str(uuid.uuid4())
-    vm2_uuid = str(uuid.uuid4())
-    vm3_uuid = str(uuid.uuid4())
-    loop.run_until_complete(vpcs.create_vm("PC 1", project.uuid, vm1_uuid))
-    loop.run_until_complete(vpcs.create_vm("PC 2", project.uuid, vm2_uuid))
-    assert vpcs.get_mac_id(vm1_uuid) == 0
-    assert vpcs.get_mac_id(vm1_uuid) == 0
-    assert vpcs.get_mac_id(vm2_uuid) == 1
-    loop.run_until_complete(vpcs.delete_vm(vm1_uuid))
-    loop.run_until_complete(vpcs.create_vm("PC 3", project.uuid, vm3_uuid))
-    assert vpcs.get_mac_id(vm3_uuid) == 0
+    vm1_id = str(uuid.uuid4())
+    vm2_id = str(uuid.uuid4())
+    vm3_id = str(uuid.uuid4())
+    loop.run_until_complete(vpcs.create_vm("PC 1", project.id, vm1_id))
+    loop.run_until_complete(vpcs.create_vm("PC 2", project.id, vm2_id))
+    assert vpcs.get_mac_id(vm1_id) == 0
+    assert vpcs.get_mac_id(vm1_id) == 0
+    assert vpcs.get_mac_id(vm2_id) == 1
+    loop.run_until_complete(vpcs.delete_vm(vm1_id))
+    loop.run_until_complete(vpcs.create_vm("PC 3", project.id, vm3_id))
+    assert vpcs.get_mac_id(vm3_id) == 0
 
 
 def test_get_mac_id_multiple_project(loop, port_manager):
@@ -48,17 +48,17 @@ def test_get_mac_id_multiple_project(loop, port_manager):
     VPCS._instance = None
     vpcs = VPCS.instance()
     vpcs.port_manager = port_manager
-    vm1_uuid = str(uuid.uuid4())
-    vm2_uuid = str(uuid.uuid4())
-    vm3_uuid = str(uuid.uuid4())
+    vm1_id = str(uuid.uuid4())
+    vm2_id = str(uuid.uuid4())
+    vm3_id = str(uuid.uuid4())
     project1 = ProjectManager.instance().create_project()
     project2 = ProjectManager.instance().create_project()
-    loop.run_until_complete(vpcs.create_vm("PC 1", project1.uuid, vm1_uuid))
-    loop.run_until_complete(vpcs.create_vm("PC 2", project1.uuid, vm2_uuid))
-    loop.run_until_complete(vpcs.create_vm("PC 2", project2.uuid, vm3_uuid))
-    assert vpcs.get_mac_id(vm1_uuid) == 0
-    assert vpcs.get_mac_id(vm2_uuid) == 1
-    assert vpcs.get_mac_id(vm3_uuid) == 0
+    loop.run_until_complete(vpcs.create_vm("PC 1", project1.id, vm1_id))
+    loop.run_until_complete(vpcs.create_vm("PC 2", project1.id, vm2_id))
+    loop.run_until_complete(vpcs.create_vm("PC 2", project2.id, vm3_id))
+    assert vpcs.get_mac_id(vm1_id) == 0
+    assert vpcs.get_mac_id(vm2_id) == 1
+    assert vpcs.get_mac_id(vm3_id) == 0
 
 
 def test_get_mac_id_no_id_available(loop, project, port_manager):
@@ -68,6 +68,6 @@ def test_get_mac_id_no_id_available(loop, project, port_manager):
     vpcs.port_manager = port_manager
     with pytest.raises(VPCSError):
         for i in range(0, 256):
-            vm_uuid = str(uuid.uuid4())
-            loop.run_until_complete(vpcs.create_vm("PC {}".format(i), project.uuid, vm_uuid))
-            assert vpcs.get_mac_id(vm_uuid) == i
+            vm_id = str(uuid.uuid4())
+            loop.run_until_complete(vpcs.create_vm("PC {}".format(i), project.id, vm_id))
+            assert vpcs.get_mac_id(vm_id) == i

tests/modules/vpcs/test_vpcs_vm.py

@@ -43,7 +43,7 @@ def vm(project, manager):
 def test_vm(project, manager):
     vm = VPCSVM("test", "00010203-0405-0607-0809-0a0b0c0d0e0f", project, manager)
     assert vm.name == "test"
-    assert vm.uuid == "00010203-0405-0607-0809-0a0b0c0d0e0f"
+    assert vm.id == "00010203-0405-0607-0809-0a0b0c0d0e0f"
 
 
 def test_vm_invalid_vpcs_version(loop, project, manager):
@@ -54,7 +54,7 @@ def test_vm_invalid_vpcs_version(loop, project, manager):
             vm.port_add_nio_binding(0, nio)
             loop.run_until_complete(asyncio.async(vm.start()))
             assert vm.name == "test"
-            assert vm.uuid == "00010203-0405-0607-0809-0a0b0c0d0e0f"
+            assert vm.id == "00010203-0405-0607-0809-0a0b0c0d0e0f"
 
 
 @patch("gns3server.config.Config.get_section_config", return_value={"vpcs_path": "/bin/test_fake"})
@@ -65,7 +65,7 @@ def test_vm_invalid_vpcs_path(project, manager, loop):
         vm.port_add_nio_binding(0, nio)
         loop.run_until_complete(asyncio.async(vm.start()))
         assert vm.name == "test"
-        assert vm.uuid == "00010203-0405-0607-0809-0a0b0c0d0e0e"
+        assert vm.id == "00010203-0405-0607-0809-0a0b0c0d0e0e"
 
 
 def test_start(loop, vm):