Refactoring to use a common node class for all VMs and other (future) objects.

tests/handlers/api/controller/test_link.py

@@ -31,7 +31,7 @@ from tests.utils import asyncio_patch, AsyncioMagicMock
 
 from gns3server.handlers.api.controller.project_handler import ProjectHandler
 from gns3server.controller import Controller
-from gns3server.controller.vm import VM
+from gns3server.controller.node import Node
 from gns3server.controller.link import Link
 
 
@@ -53,19 +53,19 @@ def test_create_link(http_controller, tmpdir, project, compute, async_run):
     response.json = {"console": 2048}
     compute.post = AsyncioMagicMock(return_value=response)
 
-    vm1 = async_run(project.addVM(compute, None))
-    vm2 = async_run(project.addVM(compute, None))
+    node1 = async_run(project.add_node(compute, None))
+    node2 = async_run(project.add_node(compute, None))
 
     with asyncio_patch("gns3server.controller.udp_link.UDPLink.create") as mock:
         response = http_controller.post("/projects/{}/links".format(project.id), {
-            "vms": [
+            "nodes": [
                 {
-                    "vm_id": vm1.id,
+                    "node_id": node1.id,
                     "adapter_number": 0,
                     "port_number": 3
                 },
                 {
-                    "vm_id": vm2.id,
+                    "node_id": node2.id,
                     "adapter_number": 2,
                     "port_number": 4
                 }
@@ -74,7 +74,7 @@ def test_create_link(http_controller, tmpdir, project, compute, async_run):
     assert mock.called
     assert response.status == 201
     assert response.json["link_id"] is not None
-    assert len(response.json["vms"]) == 2
+    assert len(response.json["nodes"]) == 2
 
 
 def test_start_capture(http_controller, tmpdir, project, compute, async_run):

tests/handlers/api/controller/test_node.py

@@ -31,7 +31,7 @@ from tests.utils import asyncio_patch, AsyncioMagicMock
 
 from gns3server.handlers.api.controller.project_handler import ProjectHandler
 from gns3server.controller import Controller
-from gns3server.controller.vm import VM
+from gns3server.controller.node import Node
 
 
 @pytest.fixture
@@ -48,20 +48,20 @@ def project(http_controller, async_run):
 
 
 @pytest.fixture
-def vm(project, compute, async_run):
-    vm = VM(project, compute, name="test", vm_type="vpcs")
-    project._vms[vm.id] = vm
-    return vm
+def node(project, compute, async_run):
+    node = Node(project, compute, name="test", node_type="vpcs")
+    project._nodes[node.id] = node
+    return node
 
 
-def test_create_vm(http_controller, tmpdir, project, compute):
+def test_create_node(http_controller, tmpdir, project, compute):
     response = MagicMock()
     response.json = {"console": 2048}
     compute.post = AsyncioMagicMock(return_value=response)
 
-    response = http_controller.post("/projects/{}/vms".format(project.id), {
+    response = http_controller.post("/projects/{}/nodes".format(project.id), {
         "name": "test",
-        "vm_type": "vpcs",
+        "node_type": "vpcs",
         "compute_id": "example.com",
         "properties": {
                 "startup_script": "echo test"
@@ -72,32 +72,32 @@ def test_create_vm(http_controller, tmpdir, project, compute):
     assert "name" not in response.json["properties"]
 
 
-def test_list_vm(http_controller, tmpdir, project, compute):
+def test_list_node(http_controller, tmpdir, project, compute):
     response = MagicMock()
     response.json = {"console": 2048}
     compute.post = AsyncioMagicMock(return_value=response)
 
-    response = http_controller.post("/projects/{}/vms".format(project.id), {
+    response = http_controller.post("/projects/{}/nodes".format(project.id), {
         "name": "test",
-        "vm_type": "vpcs",
+        "node_type": "vpcs",
         "compute_id": "example.com",
         "properties": {
                 "startup_script": "echo test"
         }
     })
-    response = http_controller.get("/projects/{}/vms".format(project.id), example=True)
+    response = http_controller.get("/projects/{}/nodes".format(project.id), example=True)
     assert response.status == 200
     assert response.json[0]["name"] == "test"
 
 
-def test_update_vm(http_controller, tmpdir, project, compute, vm):
+def test_update_node(http_controller, tmpdir, project, compute, node):
     response = MagicMock()
     response.json = {"console": 2048}
     compute.put = AsyncioMagicMock(return_value=response)
 
-    response = http_controller.put("/projects/{}/vms/{}".format(project.id, vm.id), {
+    response = http_controller.put("/projects/{}/nodes/{}".format(project.id, node.id), {
         "name": "test",
-        "vm_type": "vpcs",
+        "node_type": "vpcs",
         "compute_id": "example.com",
         "properties": {
                 "startup_script": "echo test"
@@ -108,45 +108,45 @@ def test_update_vm(http_controller, tmpdir, project, compute, vm):
     assert "name" not in response.json["properties"]
 
 
-def test_start_vm(http_controller, tmpdir, project, compute, vm):
+def test_start_node(http_controller, tmpdir, project, compute, node):
     response = MagicMock()
     compute.post = AsyncioMagicMock()
 
-    response = http_controller.post("/projects/{}/vms/{}/start".format(project.id, vm.id), example=True)
+    response = http_controller.post("/projects/{}/nodes/{}/start".format(project.id, node.id), example=True)
     assert response.status == 201
-    assert response.json["name"] == vm.name
+    assert response.json["name"] == node.name
 
 
-def test_stop_vm(http_controller, tmpdir, project, compute, vm):
+def test_stop_node(http_controller, tmpdir, project, compute, node):
     response = MagicMock()
     compute.post = AsyncioMagicMock()
 
-    response = http_controller.post("/projects/{}/vms/{}/stop".format(project.id, vm.id), example=True)
+    response = http_controller.post("/projects/{}/nodes/{}/stop".format(project.id, node.id), example=True)
     assert response.status == 201
-    assert response.json["name"] == vm.name
+    assert response.json["name"] == node.name
 
 
-def test_suspend_vm(http_controller, tmpdir, project, compute, vm):
+def test_suspend_node(http_controller, tmpdir, project, compute, node):
     response = MagicMock()
     compute.post = AsyncioMagicMock()
 
-    response = http_controller.post("/projects/{}/vms/{}/suspend".format(project.id, vm.id), example=True)
+    response = http_controller.post("/projects/{}/nodes/{}/suspend".format(project.id, node.id), example=True)
     assert response.status == 201
-    assert response.json["name"] == vm.name
+    assert response.json["name"] == node.name
 
 
-def test_reload_vm(http_controller, tmpdir, project, compute, vm):
+def test_reload_node(http_controller, tmpdir, project, compute, node):
     response = MagicMock()
     compute.post = AsyncioMagicMock()
 
-    response = http_controller.post("/projects/{}/vms/{}/reload".format(project.id, vm.id), example=True)
+    response = http_controller.post("/projects/{}/nodes/{}/reload".format(project.id, node.id), example=True)
     assert response.status == 201
-    assert response.json["name"] == vm.name
+    assert response.json["name"] == node.name
 
 
-def test_delete_vm(http_controller, tmpdir, project, compute, vm):
+def test_delete_node(http_controller, tmpdir, project, compute, node):
     response = MagicMock()
     compute.post = AsyncioMagicMock()
 
-    response = http_controller.delete("/projects/{}/vms/{}".format(project.id, vm.id), example=True)
+    response = http_controller.delete("/projects/{}/nodes/{}".format(project.id, node.id), example=True)
     assert response.status == 201

tests/handlers/api/controller/test_project.py

@@ -39,7 +39,7 @@ def project(http_controller):
     u = str(uuid.uuid4())
     query = {"name": "test", "project_id": u}
     response = http_controller.post("/projects", query)
-    return Controller.instance().getProject(u)
+    return Controller.instance().get_project(u)
 
 
 def test_create_project_with_path(http_controller, tmpdir):
@@ -126,7 +126,7 @@ def test_notification(http_controller, project, loop):
     def go(future):
         response = yield from aiohttp.request("GET", http_controller.get_url("/projects/{project_id}/notifications".format(project_id=project.id)))
         response.body = yield from response.content.read(200)
-        project.emit("vm.created", {"a": "b"})
+        project.emit("node.created", {"a": "b"})
         response.body += yield from response.content.read(50)
         response.close()
         future.set_result(response)
@@ -137,7 +137,7 @@ def test_notification(http_controller, project, loop):
     assert response.status == 200
     assert b'"action": "ping"' in response.body
     assert b'"cpu_usage_percent"' in response.body
-    assert b'{"action": "vm.created", "event": {"a": "b"}}\n' in response.body
+    assert b'{"action": "node.created", "event": {"a": "b"}}\n' in response.body
 
 
 def test_notification_invalid_id(http_controller):