Refactor tests and start work on database integration.

tests/api/routes/compute/test_docker_nodes.py

@@ -17,16 +17,20 @@
 
 import pytest
 import sys
-import uuid
 
+from fastapi import FastAPI, status
+from httpx import AsyncClient
 from tests.utils import asyncio_patch
 from unittest.mock import patch
 
-pytestmark = pytest.mark.skipif(sys.platform.startswith("win"), reason="Not supported on Windows")
+from gns3server.compute.project import Project
+
+pytestmark = [pytest.mark.skipif(sys.platform.startswith("win"), reason="Not supported on Windows"),
+              pytest.mark.asyncio]
 
 
 @pytest.fixture
-def base_params():
+def base_params() -> dict:
     """Return standard parameters"""
 
     params = {
@@ -53,90 +57,96 @@ def base_params():
 
 
 @pytest.fixture
-@pytest.mark.asyncio
-async def vm(compute_api, compute_project, base_params):
+async def vm(app: FastAPI, client: AsyncClient, compute_project: Project, base_params: dict) -> dict:
 
     with asyncio_patch("gns3server.compute.docker.Docker.list_images", return_value=[{"image": "nginx"}]):
         with asyncio_patch("gns3server.compute.docker.Docker.query", return_value={"Id": "8bd8153ea8f5"}):
             with asyncio_patch("gns3server.compute.docker.DockerVM._get_container_state", return_value="exited"):
-                response = await compute_api.post("/projects/{project_id}/docker/nodes".format(project_id=compute_project.id), base_params)
-    assert response.status_code == 201
-    return response.json
+                response = await client.post(app.url_path_for("create_docker_node", project_id=compute_project.id),
+                                             json=base_params)
+    assert response.status_code == status.HTTP_201_CREATED
+    return response.json()
 
 
-@pytest.mark.asyncio
-async def test_docker_create(compute_api, compute_project, base_params):
+async def test_docker_create(app: FastAPI, client: AsyncClient, compute_project: Project, base_params: dict) -> None:
 
     with asyncio_patch("gns3server.compute.docker.Docker.list_images", return_value=[{"image": "nginx"}]):
         with asyncio_patch("gns3server.compute.docker.Docker.query", return_value={"Id": "8bd8153ea8f5"}):
-            response = await compute_api.post("/projects/{project_id}/docker/nodes".format(project_id=compute_project.id), base_params)
-    assert response.status_code == 201
-    assert response.json["name"] == "PC TEST 1"
-    assert response.json["project_id"] == compute_project.id
-    assert response.json["container_id"] == "8bd8153ea8f5"
-    assert response.json["image"] == "nginx:latest"
-    assert response.json["adapters"] == 2
-    assert response.json["environment"] == "YES=1\nNO=0"
-    assert response.json["console_resolution"] == "1280x1024"
-    assert response.json["extra_hosts"] == "test:127.0.0.1"
+            response = await client.post(app.url_path_for("create_docker_node", project_id=compute_project.id),
+                                         json=base_params)
+    assert response.status_code == status.HTTP_201_CREATED
+    assert response.json()["name"] == "PC TEST 1"
+    assert response.json()["project_id"] == compute_project.id
+    assert response.json()["container_id"] == "8bd8153ea8f5"
+    assert response.json()["image"] == "nginx:latest"
+    assert response.json()["adapters"] == 2
+    assert response.json()["environment"] == "YES=1\nNO=0"
+    assert response.json()["console_resolution"] == "1280x1024"
+    assert response.json()["extra_hosts"] == "test:127.0.0.1"
 
 
-@pytest.mark.asyncio
-async def test_docker_start(compute_api, vm):
+async def test_docker_start(app: FastAPI, client: AsyncClient, vm: dict) -> None:
 
     with asyncio_patch("gns3server.compute.docker.docker_vm.DockerVM.start", return_value=True) as mock:
-        response = await compute_api.post("/projects/{project_id}/docker/nodes/{node_id}/start".format(project_id=vm["project_id"], node_id=vm["node_id"]))
+
+        response = await client.post(app.url_path_for("start_docker_node",
+                                                      project_id=vm["project_id"],
+                                                      node_id=vm["node_id"]))
         assert mock.called
-        assert response.status_code == 204
+        assert response.status_code == status.HTTP_204_NO_CONTENT
 
 
-@pytest.mark.asyncio
-async def test_docker_stop(compute_api, vm):
+async def test_docker_stop(app: FastAPI, client: AsyncClient, vm: dict) -> None:
 
     with asyncio_patch("gns3server.compute.docker.docker_vm.DockerVM.stop", return_value=True) as mock:
-        response = await compute_api.post("/projects/{project_id}/docker/nodes/{node_id}/stop".format(project_id=vm["project_id"], node_id=vm["node_id"]))
+        response = await client.post(app.url_path_for("stop_docker_node",
+                                                      project_id=vm["project_id"],
+                                                      node_id=vm["node_id"]))
         assert mock.called
-        assert response.status_code == 204
+        assert response.status_code == status.HTTP_204_NO_CONTENT
 
 
-@pytest.mark.asyncio
-async def test_docker_reload(compute_api, vm):
+async def test_docker_reload(app: FastAPI, client: AsyncClient, vm: dict) -> None:
 
     with asyncio_patch("gns3server.compute.docker.docker_vm.DockerVM.restart", return_value=True) as mock:
-        response = await compute_api.post("/projects/{project_id}/docker/nodes/{node_id}/reload".format(project_id=vm["project_id"], node_id=vm["node_id"]))
+        response = await client.post(app.url_path_for("reload_docker_node",
+                                                      project_id=vm["project_id"],
+                                                      node_id=vm["node_id"]))
         assert mock.called
-        assert response.status_code == 204
+        assert response.status_code == status.HTTP_204_NO_CONTENT
 
 
-@pytest.mark.asyncio
-async def test_docker_delete(compute_api, vm):
+async def test_docker_delete(app: FastAPI, client: AsyncClient, vm: dict) -> None:
 
     with asyncio_patch("gns3server.compute.docker.docker_vm.DockerVM.delete", return_value=True) as mock:
-        response = await compute_api.delete("/projects/{project_id}/docker/nodes/{node_id}".format(project_id=vm["project_id"], node_id=vm["node_id"]))
+        response = await client.delete(app.url_path_for("delete_docker_node",
+                                                        project_id=vm["project_id"],
+                                                        node_id=vm["node_id"]))
         assert mock.called
-        assert response.status_code == 204
+        assert response.status_code == status.HTTP_204_NO_CONTENT
 
 
-@pytest.mark.asyncio
-async def test_docker_pause(compute_api, vm):
+async def test_docker_pause(app: FastAPI, client: AsyncClient, vm: dict) -> None:
 
     with asyncio_patch("gns3server.compute.docker.docker_vm.DockerVM.pause", return_value=True) as mock:
-        response = await compute_api.post("/projects/{project_id}/docker/nodes/{node_id}/pause".format(project_id=vm["project_id"], node_id=vm["node_id"]))
+        response = await client.post(app.url_path_for("pause_docker_node",
+                                                      project_id=vm["project_id"],
+                                                      node_id=vm["node_id"]))
         assert mock.called
-        assert response.status_code == 204
+        assert response.status_code == status.HTTP_204_NO_CONTENT
 
 
-@pytest.mark.asyncio
-async def test_docker_unpause(compute_api, vm):
+async def test_docker_unpause(app: FastAPI, client: AsyncClient, vm: dict) -> None:
 
     with asyncio_patch("gns3server.compute.docker.docker_vm.DockerVM.unpause", return_value=True) as mock:
-        response = await compute_api.post("/projects/{project_id}/docker/nodes/{node_id}/unpause".format(project_id=vm["project_id"], node_id=vm["node_id"]))
+        response = await client.post(app.url_path_for("unpause_docker_node",
+                                                      project_id=vm["project_id"],
+                                                      node_id=vm["node_id"]))
         assert mock.called
-        assert response.status_code == 204
+        assert response.status_code == status.HTTP_204_NO_CONTENT
 
 
-@pytest.mark.asyncio
-async def test_docker_nio_create_udp(compute_api, vm):
+async def test_docker_nio_create_udp(app: FastAPI, client: AsyncClient, vm: dict) -> None:
 
     params = {
         "type": "nio_udp",
@@ -144,13 +154,17 @@ async def test_docker_nio_create_udp(compute_api, vm):
         "rport": 4343,
         "rhost": "127.0.0.1"}
 
-    response = await compute_api.post("/projects/{project_id}/docker/nodes/{node_id}/adapters/0/ports/0/nio".format(project_id=vm["project_id"], node_id=vm["node_id"]), params)
-    assert response.status_code == 201
-    assert response.json["type"] == "nio_udp"
+    url = app.url_path_for("create_docker_node_nio",
+                           project_id=vm["project_id"],
+                           node_id=vm["node_id"],
+                           adapter_number="0",
+                           port_number="0")
+    response = await client.post(url, json=params)
+    assert response.status_code == status.HTTP_201_CREATED
+    assert response.json()["type"] == "nio_udp"
 
 
-@pytest.mark.asyncio
-async def test_docker_update_nio(compute_api, vm):
+async def test_docker_update_nio(app: FastAPI, client: AsyncClient, vm: dict) -> None:
 
     params = {
         "type": "nio_udp",
@@ -159,23 +173,37 @@ async def test_docker_update_nio(compute_api, vm):
         "rhost": "127.0.0.1"
     }
 
-    response = await compute_api.post("/projects/{project_id}/docker/nodes/{node_id}/adapters/0/ports/0/nio".format(project_id=vm["project_id"], node_id=vm["node_id"]), params)
-    assert response.status_code == 201
+    url = app.url_path_for("create_docker_node_nio",
+                           project_id=vm["project_id"],
+                           node_id=vm["node_id"],
+                           adapter_number="0",
+                           port_number="0")
+    response = await client.post(url, json=params)
+    assert response.status_code == status.HTTP_201_CREATED
+
+    url = app.url_path_for("update_docker_node_nio",
+                           project_id=vm["project_id"],
+                           node_id=vm["node_id"],
+                           adapter_number="0",
+                           port_number="0")
     with asyncio_patch("gns3server.compute.docker.docker_vm.DockerVM.adapter_update_nio_binding"):
-        response = await compute_api.put("/projects/{project_id}/docker/nodes/{node_id}/adapters/0/ports/0/nio".format(project_id=vm["project_id"], node_id=vm["node_id"]), params)
-    assert response.status_code == 201, response.body.decode()
+        response = await client.put(url, json=params)
+    assert response.status_code == status.HTTP_201_CREATED
 
 
-@pytest.mark.asyncio
-async def test_docker_delete_nio(compute_api, vm):
+async def test_docker_delete_nio(app: FastAPI, client: AsyncClient, vm: dict) -> None:
 
+    url = app.url_path_for("delete_docker_node_nio",
+                           project_id=vm["project_id"],
+                           node_id=vm["node_id"],
+                           adapter_number="0",
+                           port_number="0")
     with asyncio_patch("gns3server.compute.docker.docker_vm.DockerVM.adapter_remove_nio_binding"):
-        response = await compute_api.delete("/projects/{project_id}/docker/nodes/{node_id}/adapters/0/ports/0/nio".format(project_id=vm["project_id"], node_id=vm["node_id"]))
-    assert response.status_code == 204
+        response = await client.delete(url)
+    assert response.status_code == status.HTTP_204_NO_CONTENT
 
 
-@pytest.mark.asyncio
-async def test_docker_update(compute_api, vm, free_console_port):
+async def test_docker_update(app: FastAPI, client: AsyncClient, vm: dict, free_console_port: int) -> None:
 
     params = {
         "name": "test",
@@ -186,48 +214,62 @@ async def test_docker_update(compute_api, vm, free_console_port):
     }
 
     with asyncio_patch("gns3server.compute.docker.docker_vm.DockerVM.update") as mock:
-        response = await compute_api.put("/projects/{project_id}/docker/nodes/{node_id}".format(project_id=vm["project_id"], node_id=vm["node_id"]), params)
+        response = await client.put(app.url_path_for("update_docker_node",
+                                                     project_id=vm["project_id"],
+                                                     node_id=vm["node_id"]), json=params)
 
     assert response.status_code == 200
     assert mock.called
-    assert response.json["name"] == "test"
-    assert response.json["console"] == free_console_port
-    assert response.json["start_command"] == "yes"
-    assert response.json["environment"] == "GNS3=1\nGNS4=0"
-    assert response.json["extra_hosts"] == "test:127.0.0.1"
+    assert response.json()["name"] == "test"
+    assert response.json()["console"] == free_console_port
+    assert response.json()["start_command"] == "yes"
+    assert response.json()["environment"] == "GNS3=1\nGNS4=0"
+    assert response.json()["extra_hosts"] == "test:127.0.0.1"
 
 
-@pytest.mark.asyncio
-async def test_docker_start_capture(compute_api, vm):
+async def test_docker_start_capture(app: FastAPI, client: AsyncClient, vm: dict) -> None:
+
+    url = app.url_path_for("start_docker_node_capture",
+                           project_id=vm["project_id"],
+                           node_id=vm["node_id"],
+                           adapter_number="0",
+                           port_number="0")
 
     with patch("gns3server.compute.docker.docker_vm.DockerVM.is_running", return_value=True):
         with asyncio_patch("gns3server.compute.docker.docker_vm.DockerVM.start_capture") as mock:
             params = {"capture_file_name": "test.pcap", "data_link_type": "DLT_EN10MB"}
-            response = await compute_api.post("/projects/{project_id}/docker/nodes/{node_id}/adapters/0/ports/0/capture/start".format(project_id=vm["project_id"], node_id=vm["node_id"]), body=params)
-            assert response.status_code == 200
+            response = await client.post(url, json=params)
+            assert response.status_code == status.HTTP_200_OK
             assert mock.called
-            assert "test.pcap" in response.json["pcap_file_path"]
+            assert "test.pcap" in response.json()["pcap_file_path"]
 
 
-@pytest.mark.asyncio
-async def test_docker_stop_capture(compute_api, vm):
+async def test_docker_stop_capture(app: FastAPI, client: AsyncClient, vm: dict) -> None:
+
+    url = app.url_path_for("stop_docker_node_capture",
+                           project_id=vm["project_id"],
+                           node_id=vm["node_id"],
+                           adapter_number="0",
+                           port_number="0")
 
     with patch("gns3server.compute.docker.docker_vm.DockerVM.is_running", return_value=True):
         with asyncio_patch("gns3server.compute.docker.docker_vm.DockerVM.stop_capture") as mock:
-            response = await compute_api.post("/projects/{project_id}/docker/nodes/{node_id}/adapters/0/ports/0/capture/stop".format(project_id=vm["project_id"], node_id=vm["node_id"]))
-            assert response.status_code == 204
+            response = await client.post(url)
+            assert response.status_code == status.HTTP_204_NO_CONTENT
             assert mock.called
 
 
-@pytest.mark.asyncio
-async def test_docker_duplicate(compute_api, compute_project, base_params, vm):
+async def test_docker_duplicate(app: FastAPI, client: AsyncClient, vm: dict, base_params: dict) -> None:
 
     # create destination node first
     with asyncio_patch("gns3server.compute.docker.Docker.list_images", return_value=[{"image": "nginx"}]):
         with asyncio_patch("gns3server.compute.docker.Docker.query", return_value={"Id": "8bd8153ea8f5"}):
-            response = await compute_api.post("/projects/{project_id}/docker/nodes".format(project_id=compute_project.id), base_params)
-    assert response.status_code == 201
+            response = await client.post(app.url_path_for("create_docker_node",
+                                                          project_id=vm["project_id"]), json=base_params)
+    assert response.status_code == status.HTTP_201_CREATED
 
-    params = {"destination_node_id": response.json["node_id"]}
-    response = await compute_api.post("/projects/{project_id}/docker/nodes/{node_id}/duplicate".format(project_id=vm["project_id"], node_id=vm["node_id"]), params)
-    assert response.status_code == 201
+    params = {"destination_node_id": response.json()["node_id"]}
+    response = await client.post(app.url_path_for("duplicate_docker_node",
+                                                  project_id=vm["project_id"],
+                                                  node_id=vm["node_id"]), json=params)
+    assert response.status_code == status.HTTP_201_CREATED