Refactor tests and start work on database integration.

tests/api/routes/controller/test_appliances.py

@@ -17,10 +17,14 @@
 
 import pytest
 
+from fastapi import FastAPI, status
+from httpx import AsyncClient
 
-@pytest.mark.asyncio
-async def test_appliances_list(controller_api):
+pytestmark = pytest.mark.asyncio
 
-    response = await controller_api.get("/appliances/")
-    assert response.status_code == 200
-    assert len(response.json) > 0
+
+async def test_appliances_list(app: FastAPI, client: AsyncClient) -> None:
+
+    response = await client.get(app.url_path_for("get_appliances"))
+    assert response.status_code == status.HTTP_200_OK
+    assert len(response.json()) > 0

tests/api/routes/controller/test_computes.py

@@ -16,11 +16,19 @@
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 import pytest
+
+from fastapi import FastAPI, status
+from httpx import AsyncClient
+
+from gns3server.controller import Controller
+
+pytestmark = pytest.mark.asyncio
+
 import unittest
 from tests.utils import asyncio_patch
 
-@pytest.mark.asyncio
-async def test_compute_create_without_id(controller_api, controller):
+
+async def test_compute_create_without_id(app: FastAPI, client: AsyncClient, controller: Controller) -> None:
 
     params = {
         "protocol": "http",
@@ -29,17 +37,17 @@ async def test_compute_create_without_id(controller_api, controller):
         "user": "julien",
         "password": "secure"}
 
-    response = await controller_api.post("/computes", params)
-    assert response.status_code == 201
-    assert response.json["user"] == "julien"
-    assert response.json["compute_id"] is not None
-    assert "password" not in response.json
+    response = await client.post(app.url_path_for("create_compute"), json=params)
+    assert response.status_code == status.HTTP_201_CREATED
+    response_content = response.json()
+    assert response_content["user"] == "julien"
+    assert response_content["compute_id"] is not None
+    assert "password" not in response_content
     assert len(controller.computes) == 1
-    assert controller.computes[response.json["compute_id"]].host == "localhost"
+    assert controller.computes[response_content["compute_id"]].host == "localhost"
 
 
-@pytest.mark.asyncio
-async def test_compute_create_with_id(controller_api, controller):
+async def test_compute_create_with_id(app: FastAPI, client: AsyncClient, controller: Controller) -> None:
 
     params = {
         "compute_id": "my_compute_id",
@@ -49,16 +57,15 @@ async def test_compute_create_with_id(controller_api, controller):
         "user": "julien",
         "password": "secure"}
 
-    response = await controller_api.post("/computes", params)
-    assert response.status_code == 201
-    assert response.json["user"] == "julien"
-    assert "password" not in response.json
+    response = await client.post(app.url_path_for("create_compute"), json=params)
+    assert response.status_code == status.HTTP_201_CREATED
+    assert response.json()["user"] == "julien"
+    assert "password" not in response.json()
     assert len(controller.computes) == 1
     assert controller.computes["my_compute_id"].host == "localhost"
 
 
-@pytest.mark.asyncio
-async def test_compute_get(controller_api):
+async def test_compute_get(app: FastAPI, client: AsyncClient, controller: Controller) -> None:
 
     params = {
         "compute_id": "my_compute_id",
@@ -69,15 +76,14 @@ async def test_compute_get(controller_api):
         "password": "secure"
     }
 
-    response = await controller_api.post("/computes", params)
-    assert response.status_code == 201
+    response = await client.post(app.url_path_for("create_compute"), json=params)
+    assert response.status_code == status.HTTP_201_CREATED
 
-    response = await controller_api.get("/computes/my_compute_id")
-    assert response.status_code == 200
+    response = await client.get(app.url_path_for("update_compute", compute_id="my_compute_id"))
+    assert response.status_code == status.HTTP_200_OK
 
 
-@pytest.mark.asyncio
-async def test_compute_update(controller_api):
+async def test_compute_update(app: FastAPI, client: AsyncClient) -> None:
 
     params = {
         "compute_id": "my_compute_id",
@@ -88,22 +94,20 @@ async def test_compute_update(controller_api):
         "password": "secure"
     }
 
-    response = await controller_api.post("/computes", params)
-    assert response.status_code == 201
-
-    response = await controller_api.get("/computes/my_compute_id")
-    assert response.status_code == 200
-    assert response.json["protocol"] == "http"
+    response = await client.post(app.url_path_for("create_compute"), json=params)
+    assert response.status_code == status.HTTP_201_CREATED
+    response = await client.get(app.url_path_for("get_compute", compute_id="my_compute_id"))
+    assert response.status_code == status.HTTP_200_OK
+    assert response.json()["protocol"] == "http"
 
     params["protocol"] = "https"
-    response = await controller_api.put("/computes/my_compute_id", params)
+    response = await client.put(app.url_path_for("update_compute", compute_id="my_compute_id"), json=params)
 
-    assert response.status_code == 200
-    assert response.json["protocol"] == "https"
+    assert response.status_code == status.HTTP_200_OK
+    assert response.json()["protocol"] == "https"
 
 
-@pytest.mark.asyncio
-async def test_compute_list(controller_api):
+async def test_compute_list(app: FastAPI, client: AsyncClient, controller: Controller) -> None:
 
     params = {
         "compute_id": "my_compute_id",
@@ -115,13 +119,13 @@ async def test_compute_list(controller_api):
         "name": "My super server"
     }
 
-    response = await controller_api.post("/computes", params)
-    assert response.status_code == 201
-    assert response.json["user"] == "julien"
-    assert "password" not in response.json
+    response = await client.post(app.url_path_for("create_compute"), json=params)
+    assert response.status_code == status.HTTP_201_CREATED
+    assert response.json()["user"] == "julien"
+    assert "password" not in response.json()
 
-    response = await controller_api.get("/computes")
-    for compute in response.json:
+    response = await client.get(app.url_path_for("get_computes"))
+    for compute in response.json():
         if compute['compute_id'] != 'local':
             assert compute == {
                 'compute_id': 'my_compute_id',
@@ -146,8 +150,7 @@ async def test_compute_list(controller_api):
             }
 
 
-@pytest.mark.asyncio
-async def test_compute_delete(controller_api):
+async def test_compute_delete(app: FastAPI, client: AsyncClient, controller: Controller) -> None:
 
     params = {
         "compute_id": "my_compute_id",
@@ -157,41 +160,40 @@ async def test_compute_delete(controller_api):
         "user": "julien",
         "password": "secure"
     }
-    response = await controller_api.post("/computes", params)
-    assert response.status_code == 201
 
-    response = await controller_api.get("/computes")
-    assert len(response.json) == 1
+    response = await client.post(app.url_path_for("create_compute"), json=params)
+    assert response.status_code == status.HTTP_201_CREATED
 
-    response = await controller_api.delete("/computes/my_compute_id")
-    assert response.status_code == 204
+    response = await client.get(app.url_path_for("get_computes"))
+    assert len(response.json()) == 1
 
-    response = await controller_api.get("/computes")
-    assert len(response.json) == 0
+    response = await client.delete(app.url_path_for("delete_compute", compute_id="my_compute_id"))
+    assert response.status_code == status.HTTP_204_NO_CONTENT
+
+    response = await client.get(app.url_path_for("get_computes"))
+    assert len(response.json()) == 0
 
 
-@pytest.mark.asyncio
-async def test_compute_list_images(controller_api):
+async def test_compute_list_images(app: FastAPI, client: AsyncClient) -> None:
 
     params = {
-        "compute_id": "my_compute",
+        "compute_id": "my_compute_id",
         "protocol": "http",
         "host": "localhost",
         "port": 84,
         "user": "julien",
         "password": "secure"
     }
-    response = await controller_api.post("/computes", params)
-    assert response.status_code == 201
+    response = await client.post(app.url_path_for("create_compute"), json=params)
+    assert response.status_code == status.HTTP_201_CREATED
 
     with asyncio_patch("gns3server.controller.compute.Compute.images", return_value=[{"filename": "linux.qcow2"}, {"filename": "asav.qcow2"}]) as mock:
-        response = await controller_api.get("/computes/my_compute/qemu/images")
-        assert response.json == [{"filename": "linux.qcow2"}, {"filename": "asav.qcow2"}]
+        response = await client.get(app.url_path_for("delete_compute", compute_id="my_compute_id") + "/qemu/images")
+        assert response.json() == [{"filename": "linux.qcow2"}, {"filename": "asav.qcow2"}]
         mock.assert_called_with("qemu")
 
 
-@pytest.mark.asyncio
-async def test_compute_list_vms(controller_api):
+async def test_compute_list_vms(app: FastAPI, client: AsyncClient) -> None:
 
     params = {
         "compute_id": "my_compute",
@@ -201,17 +203,16 @@ async def test_compute_list_vms(controller_api):
         "user": "julien",
         "password": "secure"
     }
-    response = await controller_api.post("/computes", params)
-    assert response.status_code == 201
+    response = await client.post(app.url_path_for("get_computes"), json=params)
+    assert response.status_code == status.HTTP_201_CREATED
 
     with asyncio_patch("gns3server.controller.compute.Compute.forward", return_value=[]) as mock:
-        response = await controller_api.get("/computes/my_compute/virtualbox/vms")
+        response = await client.get(app.url_path_for("get_compute", compute_id="my_compute_id") + "/virtualbox/vms")
         mock.assert_called_with("GET", "virtualbox", "vms")
-        assert response.json == []
+        assert response.json() == []
 
 
-@pytest.mark.asyncio
-async def test_compute_create_img(controller_api):
+async def test_compute_create_img(app: FastAPI, client: AsyncClient) -> None:
 
     params = {
         "compute_id": "my_compute",
@@ -222,18 +223,17 @@ async def test_compute_create_img(controller_api):
         "password": "secure"
     }
 
-    response = await controller_api.post("/computes", params)
-    assert response.status_code == 201
+    response = await client.post(app.url_path_for("get_computes"), json=params)
+    assert response.status_code == status.HTTP_201_CREATED
 
     params = {"path": "/test"}
     with asyncio_patch("gns3server.controller.compute.Compute.forward", return_value=[]) as mock:
-        response = await controller_api.post("/computes/my_compute/qemu/img", params)
-        assert response.json == []
+        response = await client.post(app.url_path_for("get_compute", compute_id="my_compute_id") + "/qemu/img", json=params)
+        assert response.json() == []
         mock.assert_called_with("POST", "qemu", "img", data=unittest.mock.ANY)
 
 
-@pytest.mark.asyncio
-async def test_compute_autoidlepc(controller_api):
+async def test_compute_autoidlepc(app: FastAPI, client: AsyncClient) -> None:
 
     params = {
         "compute_id": "my_compute_id",
@@ -244,7 +244,7 @@ async def test_compute_autoidlepc(controller_api):
         "password": "secure"
     }
 
-    await controller_api.post("/computes", params)
+    await client.post(app.url_path_for("get_computes"), json=params)
 
     params = {
         "platform": "c7200",
@@ -253,9 +253,9 @@ async def test_compute_autoidlepc(controller_api):
     }
 
     with asyncio_patch("gns3server.controller.Controller.autoidlepc", return_value={"idlepc": "0x606de20c"}) as mock:
-        response = await controller_api.post("/computes/my_compute_id/auto_idlepc", params)
+        response = await client.post(app.url_path_for("get_compute", compute_id="my_compute_id") + "/auto_idlepc", json=params)
     assert mock.called
-    assert response.status_code == 200
+    assert response.status_code == status.HTTP_200_OK
 
 
 # FIXME

tests/api/routes/controller/test_controller.py

@@ -18,25 +18,29 @@
 import os
 import pytest
 
+from fastapi import FastAPI, status
+from httpx import AsyncClient
 from unittest.mock import MagicMock
 
+from gns3server.config import Config
 
-@pytest.mark.asyncio
-async def test_shutdown_local(controller_api, config):
+pytestmark = pytest.mark.asyncio
+
+
+async def test_shutdown_local(app: FastAPI, client: AsyncClient, config: Config) -> None:
 
     os.kill = MagicMock()
     config.set("Server", "local", True)
-    response = await controller_api.post('/shutdown')
-    assert response.status_code == 204
+    response = await client.post(app.url_path_for("shutdown"))
+    assert response.status_code == status.HTTP_204_NO_CONTENT
     assert os.kill.called
 
 
-@pytest.mark.asyncio
-async def test_shutdown_non_local(controller_api, config):
+async def test_shutdown_non_local(app: FastAPI, client: AsyncClient, config: Config) -> None:
 
     config.set("Server", "local", False)
-    response = await controller_api.post('/shutdown')
-    assert response.status_code == 403
+    response = await client.post(app.url_path_for("shutdown"))
+    assert response.status_code == status.HTTP_403_FORBIDDEN
 
 
 # @pytest.mark.asyncio
@@ -60,8 +64,7 @@ async def test_shutdown_non_local(controller_api, config):
 #     assert response.status_code == 403
 
 
-@pytest.mark.asyncio
-async def test_statistics_output(controller_api):
+async def test_statistics_output(app: FastAPI, client: AsyncClient) -> None:
 
-    response = await controller_api.get('/statistics')
-    assert response.status_code == 200
+    response = await client.get(app.url_path_for("statistics"))
+    assert response.status_code == status.HTTP_200_OK

tests/api/routes/controller/test_drawings.py

@@ -16,11 +16,17 @@
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 import pytest
+
+from fastapi import FastAPI, status
+from httpx import AsyncClient
+
 from gns3server.controller.drawing import Drawing
+from gns3server.controller.project import Project
+
+pytestmark = pytest.mark.asyncio
 
 
-@pytest.mark.asyncio
-async def test_create_drawing(controller_api, project):
+async def test_create_drawing(app: FastAPI, client: AsyncClient, project: Project) -> None:
 
     params = {
         "svg": '<svg height="210" width="500"><line x1="0" y1="0" x2="200" y2="200" style="stroke:rgb(255,0,0);stroke-width:2" /></svg>',
@@ -29,13 +35,12 @@ async def test_create_drawing(controller_api, project):
         "z": 0
     }
 
-    response = await controller_api.post("/projects/{}/drawings".format(project.id), params)
-    assert response.status_code == 201
-    assert response.json["drawing_id"] is not None
+    response = await client.post(app.url_path_for("create_drawing", project_id=project.id), json=params)
+    assert response.status_code == status.HTTP_201_CREATED
+    assert response.json()["drawing_id"] is not None
 
 
-@pytest.mark.asyncio
-async def test_get_drawing(controller_api, project):
+async def test_get_drawing(app: FastAPI, client: AsyncClient, project: Project) -> None:
 
     params = {
         "svg": '<svg height="210" width="500"><line x1="0" y1="0" x2="200" y2="200" style="stroke:rgb(255,0,0);stroke-width:2" /></svg>',
@@ -44,14 +49,17 @@ async def test_get_drawing(controller_api, project):
         "z": 0
     }
 
-    response = await controller_api.post("/projects/{}/drawings".format(project.id), params)
-    response = await controller_api.get("/projects/{}/drawings/{}".format(project.id, response.json["drawing_id"]))
+    response = await client.post(app.url_path_for("create_drawing", project_id=project.id), json=params)
+    response = await client.get(app.url_path_for(
+        "get_drawing",
+        project_id=project.id,
+        drawing_id=response.json()["drawing_id"])
+    )
     assert response.status_code == 200
-    assert response.json["x"] == 10
+    assert response.json()["x"] == 10
 
 
-@pytest.mark.asyncio
-async def test_update_drawing(controller_api, project):
+async def test_update_drawing(app: FastAPI, client: AsyncClient, project: Project) -> None:
 
     params = {
         "svg": '<svg height="210" width="500"><line x1="0" y1="0" x2="200" y2="200" style="stroke:rgb(255,0,0);stroke-width:2" /></svg>',
@@ -60,14 +68,19 @@ async def test_update_drawing(controller_api, project):
         "z": 0
     }
 
-    response = await controller_api.post("/projects/{}/drawings".format(project.id), params)
-    response = await controller_api.put("/projects/{}/drawings/{}".format(project.id, response.json["drawing_id"]), {"x": 42})
-    assert response.status_code == 200
-    assert response.json["x"] == 42
+    response = await client.post(app.url_path_for("create_drawing", project_id=project.id), json=params)
+    response = await client.put(app.url_path_for(
+        "update_drawing",
+        project_id=project.id,
+        drawing_id=response.json()["drawing_id"]),
+        json={"x": 42}
+    )
+
+    assert response.status_code == status.HTTP_200_OK
+    assert response.json()["x"] == 42
 
 
-@pytest.mark.asyncio
-async def test_list_drawing(controller_api, project):
+async def test_all_drawings(app: FastAPI, client: AsyncClient, project: Project) -> None:
 
     params = {
         "svg": '<svg height="210" width="500"><line x1="0" y1="0" x2="200" y2="200" style="stroke:rgb(255,0,0);stroke-width:2" /></svg>',
@@ -76,17 +89,20 @@ async def test_list_drawing(controller_api, project):
         "z": 0
     }
 
-    await controller_api.post("/projects/{}/drawings".format(project.id), params)
-    response = await controller_api.get("/projects/{}/drawings".format(project.id))
-    assert response.status_code == 200
-    assert len(response.json) == 1
+    await client.post(app.url_path_for("create_drawing", project_id=project.id), json=params)
+    response = await client.get(app.url_path_for("get_drawings", project_id=project.id))
+    assert response.status_code == status.HTTP_200_OK
+    assert len(response.json()) == 1
 
 
-@pytest.mark.asyncio
-async def test_delete_drawing(controller_api, project):
+async def test_delete_drawing(app: FastAPI, client: AsyncClient, project: Project) -> None:
 
     drawing = Drawing(project)
     project._drawings = {drawing.id: drawing}
-    response = await controller_api.delete("/projects/{}/drawings/{}".format(project.id, drawing.id))
-    assert response.status_code == 204
+    response = await client.delete(app.url_path_for(
+        "delete_drawing",
+        project_id=project.id,
+        drawing_id=drawing.id)
+    )
+    assert response.status_code == status.HTTP_204_NO_CONTENT
     assert drawing.id not in project.drawings

tests/api/routes/controller/test_gns3vm.py

@@ -16,39 +16,40 @@
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 import pytest
+
+from fastapi import FastAPI, status
+from httpx import AsyncClient
 from tests.utils import asyncio_patch
 
+pytestmark = pytest.mark.asyncio
 
-@pytest.mark.asyncio
-async def test_list_vms(controller_api):
+
+async def test_list_vms(app: FastAPI, client: AsyncClient) -> None:
 
     with asyncio_patch("gns3server.controller.gns3vm.vmware_gns3_vm.VMwareGNS3VM.list", return_value=[{"vmname": "test"}]):
-        response = await controller_api.get('/gns3vm/engines/vmware/vms')
-    assert response.status_code == 200
-    assert response.json == [
+        response = await client.get(app.url_path_for("get_vms", engine="vmware"))
+    assert response.status_code == status.HTTP_200_OK
+    assert response.json() == [
         {
             "vmname": "test"
         }
     ]
 
 
-@pytest.mark.asyncio
-async def test_engines(controller_api):
+async def test_engines(app: FastAPI, client: AsyncClient) -> None:
 
-    response = await controller_api.get('/gns3vm/engines')
-    assert response.status_code == 200
-    assert len(response.json) > 0
+    response = await client.get(app.url_path_for("get_engines"))
+    assert response.status_code == status.HTTP_200_OK
+    assert len(response.json()) > 0
 
 
-@pytest.mark.asyncio
-async def test_put_gns3vm(controller_api):
+async def test_put_gns3vm(app: FastAPI, client: AsyncClient) -> None:
 
-    response = await controller_api.put('/gns3vm', {"vmname": "TEST VM"})
-    assert response.status_code == 200
-    assert response.json["vmname"] == "TEST VM"
+    response = await client.put(app.url_path_for("update_gns3vm_settings"), json={"vmname": "TEST VM"})
+    assert response.status_code == status.HTTP_200_OK
+    assert response.json()["vmname"] == "TEST VM"
 
 
-@pytest.mark.asyncio
-async def test_get_gns3vm(controller_api):
-    response = await controller_api.get('/gns3vm')
-    assert response.status_code == 200
+async def test_get_gns3vm(app: FastAPI, client: AsyncClient) -> None:
+    response = await client.get(app.url_path_for("get_gns3vm_settings"))
+    assert response.status_code == status.HTTP_200_OK

tests/api/routes/controller/test_links.py

@@ -17,17 +17,25 @@
 
 import pytest
 
+from typing import Tuple
+from fastapi import FastAPI, status
+from httpx import AsyncClient
+
 from unittest.mock import patch, MagicMock
 from tests.utils import asyncio_patch, AsyncioMagicMock
 
+from gns3server.controller.project import Project
+from gns3server.controller.compute import Compute
+from gns3server.controller.node import Node
 from gns3server.controller.ports.ethernet_port import EthernetPort
 from gns3server.controller.link import Link, FILTERS
 from gns3server.controller.udp_link import UDPLink
 
+pytestmark = pytest.mark.asyncio
+
 
 @pytest.fixture
-@pytest.mark.asyncio
-async def nodes(compute, project):
+async def nodes(compute: Compute, project: Project) -> Tuple[Node, Node]:
 
     response = MagicMock()
     response.json = {"console": 2048}
@@ -40,8 +48,7 @@ async def nodes(compute, project):
     return node1, node2
 
 
-@pytest.mark.asyncio
-async def test_create_link(controller_api, project, nodes):
+async def test_create_link(app: FastAPI, client: AsyncClient, project: Project, nodes: Tuple[Node, Node]) -> None:
 
     node1, node2 = nodes
 
@@ -51,7 +58,7 @@ async def test_create_link(controller_api, project, nodes):
     }
 
     with asyncio_patch("gns3server.controller.udp_link.UDPLink.create") as mock:
-        response = await controller_api.post("/projects/{}/links".format(project.id), {
+        response = await client.post(app.url_path_for("create_link", project_id=project.id), json={
             "nodes": [
                 {
                     "node_id": node1.id,
@@ -73,16 +80,15 @@ async def test_create_link(controller_api, project, nodes):
         })
 
     assert mock.called
-    assert response.status_code == 201
-    assert response.json["link_id"] is not None
-    assert len(response.json["nodes"]) == 2
-    assert response.json["nodes"][0]["label"]["x"] == 42
+    assert response.status_code == status.HTTP_201_CREATED
+    assert response.json()["link_id"] is not None
+    assert len(response.json()["nodes"]) == 2
+    assert response.json()["nodes"][0]["label"]["x"] == 42
     assert len(project.links) == 1
     assert list(project.links.values())[0].filters == filters
 
 
-@pytest.mark.asyncio
-async def test_create_link_failure(controller_api, compute, project):
+async def test_create_link_failure(app: FastAPI, client: AsyncClient, compute: Compute, project: Project) -> None:
     """
     Make sure the link is deleted if we failed to create it.
 
@@ -96,7 +102,7 @@ async def test_create_link_failure(controller_api, compute, project):
     node1 = await project.add_node(compute, "node1", None, node_type="qemu")
     node1._ports = [EthernetPort("E0", 0, 0, 3), EthernetPort("E0", 0, 0, 4)]
 
-    response = await controller_api.post("/projects/{}/links".format(project.id), {
+    response = await client.post(app.url_path_for("create_link", project_id=project.id), json={
         "nodes": [
             {
                 "node_id": node1.id,
@@ -116,16 +122,15 @@ async def test_create_link_failure(controller_api, compute, project):
         ]
     })
 
-    assert response.status_code == 409
+    assert response.status_code == status.HTTP_409_CONFLICT
     assert len(project.links) == 0
 
 
-@pytest.mark.asyncio
-async def test_get_link(controller_api, project, nodes):
+async def test_get_link(app: FastAPI, client: AsyncClient, project: Project, nodes: Tuple[Node, Node]) -> None:
 
     node1, node2 = nodes
     with asyncio_patch("gns3server.controller.udp_link.UDPLink.create") as mock:
-        response = await controller_api.post("/projects/{}/links".format(project.id), {
+        response = await client.post(app.url_path_for("create_link", project_id=project.id), json={
             "nodes": [
                 {
                     "node_id": node1.id,
@@ -146,19 +151,18 @@ async def test_get_link(controller_api, project, nodes):
         })
 
     assert mock.called
-    link_id = response.json["link_id"]
-    assert response.json["nodes"][0]["label"]["x"] == 42
-    response = await controller_api.get("/projects/{}/links/{}".format(project.id, link_id))
-    assert response.status_code == 200
-    assert response.json["nodes"][0]["label"]["x"] == 42
+    link_id = response.json()["link_id"]
+    assert response.json()["nodes"][0]["label"]["x"] == 42
+    response = await client.get(app.url_path_for("get_link", project_id=project.id, link_id=link_id))
+    assert response.status_code == status.HTTP_200_OK
+    assert response.json()["nodes"][0]["label"]["x"] == 42
 
 
-@pytest.mark.asyncio
-async def test_update_link_suspend(controller_api, project, nodes):
+async def test_update_link_suspend(app: FastAPI, client: AsyncClient, project: Project, nodes: Tuple[Node, Node]) -> None:
 
     node1, node2 = nodes
     with asyncio_patch("gns3server.controller.udp_link.UDPLink.create") as mock:
-        response = await controller_api.post("/projects/{}/links".format(project.id), {
+        response = await client.post(app.url_path_for("create_link", project_id=project.id), json={
             "nodes": [
                 {
                     "node_id": node1.id,
@@ -179,10 +183,10 @@ async def test_update_link_suspend(controller_api, project, nodes):
         })
 
     assert mock.called
-    link_id = response.json["link_id"]
-    assert response.json["nodes"][0]["label"]["x"] == 42
+    link_id = response.json()["link_id"]
+    assert response.json()["nodes"][0]["label"]["x"] == 42
 
-    response = await controller_api.put("/projects/{}/links/{}".format(project.id, link_id), {
+    response = await client.put(app.url_path_for("update_link", project_id=project.id, link_id=link_id), json={
         "nodes": [
             {
                 "node_id": node1.id,
@@ -203,14 +207,13 @@ async def test_update_link_suspend(controller_api, project, nodes):
         "suspend": True
     })
 
-    assert response.status_code == 200
-    assert response.json["nodes"][0]["label"]["x"] == 64
-    assert response.json["suspend"]
-    assert response.json["filters"] == {}
+    assert response.status_code == status.HTTP_200_OK
+    assert response.json()["nodes"][0]["label"]["x"] == 64
+    assert response.json()["suspend"]
+    assert response.json()["filters"] == {}
 
 
-@pytest.mark.asyncio
-async def test_update_link(controller_api, project, nodes):
+async def test_update_link(app: FastAPI, client: AsyncClient, project: Project, nodes: Tuple[Node, Node]) -> None:
 
     filters = {
         "latency": [10],
@@ -219,7 +222,7 @@ async def test_update_link(controller_api, project, nodes):
 
     node1, node2 = nodes
     with asyncio_patch("gns3server.controller.udp_link.UDPLink.create") as mock:
-        response = await controller_api.post("/projects/{}/links".format(project.id), {
+        response = await client.post(app.url_path_for("create_link", project_id=project.id), json={
             "nodes": [
                 {
                     "node_id": node1.id,
@@ -240,10 +243,10 @@ async def test_update_link(controller_api, project, nodes):
         })
 
     assert mock.called
-    link_id = response.json["link_id"]
-    assert response.json["nodes"][0]["label"]["x"] == 42
+    link_id = response.json()["link_id"]
+    assert response.json()["nodes"][0]["label"]["x"] == 42
 
-    response = await controller_api.put("/projects/{}/links/{}".format(project.id, link_id), {
+    response = await client.put(app.url_path_for("update_link", project_id=project.id, link_id=link_id), json={
         "nodes": [
             {
                 "node_id": node1.id,
@@ -264,13 +267,12 @@ async def test_update_link(controller_api, project, nodes):
         "filters": filters
     })
 
-    assert response.status_code == 200
-    assert response.json["nodes"][0]["label"]["x"] == 64
+    assert response.status_code == status.HTTP_200_OK
+    assert response.json()["nodes"][0]["label"]["x"] == 64
     assert list(project.links.values())[0].filters == filters
 
 
-@pytest.mark.asyncio
-async def test_list_link(controller_api, project, nodes):
+async def test_list_link(app: FastAPI, client: AsyncClient, project: Project, nodes: Tuple[Node, Node]) -> None:
 
     filters = {
         "latency": [10],
@@ -291,51 +293,48 @@ async def test_list_link(controller_api, project, nodes):
         }
     ]
     with asyncio_patch("gns3server.controller.udp_link.UDPLink.create") as mock:
-        await controller_api.post("/projects/{}/links".format(project.id), {
+        await client.post(app.url_path_for("create_link", project_id=project.id), json={
             "nodes": nodes,
             "filters": filters
         })
 
     assert mock.called
-    response = await controller_api.get("/projects/{}/links".format(project.id))
-    assert response.status_code == 200
-    assert len(response.json) == 1
-    assert response.json[0]["filters"] == filters
+    response = await client.get(app.url_path_for("get_links", project_id=project.id))
+    assert response.status_code == status.HTTP_200_OK
+    assert len(response.json()) == 1
+    assert response.json()[0]["filters"] == filters
 
 
-@pytest.mark.asyncio
-async def test_reset_link(controller_api, project):
+async def test_reset_link(app: FastAPI, client: AsyncClient, project: Project) -> None:
 
     link = UDPLink(project)
     project._links = {link.id: link}
     with asyncio_patch("gns3server.controller.udp_link.UDPLink.delete") as delete_mock:
         with asyncio_patch("gns3server.controller.udp_link.UDPLink.create") as create_mock:
-            response = await controller_api.post("/projects/{}/links/{}/reset".format(project.id, link.id))
+            response = await client.post(app.url_path_for("reset_link", project_id=project.id, link_id=link.id))
             assert delete_mock.called
             assert create_mock.called
-            assert response.status_code == 200
+            assert response.status_code == status.HTTP_200_OK
 
 
-@pytest.mark.asyncio
-async def test_start_capture(controller_api, project):
+async def test_start_capture(app: FastAPI, client: AsyncClient, project: Project) -> None:
 
     link = Link(project)
     project._links = {link.id: link}
     with asyncio_patch("gns3server.controller.link.Link.start_capture") as mock:
-        response = await controller_api.post("/projects/{}/links/{}/capture/start".format(project.id, link.id))
-    assert mock.called
-    assert response.status_code == 201
+        response = await client.post(app.url_path_for("start_capture", project_id=project.id, link_id=link.id), json={})
+        assert mock.called
+        assert response.status_code == status.HTTP_201_CREATED
 
 
-@pytest.mark.asyncio
-async def test_stop_capture(controller_api, project):
+async def test_stop_capture(app: FastAPI, client: AsyncClient, project: Project) -> None:
 
     link = Link(project)
     project._links = {link.id: link}
     with asyncio_patch("gns3server.controller.link.Link.stop_capture") as mock:
-        response = await controller_api.post("/projects/{}/links/{}/capture/stop".format(project.id, link.id))
-    assert mock.called
-    assert response.status_code == 204
+        response = await client.post(app.url_path_for("stop_capture", project_id=project.id, link_id=link.id))
+        assert mock.called
+        assert response.status_code == status.HTTP_204_NO_CONTENT
 
 
 # async def test_pcap(controller_api, http_client, project):
@@ -359,24 +358,22 @@ async def test_stop_capture(controller_api, project):
 #         assert b'hello' == response.body
 
 
-@pytest.mark.asyncio
-async def test_delete_link(controller_api, project):
+async def test_delete_link(app: FastAPI, client: AsyncClient, project: Project) -> None:
 
     link = Link(project)
     project._links = {link.id: link}
     with asyncio_patch("gns3server.controller.link.Link.delete") as mock:
-        response = await controller_api.delete("/projects/{}/links/{}".format(project.id, link.id))
+        response = await client.delete(app.url_path_for("delete_link", project_id=project.id, link_id=link.id))
     assert mock.called
-    assert response.status_code == 204
+    assert response.status_code == status.HTTP_204_NO_CONTENT
 
 
-@pytest.mark.asyncio
-async def test_list_filters(controller_api, project):
+async def test_list_filters(app: FastAPI, client: AsyncClient, project: Project) -> None:
 
     link = Link(project)
     project._links = {link.id: link}
     with patch("gns3server.controller.link.Link.available_filters", return_value=FILTERS) as mock:
-        response = await controller_api.get("/projects/{}/links/{}/available_filters".format(project.id, link.id))
+        response = await client.get(app.url_path_for("get_filters", project_id=project.id, link_id=link.id))
     assert mock.called
-    assert response.status_code == 200
-    assert response.json == FILTERS
+    assert response.status_code == status.HTTP_200_OK
+    assert response.json() == FILTERS

tests/api/routes/controller/test_nodes.py

@@ -18,28 +18,34 @@
 
 import pytest
 
+from fastapi import FastAPI, status
+from httpx import AsyncClient
+
 from unittest.mock import MagicMock
 from tests.utils import AsyncioMagicMock
 
 from gns3server.controller.node import Node
+from gns3server.controller.project import Project
+from gns3server.controller.compute import Compute
+
+pytestmark = pytest.mark.asyncio
 
 
 @pytest.fixture
-def node(project, compute):
+def node(project: Project, compute: Compute) -> Node:
 
     node = Node(project, compute, "test", node_type="vpcs")
     project._nodes[node.id] = node
     return node
 
 
-@pytest.mark.asyncio
-async def test_create_node(controller_api, project, compute):
+async def test_create_node(app: FastAPI, client: AsyncClient, project: Project, compute: Compute) -> None:
 
     response = MagicMock()
     response.json = {"console": 2048}
     compute.post = AsyncioMagicMock(return_value=response)
 
-    response = await controller_api.post("/projects/{}/nodes".format(project.id), {
+    response = await client.post(app.url_path_for("create_node", project_id=project.id), json={
         "name": "test",
         "node_type": "vpcs",
         "compute_id": "example.com",
@@ -48,19 +54,18 @@ async def test_create_node(controller_api, project, compute):
         }
     })
 
-    assert response.status_code == 201
-    assert response.json["name"] == "test"
-    assert "name" not in response.json["properties"]
+    assert response.status_code == status.HTTP_201_CREATED
+    assert response.json()["name"] == "test"
+    assert "name" not in response.json()["properties"]
 
 
-@pytest.mark.asyncio
-async def test_list_node(controller_api, project, compute):
+async def test_list_node(app: FastAPI, client: AsyncClient, project: Project, compute: Compute) -> None:
 
     response = MagicMock()
     response.json = {"console": 2048}
     compute.post = AsyncioMagicMock(return_value=response)
 
-    await controller_api.post("/projects/{}/nodes".format(project.id), {
+    await client.post(app.url_path_for("create_node", project_id=project.id), json={
         "name": "test",
         "node_type": "vpcs",
         "compute_id": "example.com",
@@ -69,19 +74,18 @@ async def test_list_node(controller_api, project, compute):
         }
     })
 
-    response = await controller_api.get("/projects/{}/nodes".format(project.id))
-    assert response.status_code == 200
-    assert response.json[0]["name"] == "test"
+    response = await client.get(app.url_path_for("get_nodes", project_id=project.id))
+    assert response.status_code == status.HTTP_200_OK
+    assert response.json()[0]["name"] == "test"
 
 
-@pytest.mark.asyncio
-async def test_get_node(controller_api, project, compute):
+async def test_get_node(app: FastAPI, client: AsyncClient, project: Project, compute: Compute) -> None:
 
     response = MagicMock()
     response.json = {"console": 2048}
     compute.post = AsyncioMagicMock(return_value=response)
 
-    response = await controller_api.post("/projects/{}/nodes".format(project.id), {
+    response = await client.post(app.url_path_for("create_node", project_id=project.id), json={
         "name": "test",
         "node_type": "vpcs",
         "compute_id": "example.com",
@@ -90,19 +94,18 @@ async def test_get_node(controller_api, project, compute):
         }
     })
 
-    response = await controller_api.get("/projects/{}/nodes/{}".format(project.id, response.json["node_id"]))
-    assert response.status_code == 200
-    assert response.json["name"] == "test"
+    response = await client.get(app.url_path_for("get_node", project_id=project.id, node_id=response.json()["node_id"]))
+    assert response.status_code == status.HTTP_200_OK
+    assert response.json()["name"] == "test"
 
 
-@pytest.mark.asyncio
-async def test_update_node(controller_api, project, compute, node):
+async def test_update_node(app: FastAPI, client: AsyncClient, project: Project, compute: Compute, node: Node) -> None:
 
     response = MagicMock()
     response.json = {"console": 2048}
     compute.put = AsyncioMagicMock(return_value=response)
 
-    response = await controller_api.put("/projects/{}/nodes/{}".format(project.id, node.id), {
+    response = await client.put(app.url_path_for("update_node", project_id=project.id, node_id=node.id), json={
         "name": "test",
         "node_type": "vpcs",
         "compute_id": "example.com",
@@ -112,156 +115,167 @@ async def test_update_node(controller_api, project, compute, node):
     })
 
     assert response.status_code == 200
-    assert response.json["name"] == "test"
-    assert "name" not in response.json["properties"]
+    assert response.json()["name"] == "test"
+    assert "name" not in response.json()["properties"]
 
 
-@pytest.mark.asyncio
-async def test_start_all_nodes(controller_api, project, compute):
+async def test_start_all_nodes(app: FastAPI, client: AsyncClient, project: Project, compute: Compute) -> None:
 
     compute.post = AsyncioMagicMock()
-    response = await controller_api.post("/projects/{}/nodes/start".format(project.id))
-    assert response.status_code == 204
+    response = await client.post(app.url_path_for("start_all_nodes", project_id=project.id))
+    assert response.status_code == status.HTTP_204_NO_CONTENT
 
 
-@pytest.mark.asyncio
-async def test_stop_all_nodes(controller_api, project, compute):
+async def test_stop_all_nodes(app: FastAPI, client: AsyncClient, project: Project, compute: Compute) -> None:
 
     compute.post = AsyncioMagicMock()
-    response = await controller_api.post("/projects/{}/nodes/stop".format(project.id))
-    assert response.status_code == 204
+    response = await client.post(app.url_path_for("stop_all_nodes", project_id=project.id))
+    assert response.status_code == status.HTTP_204_NO_CONTENT
 
 
-@pytest.mark.asyncio
-async def test_suspend_all_nodes(controller_api, project, compute):
+async def test_suspend_all_nodes(app: FastAPI, client: AsyncClient, project: Project, compute: Compute) -> None:
 
     compute.post = AsyncioMagicMock()
-    response = await controller_api.post("/projects/{}/nodes/suspend".format(project.id))
-    assert response.status_code == 204
+    response = await client.post(app.url_path_for("suspend_all_nodes", project_id=project.id))
+    assert response.status_code == status.HTTP_204_NO_CONTENT
 
 
-@pytest.mark.asyncio
-async def test_reload_all_nodes(controller_api, project, compute):
+async def test_reload_all_nodes(app: FastAPI, client: AsyncClient, project: Project, compute: Compute) -> None:
 
     compute.post = AsyncioMagicMock()
-    response = await controller_api.post("/projects/{}/nodes/reload".format(project.id))
-    assert response.status_code == 204
+    response = await client.post(app.url_path_for("reload_all_nodes", project_id=project.id))
+    assert response.status_code == status.HTTP_204_NO_CONTENT
 
 
-@pytest.mark.asyncio
-async def test_reset_console_all_nodes(controller_api, project, compute):
+async def test_reset_console_all_nodes(app: FastAPI, client: AsyncClient, project: Project, compute: Compute) -> None:
 
     compute.post = AsyncioMagicMock()
-    response = await controller_api.post("/projects/{}/nodes/console/reset".format(project.id))
-    assert response.status_code == 204
+    response = await client.post(app.url_path_for("reset_console_all_nodes", project_id=project.id))
+    assert response.status_code == status.HTTP_204_NO_CONTENT
 
 
-@pytest.mark.asyncio
-async def test_start_node(controller_api, project, node, compute):
+async def test_start_node(app: FastAPI, client: AsyncClient, project: Project, compute: Compute, node: Node) -> None:
 
     compute.post = AsyncioMagicMock()
-    response = await controller_api.post("/projects/{}/nodes/{}/start".format(project.id, node.id))
-    assert response.status_code == 204
+    response = await client.post(app.url_path_for("start_node", project_id=project.id, node_id=node.id), json={})
+    assert response.status_code == status.HTTP_204_NO_CONTENT
 
 
-@pytest.mark.asyncio
-async def test_stop_node(controller_api, project, node, compute):
+async def test_stop_node(app: FastAPI, client: AsyncClient, project: Project, compute: Compute, node: Node) -> None:
 
     compute.post = AsyncioMagicMock()
-    response = await controller_api.post("/projects/{}/nodes/{}/stop".format(project.id, node.id))
-    assert response.status_code == 204
+    response = await client.post(app.url_path_for("stop_node", project_id=project.id, node_id=node.id))
+    assert response.status_code == status.HTTP_204_NO_CONTENT
 
-
-@pytest.mark.asyncio
-async def test_suspend_node(controller_api, project, node, compute):
+async def test_suspend_node(app: FastAPI, client: AsyncClient, project: Project, compute: Compute, node: Node) -> None:
 
     compute.post = AsyncioMagicMock()
-    response = await controller_api.post("/projects/{}/nodes/{}/suspend".format(project.id, node.id))
-    assert response.status_code == 204
+    response = await client.post(app.url_path_for("suspend_node", project_id=project.id, node_id=node.id))
+    assert response.status_code == status.HTTP_204_NO_CONTENT
 
 
-@pytest.mark.asyncio
-async def test_reload_node(controller_api, project, node, compute):
+async def test_reload_node(app: FastAPI, client: AsyncClient, project: Project, compute: Compute, node: Node):
 
     compute.post = AsyncioMagicMock()
-    response = await controller_api.post("/projects/{}/nodes/{}/reload".format(project.id, node.id))
-    assert response.status_code == 204
+    response = await client.post(app.url_path_for("reload_node", project_id=project.id, node_id=node.id))
+    assert response.status_code == status.HTTP_204_NO_CONTENT
 
 
-@pytest.mark.asyncio
-async def test_duplicate_node(controller_api, project, compute, node):
+async def test_duplicate_node(
+        app: FastAPI,
+        client: AsyncClient,
+        project: Project,
+        compute: Compute,
+        node: Node) -> None:
 
     response = MagicMock()
     response.json({"console": 2035})
     compute.post = AsyncioMagicMock(return_value=response)
 
-    response = await controller_api.post("/projects/{}/nodes/{}/duplicate".format(project.id, node.id),
-                                         {"x": 10,
-                                          "y": 5,
-                                          "z": 0})
-    assert response.status_code == 201, response.body.decode()
+    response = await client.post(app.url_path_for("duplicate_node", project_id=project.id, node_id=node.id),
+                                 json={"x": 10, "y": 5, "z": 0})
+    assert response.status_code == status.HTTP_201_CREATED
 
 
-@pytest.mark.asyncio
-async def test_delete_node(controller_api, project, node, compute):
+async def test_delete_node(app: FastAPI, client: AsyncClient, project: Project, compute: Compute, node: Node) -> None:
 
     compute.post = AsyncioMagicMock()
-    response = await controller_api.delete("/projects/{}/nodes/{}".format(project.id, node.id))
-    assert response.status_code == 204
+    response = await client.delete(app.url_path_for("delete_node", project_id=project.id, node_id=node.id))
+    assert response.status_code == status.HTTP_204_NO_CONTENT
 
 
-@pytest.mark.asyncio
-async def test_dynamips_idle_pc(controller_api, project, compute, node):
+async def test_dynamips_idle_pc(
+        app: FastAPI,
+        client: AsyncClient,
+        project: Project,
+        compute: Compute,
+        node: Node) -> None:
 
     response = MagicMock()
     response.json = {"idlepc": "0x60606f54"}
     compute.get = AsyncioMagicMock(return_value=response)
 
-    response = await controller_api.get("/projects/{}/nodes/{}/dynamips/auto_idlepc".format(project.id, node.id))
-    assert response.status_code == 200
-    assert response.json["idlepc"] == "0x60606f54"
+    response = await client.get(app.url_path_for("auto_idlepc", project_id=project.id, node_id=node.id))
+    assert response.status_code == status.HTTP_200_OK
+    assert response.json()["idlepc"] == "0x60606f54"
 
 
-@pytest.mark.asyncio
-async def test_dynamips_idlepc_proposals(controller_api, project, compute, node):
+async def test_dynamips_idlepc_proposals(
+        app: FastAPI,
+        client: AsyncClient,
+        project: Project,
+        compute: Compute,
+        node: Node) -> None:
 
     response = MagicMock()
     response.json = ["0x60606f54", "0x33805a22"]
     compute.get = AsyncioMagicMock(return_value=response)
 
-    response = await controller_api.get("/projects/{}/nodes/{}/dynamips/idlepc_proposals".format(project.id, node.id))
-    assert response.status_code == 200
-    assert response.json == ["0x60606f54", "0x33805a22"]
+    response = await client.get(app.url_path_for("idlepc_proposals", project_id=project.id, node_id=node.id))
+    assert response.status_code == status.HTTP_200_OK
+    assert response.json() == ["0x60606f54", "0x33805a22"]
 
 
-@pytest.mark.asyncio
-async def test_get_file(controller_api, project, node, compute):
+async def test_get_file(app: FastAPI, client: AsyncClient, project: Project, compute: Compute, node: Node) -> None:
 
     response = MagicMock()
     response.body = b"world"
     compute.http_query = AsyncioMagicMock(return_value=response)
 
-    response = await controller_api.get("/projects/{project_id}/nodes/{node_id}/files/hello".format(project_id=project.id, node_id=node.id))
-    assert response.status_code == 200
+    response = await client.get(app.url_path_for("get_file", project_id=project.id, node_id=node.id, file_path="hello"))
+    assert response.status_code == status.HTTP_200_OK
     assert response.content == b'world'
 
-    compute.http_query.assert_called_with("GET", "/projects/{project_id}/files/project-files/vpcs/{node_id}/hello".format(project_id=project.id, node_id=node.id), timeout=None, raw=True)
+    compute.http_query.assert_called_with(
+        "GET",
+        "/projects/{project_id}/files/project-files/vpcs/{node_id}/hello".format(
+            project_id=project.id,
+            node_id=node.id),
+        timeout=None,
+        raw=True)
 
-    response = await controller_api.get("/projects/{project_id}/nodes/{node_id}/files/../hello".format(project_id=project.id, node_id=node.id))
-    assert response.status_code == 404
+    response = await client.get(app.url_path_for(
+        "get_file",
+        project_id=project.id,
+        node_id=node.id,
+        file_path="../hello"))
+    assert response.status_code == status.HTTP_404_NOT_FOUND
 
 
-@pytest.mark.asyncio
-async def test_post_file(controller_api, project, node, compute):
+async def test_post_file(app: FastAPI, client: AsyncClient, project: Project, compute: Compute, node: Node) -> None:
 
     compute.http_query = AsyncioMagicMock()
-    response = await controller_api.post("/projects/{project_id}/nodes/{node_id}/files/hello".format(project_id=project.id, node_id=node.id), body=b"hello", raw=True)
-    assert response.status_code == 201
+    response = await client.post(app.url_path_for(
+        "post_file",
+        project_id=project.id,
+        node_id=node.id,
+        file_path="hello"), content=b"hello")
+    assert response.status_code == status.HTTP_201_CREATED
 
     compute.http_query.assert_called_with("POST", "/projects/{project_id}/files/project-files/vpcs/{node_id}/hello".format(project_id=project.id, node_id=node.id), data=b'hello', timeout=None, raw=True)
 
-    response = await controller_api.get("/projects/{project_id}/nodes/{node_id}/files/../hello".format(project_id=project.id, node_id=node.id))
-    assert response.status_code == 404
+    response = await client.get("/projects/{project_id}/nodes/{node_id}/files/../hello".format(project_id=project.id, node_id=node.id))
+    assert response.status_code == status.HTTP_404_NOT_FOUND
 
 
 # @pytest.mark.asyncio

tests/api/routes/controller/test_projects.py

@@ -17,177 +17,173 @@
 
 import uuid
 import os
-import pytest
 import zipfile
 import json
+import pytest
 
+from fastapi import FastAPI, status
+from httpx import AsyncClient
 from unittest.mock import patch, MagicMock
 from tests.utils import asyncio_patch
 
+from gns3server.controller import Controller
+from gns3server.controller.project import Project
+
+pytestmark = pytest.mark.asyncio
+
 
 @pytest.fixture
-@pytest.mark.asyncio
-async def project(controller_api, controller):
+async def project(app: FastAPI, client: AsyncClient, controller: Controller) -> Project:
 
     u = str(uuid.uuid4())
     params = {"name": "test", "project_id": u}
-    await controller_api.post("/projects", params)
+    await client.post(app.url_path_for("create_project"), json=params)
     return controller.get_project(u)
 
 
-@pytest.mark.asyncio
-async def test_create_project_with_path(controller_api, tmpdir):
+async def test_create_project_with_path(app: FastAPI, client: AsyncClient, controller: Controller, tmpdir) -> None:
 
-    response = await controller_api.post("/projects", {"name": "test", "path": str(tmpdir), "project_id": "00010203-0405-0607-0809-0a0b0c0d0e0f"})
-    assert response.status_code == 201
-    assert response.json["name"] == "test"
-    assert response.json["project_id"] == "00010203-0405-0607-0809-0a0b0c0d0e0f"
-    assert response.json["status"] == "opened"
+    params = {"name": "test", "path": str(tmpdir), "project_id": "00010203-0405-0607-0809-0a0b0c0d0e0f"}
+    response = await client.post(app.url_path_for("create_project"), json=params)
+    assert response.status_code == status.HTTP_201_CREATED
+    assert response.json()["name"] == "test"
+    assert response.json()["project_id"] == "00010203-0405-0607-0809-0a0b0c0d0e0f"
+    assert response.json()["status"] == "opened"
 
 
-@pytest.mark.asyncio
-async def test_create_project_without_dir(controller_api):
+async def test_create_project_without_dir(app: FastAPI, client: AsyncClient, controller: Controller) -> None:
 
     params = {"name": "test", "project_id": "10010203-0405-0607-0809-0a0b0c0d0e0f"}
-    response = await controller_api.post("/projects", params)
-    assert response.status_code == 201
-    assert response.json["project_id"] == "10010203-0405-0607-0809-0a0b0c0d0e0f"
-    assert response.json["name"] == "test"
+    response = await client.post(app.url_path_for("create_project"), json=params)
+    assert response.status_code == status.HTTP_201_CREATED
+    assert response.json()["project_id"] == "10010203-0405-0607-0809-0a0b0c0d0e0f"
+    assert response.json()["name"] == "test"
 
 
-@pytest.mark.asyncio
-async def test_create_project_with_uuid(controller_api):
+async def test_create_project_with_uuid(app: FastAPI, client: AsyncClient, controller: Controller) -> None:
 
     params = {"name": "test", "project_id": "30010203-0405-0607-0809-0a0b0c0d0e0f"}
-    response = await controller_api.post("/projects", params)
+    response = await client.post(app.url_path_for("create_project"), json=params)
     assert response.status_code == 201
-    assert response.json["project_id"] == "30010203-0405-0607-0809-0a0b0c0d0e0f"
-    assert response.json["name"] == "test"
+    assert response.json()["project_id"] == "30010203-0405-0607-0809-0a0b0c0d0e0f"
+    assert response.json()["name"] == "test"
 
 
-@pytest.mark.asyncio
-async def test_create_project_with_variables(controller_api):
+async def test_create_project_with_variables(app: FastAPI, client: AsyncClient, controller: Controller) -> None:
 
     variables = [
         {"name": "TEST1"},
         {"name": "TEST2", "value": "value1"}
     ]
     params = {"name": "test", "project_id": "30010203-0405-0607-0809-0a0b0c0d0e0f", "variables": variables}
-    response = await controller_api.post("/projects", params)
+    response = await client.post(app.url_path_for("create_project"), json=params)
     assert response.status_code == 201
-    assert response.json["variables"] == [
+    assert response.json()["variables"] == [
         {"name": "TEST1"},
         {"name": "TEST2", "value": "value1"}
     ]
 
 
-@pytest.mark.asyncio
-async def test_create_project_with_supplier(controller_api):
+async def test_create_project_with_supplier(app: FastAPI, client: AsyncClient, controller: Controller) -> None:
 
     supplier = {
         'logo': 'logo.png',
         'url': 'http://example.com'
     }
     params = {"name": "test", "project_id": "30010203-0405-0607-0809-0a0b0c0d0e0f", "supplier": supplier}
-    response = await controller_api.post("/projects", params)
-    assert response.status_code == 201
-    assert response.json["supplier"] == supplier
+    response = await client.post(app.url_path_for("create_project"), json=params)
+    assert response.status_code == status.HTTP_201_CREATED
+    assert response.json()["supplier"] == supplier
 
 
-@pytest.mark.asyncio
-async def test_update_project(controller_api):
+async def test_update_project(app: FastAPI, client: AsyncClient, controller: Controller) -> None:
 
     params = {"name": "test", "project_id": "10010203-0405-0607-0809-0a0b0c0d0e0f"}
-    response = await controller_api.post("/projects", params)
-    assert response.status_code == 201
-    assert response.json["project_id"] == "10010203-0405-0607-0809-0a0b0c0d0e0f"
-    assert response.json["name"] == "test"
+    response = await client.post(app.url_path_for("create_project"), json=params)
+    assert response.status_code == status.HTTP_201_CREATED
+    assert response.json()["project_id"] == "10010203-0405-0607-0809-0a0b0c0d0e0f"
+    assert response.json()["name"] == "test"
 
     params = {"name": "test2"}
-    response = await controller_api.put("/projects/10010203-0405-0607-0809-0a0b0c0d0e0f", params)
-    assert response.status_code == 200
-    assert response.json["name"] == "test2"
+    response = await client.put(app.url_path_for("update_project", project_id="10010203-0405-0607-0809-0a0b0c0d0e0f"),
+                                json=params)
+    assert response.status_code == status.HTTP_200_OK
+    assert response.json()["name"] == "test2"
 
 
-@pytest.mark.asyncio
-async def test_update_project_with_variables(controller_api):
+async def test_update_project_with_variables(app: FastAPI, client: AsyncClient, controller: Controller) -> None:
 
     variables = [
         {"name": "TEST1"},
         {"name": "TEST2", "value": "value1"}
     ]
     params = {"name": "test", "project_id": "10010203-0405-0607-0809-0a0b0c0d0e0f", "variables": variables}
-    response = await controller_api.post("/projects", params)
-    assert response.status_code == 201
+    response = await client.post(app.url_path_for("create_project"), json=params)
+    assert response.status_code == status.HTTP_201_CREATED
 
     params = {"name": "test2"}
-    response = await controller_api.put("/projects/10010203-0405-0607-0809-0a0b0c0d0e0f", params)
-    assert response.status_code == 200
-    assert response.json["variables"] == variables
+    response = await client.put(app.url_path_for("update_project", project_id="10010203-0405-0607-0809-0a0b0c0d0e0f"),
+                                json=params)
+    assert response.status_code == status.HTTP_200_OK
+    assert response.json()["variables"] == variables
 
 
-@pytest.mark.asyncio
-async def test_list_projects(controller_api, tmpdir):
+async def test_list_projects(app: FastAPI, client: AsyncClient, controller: Controller, tmpdir) -> None:
 
-    await controller_api.post("/projects", {"name": "test", "path": str(tmpdir), "project_id": "00010203-0405-0607-0809-0a0b0c0d0e0f"})
-    response = await controller_api.get("/projects")
-    assert response.status_code == 200
-    projects = response.json
+    params = {"name": "test", "path": str(tmpdir), "project_id": "00010203-0405-0607-0809-0a0b0c0d0e0f"}
+    await client.post(app.url_path_for("create_project"), json=params)
+    response = await client.get(app.url_path_for("get_projects"))
+    assert response.status_code == status.HTTP_200_OK
+    projects = response.json()
     assert projects[0]["name"] == "test"
 
 
-@pytest.mark.asyncio
-async def test_get_project(controller_api, project):
+async def test_get_project(app: FastAPI, client: AsyncClient, project: Project) -> None:
 
-    response = await controller_api.get("/projects/{project_id}".format(project_id=project.id))
-    assert response.status_code == 200
-    assert response.json["name"] == "test"
+    response = await client.get(app.url_path_for("get_project", project_id=project.id))
+    assert response.status_code == status.HTTP_200_OK
+    assert response.json()["name"] == "test"
 
 
-@pytest.mark.asyncio
-async def test_delete_project(controller_api, project, controller):
+async def test_delete_project(app: FastAPI, client: AsyncClient, project: Project, controller: Controller) -> None:
 
     with asyncio_patch("gns3server.controller.project.Project.delete", return_value=True) as mock:
-        response = await controller_api.delete("/projects/{project_id}".format(project_id=project.id))
-        assert response.status_code == 204
+        response = await client.delete(app.url_path_for("delete_project", project_id=project.id))
+        assert response.status_code == status.HTTP_204_NO_CONTENT
         assert mock.called
         assert project not in controller.projects
 
 
-@pytest.mark.asyncio
-async def test_delete_project_invalid_uuid(controller_api):
+async def test_delete_project_invalid_uuid(app: FastAPI, client: AsyncClient) -> None:
 
-    response = await controller_api.delete("/projects/{project_id}".format(project_id=uuid.uuid4()))
-    assert response.status_code == 404
+    response = await client.delete(app.url_path_for("delete_project", project_id=str(uuid.uuid4())))
+    assert response.status_code == status.HTTP_404_NOT_FOUND
 
 
-@pytest.mark.asyncio
-async def test_close_project(controller_api, project):
+async def test_close_project(app: FastAPI, client: AsyncClient, project: Project) -> None:
 
     with asyncio_patch("gns3server.controller.project.Project.close", return_value=True) as mock:
-        response = await controller_api.post("/projects/{project_id}/close".format(project_id=project.id))
-        assert response.status_code == 204
+        response = await client.post(app.url_path_for("close_project", project_id=project.id))
+        assert response.status_code == status.HTTP_204_NO_CONTENT
         assert mock.called
 
 
-@pytest.mark.asyncio
-async def test_open_project(controller_api, project):
+async def test_open_project(app: FastAPI, client: AsyncClient, project: Project) -> None:
 
     with asyncio_patch("gns3server.controller.project.Project.open", return_value=True) as mock:
-        response = await controller_api.post("/projects/{project_id}/open".format(project_id=project.id))
-        assert response.status_code == 201
+        response = await client.post(app.url_path_for("open_project", project_id=project.id))
+        assert response.status_code == status.HTTP_201_CREATED
         assert mock.called
 
 
-@pytest.mark.asyncio
-async def test_load_project(controller_api, project, config):
+async def test_load_project(app: FastAPI, client: AsyncClient, project: Project, config) -> None:
 
     config.set("Server", "local", "true")
     with asyncio_patch("gns3server.controller.Controller.load_project", return_value=project) as mock:
-        response = await controller_api.post("/projects/load", {"path": "/tmp/test.gns3"})
-        assert response.status_code == 201
+        response = await client.post(app.url_path_for("load_project"), json={"path": "/tmp/test.gns3"})
+        assert response.status_code == status.HTTP_201_CREATED
         mock.assert_called_with("/tmp/test.gns3")
-        assert response.json["project_id"] == project.id
+        assert response.json()["project_id"] == project.id
 
 
 # @pytest.mark.asyncio
@@ -230,8 +226,7 @@ async def test_load_project(controller_api, project, config):
 #     assert project.status_code == "opened"
 
 
-@pytest.mark.asyncio
-async def test_export_with_images(controller_api, tmpdir, project):
+async def test_export_with_images(app: FastAPI, client: AsyncClient, tmpdir, project: Project) -> None:
 
     project.dump = MagicMock()
     os.makedirs(project.path, exist_ok=True)
@@ -258,8 +253,9 @@ async def test_export_with_images(controller_api, tmpdir, project):
         json.dump(topology, f)
 
     with patch("gns3server.compute.Dynamips.get_images_directory", return_value=str(tmpdir / "IOS")):
-        response = await controller_api.get("/projects/{project_id}/export?include_images=yes".format(project_id=project.id))
-    assert response.status_code == 200
+        response = await client.get(app.url_path_for("export_project", project_id=project.id),
+                                    params={"include_images": "yes"})
+    assert response.status_code == status.HTTP_200_OK
     assert response.headers['CONTENT-TYPE'] == 'application/gns3project'
     assert response.headers['CONTENT-DISPOSITION'] == 'attachment; filename="{}.gns3project"'.format(project.name)
 
@@ -273,8 +269,7 @@ async def test_export_with_images(controller_api, tmpdir, project):
         myzip.getinfo("images/IOS/test.image")
 
 
-@pytest.mark.asyncio
-async def test_export_without_images(controller_api, tmpdir, project):
+async def test_export_without_images(app: FastAPI, client: AsyncClient, tmpdir, project: Project) -> None:
 
     project.dump = MagicMock()
     os.makedirs(project.path, exist_ok=True)
@@ -301,8 +296,9 @@ async def test_export_without_images(controller_api, tmpdir, project):
         json.dump(topology, f)
 
     with patch("gns3server.compute.Dynamips.get_images_directory", return_value=str(tmpdir / "IOS"),):
-        response = await controller_api.get("/projects/{project_id}/export?include_images=0".format(project_id=project.id))
-    assert response.status_code == 200
+        response = await client.get(app.url_path_for("export_project", project_id=project.id),
+                                    params={"include_images": "0"})
+    assert response.status_code == status.HTTP_200_OK
     assert response.headers['CONTENT-TYPE'] == 'application/gns3project'
     assert response.headers['CONTENT-DISPOSITION'] == 'attachment; filename="{}.gns3project"'.format(project.name)
 
@@ -318,50 +314,51 @@ async def test_export_without_images(controller_api, tmpdir, project):
             myzip.getinfo("images/IOS/test.image")
 
 
-@pytest.mark.asyncio
-async def test_get_file(controller_api, project):
+async def test_get_file(app: FastAPI, client: AsyncClient, project: Project) -> None:
 
     os.makedirs(project.path, exist_ok=True)
     with open(os.path.join(project.path, 'hello'), 'w+') as f:
         f.write('world')
 
-    response = await controller_api.get("/projects/{project_id}/files/hello".format(project_id=project.id))
-    assert response.status_code == 200
+    response = await client.get(app.url_path_for("get_file", project_id=project.id, file_path="hello"))
+    assert response.status_code == status.HTTP_200_OK
     assert response.content == b"world"
 
-    response = await controller_api.get("/projects/{project_id}/files/false".format(project_id=project.id))
-    assert response.status_code == 404
+    response = await client.get(app.url_path_for("get_file", project_id=project.id, file_path="false"))
+    assert response.status_code == status.HTTP_404_NOT_FOUND
 
-    response = await controller_api.get("/projects/{project_id}/files/../hello".format(project_id=project.id))
-    assert response.status_code == 404
+    response = await client.get(app.url_path_for("get_file", project_id=project.id, file_path="../hello"))
+    assert response.status_code == status.HTTP_404_NOT_FOUND
 
 
-@pytest.mark.asyncio
-async def test_write_file(controller_api, project):
+async def test_write_file(app: FastAPI, client: AsyncClient, project: Project) -> None:
 
-    response = await controller_api.post("/projects/{project_id}/files/hello".format(project_id=project.id), body="world", raw=True)
-    assert response.status_code == 204
+    response = await client.post(app.url_path_for("write_file", project_id=project.id, file_path="hello"),
+                                 content=b"world")
+    assert response.status_code == status.HTTP_204_NO_CONTENT
 
     with open(os.path.join(project.path, "hello")) as f:
         assert f.read() == "world"
 
-    response = await controller_api.post("/projects/{project_id}/files/../hello".format(project_id=project.id), raw=True)
-    assert response.status_code == 404
+    response = await client.post(app.url_path_for("write_file", project_id=project.id, file_path="../hello"))
+    assert response.status_code == status.HTTP_404_NOT_FOUND
 
 
-@pytest.mark.asyncio
-async def test_write_and_get_file_with_leading_slashes_in_filename(controller_api, project):
+async def test_write_and_get_file_with_leading_slashes_in_filename(
+        app: FastAPI,
+        client: AsyncClient,
+        project: Project) -> None:
 
-    response = await controller_api.post("/projects/{project_id}/files//hello".format(project_id=project.id), body="world", raw=True)
-    assert response.status_code == 204
+    response = await client.post(app.url_path_for("write_file", project_id=project.id, file_path="//hello"),
+                                 content=b"world")
+    assert response.status_code == status.HTTP_204_NO_CONTENT
 
-    response = await controller_api.get("/projects/{project_id}/files//hello".format(project_id=project.id), raw=True)
-    assert response.status_code == 200
+    response = await client.get(app.url_path_for("get_file", project_id=project.id, file_path="//hello"))
+    assert response.status_code == status.HTTP_200_OK
     assert response.content == b"world"
 
 
-@pytest.mark.asyncio
-async def test_import(controller_api, tmpdir, controller):
+async def test_import(app: FastAPI, client: AsyncClient, tmpdir, controller: Controller) -> None:
 
     with zipfile.ZipFile(str(tmpdir / "test.zip"), 'w') as myzip:
         myzip.writestr("project.gns3", b'{"project_id": "c6992992-ac72-47dc-833b-54aa334bcd05", "version": "2.0.0", "name": "test"}')
@@ -369,8 +366,8 @@ async def test_import(controller_api, tmpdir, controller):
 
     project_id = str(uuid.uuid4())
     with open(str(tmpdir / "test.zip"), "rb") as f:
-        response = await controller_api.post("/projects/{project_id}/import".format(project_id=project_id), body=f.read(), raw=True)
-    assert response.status_code == 201
+        response = await client.post(app.url_path_for("import_project", project_id=project_id), content=f.read())
+    assert response.status_code == status.HTTP_201_CREATED
 
     project = controller.get_project(project_id)
     with open(os.path.join(project.path, "demo")) as f:
@@ -378,9 +375,8 @@ async def test_import(controller_api, tmpdir, controller):
     assert content == "hello"
 
 
-@pytest.mark.asyncio
-async def test_duplicate(controller_api, project):
+async def test_duplicate(app: FastAPI, client: AsyncClient, project: Project) -> None:
 
-    response = await controller_api.post("/projects/{project_id}/duplicate".format(project_id=project.id), {"name": "hello"})
-    assert response.status_code == 201
-    assert response.json["name"] == "hello"
+    response = await client.post(app.url_path_for("duplicate_project", project_id=project.id), json={"name": "hello"})
+    assert response.status_code == status.HTTP_201_CREATED
+    assert response.json()["name"] == "hello"

tests/api/routes/controller/test_snapshots.py

@@ -19,54 +19,57 @@ import os
 import uuid
 import pytest
 
+from fastapi import FastAPI, status
+from httpx import AsyncClient
+
+from gns3server.controller import Controller
+from gns3server.controller.project import Project
+from gns3server.controller.snapshot import Snapshot
+
+pytestmark = pytest.mark.asyncio
+
 
 @pytest.fixture
-@pytest.mark.asyncio
-async def project(controller_api, controller):
+async def project(app: FastAPI, client: AsyncClient, controller: Controller) -> Project:
 
     u = str(uuid.uuid4())
     params = {"name": "test", "project_id": u}
-    await controller_api.post("/projects", params)
+    await client.post(app.url_path_for("create_project"), json=params)
     project = controller.get_project(u)
     return project
 
 
 @pytest.fixture
-@pytest.mark.asyncio
-async def snapshot(project):
+async def snapshot(project: Project):
 
     snapshot = await project.snapshot("test")
     return snapshot
 
 
-@pytest.mark.asyncio
-async def test_list_snapshots(controller_api, project, snapshot):
+async def test_list_snapshots(app: FastAPI, client: AsyncClient, project: Project, snapshot: Snapshot) -> None:
 
     assert snapshot.name == "test"
-    response = await controller_api.get("/projects/{}/snapshots".format(project.id))
-    assert response.status_code == 200
-    assert len(response.json) == 1
+    response = await client.get(app.url_path_for("get_snapshots", project_id=project.id))
+    assert response.status_code == status.HTTP_200_OK
+    assert len(response.json()) == 1
 
 
-@pytest.mark.asyncio
-async def test_delete_snapshot(controller_api, project, snapshot):
+async def test_delete_snapshot(app: FastAPI, client: AsyncClient, project: Project, snapshot: Snapshot) -> None:
 
-    response = await controller_api.delete("/projects/{}/snapshots/{}".format(project.id, snapshot.id))
-    assert response.status_code == 204
+    response = await client.delete(app.url_path_for("delete_snapshot", project_id=project.id, snapshot_id=snapshot.id))
+    assert response.status_code == status.HTTP_204_NO_CONTENT
     assert not os.path.exists(snapshot.path)
 
 
-@pytest.mark.asyncio
-async def test_restore_snapshot(controller_api, project, snapshot):
+async def test_restore_snapshot(app: FastAPI, client: AsyncClient, project: Project, snapshot: Snapshot) -> None:
 
-    response = await controller_api.post("/projects/{}/snapshots/{}/restore".format(project.id, snapshot.id))
-    assert response.status_code == 201
-    assert response.json["name"] == project.name
+    response = await client.post(app.url_path_for("restore_snapshot", project_id=project.id, snapshot_id=snapshot.id))
+    assert response.status_code == status.HTTP_201_CREATED
+    assert response.json()["name"] == project.name
 
 
-@pytest.mark.asyncio
-async def test_create_snapshot(controller_api, project):
+async def test_create_snapshot(app: FastAPI, client: AsyncClient, project: Project) -> None:
 
-    response = await controller_api.post("/projects/{}/snapshots".format(project.id), {"name": "snap1"})
-    assert response.status_code == 201
+    response = await client.post(app.url_path_for("create_snapshot", project_id=project.id), json={"name": "snap1"})
+    assert response.status_code == status.HTTP_201_CREATED
     assert len(os.listdir(os.path.join(project.path, "snapshots"))) == 1

tests/api/routes/controller/test_symbols.py

@@ -20,44 +20,49 @@ import pytest
 import os
 import urllib.parse
 
+from fastapi import FastAPI, status
+from httpx import AsyncClient
 
-@pytest.mark.asyncio
-async def test_symbols(controller_api):
+from gns3server.controller import Controller
 
-    response = await controller_api.get('/symbols')
+pytestmark = pytest.mark.asyncio
 
-    assert response.status_code == 200
+
+async def test_symbols(app: FastAPI, client: AsyncClient) -> None:
+
+    response = await client.get(app.url_path_for("get_symbols"))
+
+    assert response.status_code == status.HTTP_200_OK
     assert {
         'symbol_id': ':/symbols/classic/firewall.svg',
         'filename': 'firewall.svg',
         'builtin': True,
         'theme': 'Classic'
-    } in response.json
+    } in response.json()
 
 
-@pytest.mark.asyncio
-async def test_get(controller_api, controller):
+async def test_get(app: FastAPI, client: AsyncClient, controller: Controller) -> None:
 
     controller.symbols.theme = "Classic"
-    response = await controller_api.get('/symbols/' + urllib.parse.quote(':/symbols/classic/firewall.svg') + '/raw')
-    assert response.status_code == 200
+    url = app.url_path_for("get_symbol", symbol_id=urllib.parse.quote(':/symbols/classic/firewall.svg'))
+    response = await client.get(url)
+    assert response.status_code == status.HTTP_200_OK
     assert response.headers['CONTENT-TYPE'] == 'image/svg+xml'
     assert response.headers['CONTENT-LENGTH'] == '9381'
     assert '</svg>' in response.text
 
     # Reply with the default symbol
-    response = await controller_api.get('/symbols/404.png/raw')
-    assert response.status_code == 200
+    response = await client.get(app.url_path_for("get_symbol", symbol_id="404.png"))
+    assert response.status_code == status.HTTP_200_OK
 
 
-@pytest.mark.asyncio
-async def test_upload(controller_api, symbols_dir):
+async def test_upload(app: FastAPI, client: AsyncClient, symbols_dir: str) -> None:
 
-    response = await controller_api.post("/symbols/test2/raw", body=b"TEST", raw=True)
-    assert response.status_code == 204
+    response = await client.post(app.url_path_for("upload_symbol", symbol_id="test2"), content=b"TEST")
+    assert response.status_code == status.HTTP_204_NO_CONTENT
 
     with open(os.path.join(symbols_dir, "test2")) as f:
         assert f.read() == "TEST"
 
-    response = await controller_api.get('/symbols/test2/raw')
-    assert response.status_code == 200
+    response = await client.get(app.url_path_for("get_symbol", symbol_id="test2"))
+    assert response.status_code == status.HTTP_200_OK

tests/api/routes/controller/test_templates.py

@@ -19,13 +19,16 @@ import pytest
 import uuid
 
 from pathlib import Path
-from tests.utils import asyncio_patch
+from fastapi import FastAPI, status
+from httpx import AsyncClient
 
+from gns3server.controller import Controller
 from gns3server.controller.template import Template
 
+pytestmark = pytest.mark.asyncio
 
-@pytest.mark.asyncio
-async def test_template_list(controller_api, controller):
+
+async def test_template_list(app: FastAPI, client: AsyncClient, controller: Controller) -> None:
 
     id = str(uuid.uuid4())
     controller.template_manager.load_templates()
@@ -37,13 +40,12 @@ async def test_template_list(controller_api, controller):
         "default_name_format": "{name}-{0}",
         "compute_id": "local"
     })
-    response = await controller_api.get("/templates")
-    assert response.status_code == 200
-    assert len(response.json) > 0
+    response = await client.get(app.url_path_for("get_templates"))
+    assert response.status_code == status.HTTP_200_OK
+    assert len(response.json()) > 0
 
 
-@pytest.mark.asyncio
-async def test_template_create_without_id(controller_api, controller):
+async def test_template_create_without_id(app: FastAPI, client: AsyncClient, controller: Controller) -> None:
 
     params = {"base_script_file": "vpcs_base_config.txt",
               "category": "guest",
@@ -55,14 +57,13 @@ async def test_template_create_without_id(controller_api, controller):
               "symbol": ":/symbols/vpcs_guest.svg",
               "template_type": "vpcs"}
 
-    response = await controller_api.post("/templates", params)
-    assert response.status_code == 201
-    assert response.json["template_id"] is not None
+    response = await client.post(app.url_path_for("create_template"), json=params)
+    assert response.status_code == status.HTTP_201_CREATED
+    assert response.json()["template_id"] is not None
     assert len(controller.template_manager.templates) == 1
 
 
-@pytest.mark.asyncio
-async def test_template_create_with_id(controller_api, controller):
+async def test_template_create_with_id(app: FastAPI, client: AsyncClient, controller: Controller):
 
     params = {"template_id": str(uuid.uuid4()),
               "base_script_file": "vpcs_base_config.txt",
@@ -75,14 +76,13 @@ async def test_template_create_with_id(controller_api, controller):
               "symbol": ":/symbols/vpcs_guest.svg",
               "template_type": "vpcs"}
 
-    response = await controller_api.post("/templates", params)
-    assert response.status_code == 201
-    assert response.json["template_id"] is not None
+    response = await client.post(app.url_path_for("create_template"), json=params)
+    assert response.status_code == status.HTTP_201_CREATED
+    assert response.json()["template_id"] is not None
     assert len(controller.template_manager.templates) == 1
 
 
-@pytest.mark.asyncio
-async def test_template_create_wrong_type(controller_api, controller):
+async def test_template_create_wrong_type(app: FastAPI, client: AsyncClient, controller: Controller) -> None:
 
     params = {"template_id": str(uuid.uuid4()),
               "base_script_file": "vpcs_base_config.txt",
@@ -95,13 +95,12 @@ async def test_template_create_wrong_type(controller_api, controller):
               "symbol": ":/symbols/vpcs_guest.svg",
               "template_type": "invalid_template_type"}
 
-    response = await controller_api.post("/templates", params)
-    assert response.status_code == 422
+    response = await client.post(app.url_path_for("create_template"), json=params)
+    assert response.status_code == status.HTTP_422_UNPROCESSABLE_ENTITY
     assert len(controller.template_manager.templates) == 0
 
 
-@pytest.mark.asyncio
-async def test_template_get(controller_api):
+async def test_template_get(app: FastAPI, client: AsyncClient) -> None:
 
     template_id = str(uuid.uuid4())
     params = {"template_id": template_id,
@@ -115,16 +114,15 @@ async def test_template_get(controller_api):
               "symbol": ":/symbols/vpcs_guest.svg",
               "template_type": "vpcs"}
 
-    response = await controller_api.post("/templates", params)
-    assert response.status_code == 201
+    response = await client.post(app.url_path_for("create_template"), json=params)
+    assert response.status_code == status.HTTP_201_CREATED
 
-    response = await controller_api.get("/templates/{}".format(template_id))
-    assert response.status_code == 200
-    assert response.json["template_id"] == template_id
+    response = await client.get(app.url_path_for("get_template", template_id=template_id))
+    assert response.status_code == status.HTTP_200_OK
+    assert response.json()["template_id"] == template_id
 
 
-@pytest.mark.asyncio
-async def test_template_update(controller_api):
+async def test_template_update(app: FastAPI, client: AsyncClient) -> None:
 
     template_id = str(uuid.uuid4())
     params = {"template_id": template_id,
@@ -138,22 +136,21 @@ async def test_template_update(controller_api):
               "symbol": ":/symbols/vpcs_guest.svg",
               "template_type": "vpcs"}
 
-    response = await controller_api.post("/templates", params)
-    assert response.status_code == 201
+    response = await client.post(app.url_path_for("create_template"), json=params)
+    assert response.status_code == status.HTTP_201_CREATED
 
-    response = await controller_api.get("/templates/{}".format(template_id))
-    assert response.status_code == 200
-    assert response.json["template_id"] == template_id
+    response = await client.get(app.url_path_for("get_template", template_id=template_id))
+    assert response.status_code == status.HTTP_200_OK
+    assert response.json()["template_id"] == template_id
 
     params["name"] = "VPCS_TEST_RENAMED"
-    response = await controller_api.put("/templates/{}".format(template_id), params)
+    response = await client.put(app.url_path_for("update_template", template_id=template_id), json=params)
 
-    assert response.status_code == 200
-    assert response.json["name"] == "VPCS_TEST_RENAMED"
+    assert response.status_code == status.HTTP_200_OK
+    assert response.json()["name"] == "VPCS_TEST_RENAMED"
 
 
-@pytest.mark.asyncio
-async def test_template_delete(controller_api, controller):
+async def test_template_delete(app: FastAPI, client: AsyncClient, controller: Controller) -> None:
 
     template_id = str(uuid.uuid4())
     params = {"template_id": template_id,
@@ -167,23 +164,22 @@ async def test_template_delete(controller_api, controller):
               "symbol": ":/symbols/vpcs_guest.svg",
               "template_type": "vpcs"}
 
-    response = await controller_api.post("/templates", params)
-    assert response.status_code == 201
+    response = await client.post(app.url_path_for("create_template"), json=params)
+    assert response.status_code == status.HTTP_201_CREATED
 
-    response = await controller_api.get("/templates")
-    assert len(response.json) == 1
+    response = await client.get(app.url_path_for("get_templates"))
+    assert len(response.json()) == 1
     assert len(controller.template_manager._templates) == 1
 
-    response = await controller_api.delete("/templates/{}".format(template_id))
-    assert response.status_code == 204
+    response = await client.delete(app.url_path_for("delete_template", template_id=template_id))
+    assert response.status_code == status.HTTP_204_NO_CONTENT
 
-    response = await controller_api.get("/templates")
-    assert len(response.json) == 0
+    response = await client.get(app.url_path_for("get_templates"))
+    assert len(response.json()) == 0
     assert len(controller.template_manager.templates) == 0
 
 
-@pytest.mark.asyncio
-async def test_template_duplicate(controller_api, controller):
+async def test_template_duplicate(app: FastAPI, client: AsyncClient, controller: Controller) -> None:
 
     template_id = str(uuid.uuid4())
     params = {"template_id": template_id,
@@ -197,23 +193,22 @@ async def test_template_duplicate(controller_api, controller):
               "symbol": ":/symbols/vpcs_guest.svg",
               "template_type": "vpcs"}
 
-    response = await controller_api.post("/templates", params)
-    assert response.status_code == 201
+    response = await client.post(app.url_path_for("create_template"), json=params)
+    assert response.status_code == status.HTTP_201_CREATED
 
-    response = await controller_api.post("/templates/{}/duplicate".format(template_id))
-    assert response.status_code == 201
-    assert response.json["template_id"] != template_id
+    response = await client.post(app.url_path_for("duplicate_template", template_id=template_id))
+    assert response.status_code == status.HTTP_201_CREATED
+    assert response.json()["template_id"] != template_id
     params.pop("template_id")
     for param, value in params.items():
-        assert response.json[param] == value
+        assert response.json()[param] == value
 
-    response = await controller_api.get("/templates")
-    assert len(response.json) == 2
+    response = await client.get(app.url_path_for("get_templates"))
+    assert len(response.json()) == 2
     assert len(controller.template_manager.templates) == 2
 
 
-@pytest.mark.asyncio
-async def test_c7200_dynamips_template_create(controller_api):
+async def test_c7200_dynamips_template_create(app: FastAPI, client: AsyncClient) -> None:
 
     params = {"name": "Cisco c7200 template",
               "platform": "c7200",
@@ -221,9 +216,9 @@ async def test_c7200_dynamips_template_create(controller_api):
               "image": "c7200-adventerprisek9-mz.124-24.T5.image",
               "template_type": "dynamips"}
 
-    response = await controller_api.post("/templates", params)
-    assert response.status_code == 201
-    assert response.json["template_id"] is not None
+    response = await client.post(app.url_path_for("create_template"), json=params)
+    assert response.status_code == status.HTTP_201_CREATED
+    assert response.json()["template_id"] is not None
 
     expected_response = {"template_type": "dynamips",
                          "auto_delete_disks": False,
@@ -255,11 +250,10 @@ async def test_c7200_dynamips_template_create(controller_api):
                          "system_id": "FTX0945W0MY"}
 
     for item, value in expected_response.items():
-        assert response.json.get(item) == value
+        assert response.json().get(item) == value
 
 
-@pytest.mark.asyncio
-async def test_c3745_dynamips_template_create(controller_api):
+async def test_c3745_dynamips_template_create(app: FastAPI, client: AsyncClient) -> None:
 
     params = {"name": "Cisco c3745 template",
               "platform": "c3745",
@@ -267,9 +261,9 @@ async def test_c3745_dynamips_template_create(controller_api):
               "image": "c3745-adventerprisek9-mz.124-25d.image",
               "template_type": "dynamips"}
 
-    response = await controller_api.post("/templates", params)
-    assert response.status_code == 201
-    assert response.json["template_id"] is not None
+    response = await client.post(app.url_path_for("create_template"), json=params)
+    assert response.status_code == status.HTTP_201_CREATED
+    assert response.json()["template_id"] is not None
 
     expected_response = {"template_type": "dynamips",
                          "auto_delete_disks": False,
@@ -300,11 +294,10 @@ async def test_c3745_dynamips_template_create(controller_api):
                          "system_id": "FTX0945W0MY"}
 
     for item, value in expected_response.items():
-        assert response.json.get(item) == value
+        assert response.json().get(item) == value
 
 
-@pytest.mark.asyncio
-async def test_c3725_dynamips_template_create(controller_api):
+async def test_c3725_dynamips_template_create(app: FastAPI, client: AsyncClient) -> None:
 
     params = {"name": "Cisco c3725 template",
               "platform": "c3725",
@@ -312,9 +305,9 @@ async def test_c3725_dynamips_template_create(controller_api):
               "image": "c3725-adventerprisek9-mz.124-25d.image",
               "template_type": "dynamips"}
 
-    response = await controller_api.post("/templates", params)
-    assert response.status_code == 201
-    assert response.json["template_id"] is not None
+    response = await client.post(app.url_path_for("create_template"), json=params)
+    assert response.status_code == status.HTTP_201_CREATED
+    assert response.json()["template_id"] is not None
 
     expected_response = {"template_type": "dynamips",
                          "auto_delete_disks": False,
@@ -345,11 +338,10 @@ async def test_c3725_dynamips_template_create(controller_api):
                          "system_id": "FTX0945W0MY"}
 
     for item, value in expected_response.items():
-        assert response.json.get(item) == value
+        assert response.json().get(item) == value
 
 
-@pytest.mark.asyncio
-async def test_c3600_dynamips_template_create(controller_api):
+async def test_c3600_dynamips_template_create(app: FastAPI, client: AsyncClient) -> None:
 
     params = {"name": "Cisco c3600 template",
               "platform": "c3600",
@@ -358,9 +350,9 @@ async def test_c3600_dynamips_template_create(controller_api):
               "image": "c3660-a3jk9s-mz.124-25d.image",
               "template_type": "dynamips"}
 
-    response = await controller_api.post("/templates", params)
-    assert response.status_code == 201
-    assert response.json["template_id"] is not None
+    response = await client.post(app.url_path_for("create_template"), json=params)
+    assert response.status_code == status.HTTP_201_CREATED
+    assert response.json()["template_id"] is not None
 
     expected_response = {"template_type": "dynamips",
                          "auto_delete_disks": False,
@@ -392,11 +384,10 @@ async def test_c3600_dynamips_template_create(controller_api):
                          "system_id": "FTX0945W0MY"}
 
     for item, value in expected_response.items():
-        assert response.json.get(item) == value
+        assert response.json().get(item) == value
 
 
-@pytest.mark.asyncio
-async def test_c3600_dynamips_template_create_wrong_chassis(controller_api):
+async def test_c3600_dynamips_template_create_wrong_chassis(app: FastAPI, client: AsyncClient) -> None:
 
     params = {"name": "Cisco c3600 template",
               "platform": "c3600",
@@ -405,12 +396,11 @@ async def test_c3600_dynamips_template_create_wrong_chassis(controller_api):
               "image": "c3660-a3jk9s-mz.124-25d.image",
               "template_type": "dynamips"}
 
-    response = await controller_api.post("/templates", params)
-    assert response.status_code == 409
+    response = await client.post(app.url_path_for("create_template"), json=params)
+    assert response.status_code == status.HTTP_409_CONFLICT
 
 
-@pytest.mark.asyncio
-async def test_c2691_dynamips_template_create(controller_api):
+async def test_c2691_dynamips_template_create(app: FastAPI, client: AsyncClient) -> None:
 
     params = {"name": "Cisco c2691 template",
               "platform": "c2691",
@@ -418,9 +408,9 @@ async def test_c2691_dynamips_template_create(controller_api):
               "image": "c2691-adventerprisek9-mz.124-25d.image",
               "template_type": "dynamips"}
 
-    response = await controller_api.post("/templates", params)
-    assert response.status_code == 201
-    assert response.json["template_id"] is not None
+    response = await client.post(app.url_path_for("create_template"), json=params)
+    assert response.status_code == status.HTTP_201_CREATED
+    assert response.json()["template_id"] is not None
 
     expected_response = {"template_type": "dynamips",
                          "auto_delete_disks": False,
@@ -451,11 +441,10 @@ async def test_c2691_dynamips_template_create(controller_api):
                          "system_id": "FTX0945W0MY"}
 
     for item, value in expected_response.items():
-        assert response.json.get(item) == value
+        assert response.json().get(item) == value
 
 
-@pytest.mark.asyncio
-async def test_c2600_dynamips_template_create(controller_api):
+async def test_c2600_dynamips_template_create(app: FastAPI, client: AsyncClient) -> None:
 
     params = {"name": "Cisco c2600 template",
               "platform": "c2600",
@@ -464,9 +453,9 @@ async def test_c2600_dynamips_template_create(controller_api):
               "image": "c2600-adventerprisek9-mz.124-25d.image",
               "template_type": "dynamips"}
 
-    response = await controller_api.post("/templates", params)
-    assert response.status_code == 201
-    assert response.json["template_id"] is not None
+    response = await client.post(app.url_path_for("create_template"), json=params)
+    assert response.status_code == status.HTTP_201_CREATED
+    assert response.json()["template_id"] is not None
 
     expected_response = {"template_type": "dynamips",
                          "auto_delete_disks": False,
@@ -498,11 +487,10 @@ async def test_c2600_dynamips_template_create(controller_api):
                          "system_id": "FTX0945W0MY"}
 
     for item, value in expected_response.items():
-        assert response.json.get(item) == value
+        assert response.json().get(item) == value
 
 
-@pytest.mark.asyncio
-async def test_c2600_dynamips_template_create_wrong_chassis(controller_api):
+async def test_c2600_dynamips_template_create_wrong_chassis(app: FastAPI, client: AsyncClient) -> None:
 
     params = {"name": "Cisco c2600 template",
               "platform": "c2600",
@@ -511,12 +499,11 @@ async def test_c2600_dynamips_template_create_wrong_chassis(controller_api):
               "image": "c2600-adventerprisek9-mz.124-25d.image",
               "template_type": "dynamips"}
 
-    response = await controller_api.post("/templates", params)
-    assert response.status_code == 409
+    response = await client.post(app.url_path_for("create_template"), json=params)
+    assert response.status_code == status.HTTP_409_CONFLICT
 
 
-@pytest.mark.asyncio
-async def test_c1700_dynamips_template_create(controller_api):
+async def test_c1700_dynamips_template_create(app: FastAPI, client: AsyncClient) -> None:
 
     params = {"name": "Cisco c1700 template",
               "platform": "c1700",
@@ -525,9 +512,9 @@ async def test_c1700_dynamips_template_create(controller_api):
               "image": "c1700-adventerprisek9-mz.124-25d.image",
               "template_type": "dynamips"}
 
-    response = await controller_api.post("/templates", params)
-    assert response.status_code == 201
-    assert response.json["template_id"] is not None
+    response = await client.post(app.url_path_for("create_template"), json=params)
+    assert response.status_code == status.HTTP_201_CREATED
+    assert response.json()["template_id"] is not None
 
     expected_response = {"template_type": "dynamips",
                          "auto_delete_disks": False,
@@ -559,11 +546,10 @@ async def test_c1700_dynamips_template_create(controller_api):
                          "system_id": "FTX0945W0MY"}
 
     for item, value in expected_response.items():
-        assert response.json.get(item) == value
+        assert response.json().get(item) == value
 
 
-@pytest.mark.asyncio
-async def test_c1700_dynamips_template_create_wrong_chassis(controller_api):
+async def test_c1700_dynamips_template_create_wrong_chassis(app: FastAPI, client: AsyncClient) -> None:
 
     params = {"name": "Cisco c1700 template",
               "platform": "c1700",
@@ -572,12 +558,11 @@ async def test_c1700_dynamips_template_create_wrong_chassis(controller_api):
               "image": "c1700-adventerprisek9-mz.124-25d.image",
               "template_type": "dynamips"}
 
-    response = await controller_api.post("/templates", params)
-    assert response.status_code == 409
+    response = await client.post(app.url_path_for("create_template"), json=params)
+    assert response.status_code == status.HTTP_409_CONFLICT
 
 
-@pytest.mark.asyncio
-async def test_dynamips_template_create_wrong_platform(controller_api):
+async def test_dynamips_template_create_wrong_platform(app: FastAPI, client: AsyncClient) -> None:
 
     params = {"name": "Cisco c3900 template",
               "platform": "c3900",
@@ -585,12 +570,11 @@ async def test_dynamips_template_create_wrong_platform(controller_api):
               "image": "c3900-test.124-25d.image",
               "template_type": "dynamips"}
 
-    response = await controller_api.post("/templates", params)
-    assert response.status_code == 409
+    response = await client.post(app.url_path_for("create_template"), json=params)
+    assert response.status_code == status.HTTP_409_CONFLICT
 
 
-@pytest.mark.asyncio
-async def test_iou_template_create(controller_api):
+async def test_iou_template_create(app: FastAPI, client: AsyncClient) -> None:
 
     image_path = str(Path("/path/to/i86bi_linux-ipbase-ms-12.4.bin"))
     params = {"name": "IOU template",
@@ -598,9 +582,9 @@ async def test_iou_template_create(controller_api):
               "path": image_path,
               "template_type": "iou"}
 
-    response = await controller_api.post("/templates", params)
-    assert response.status_code == 201
-    assert response.json["template_id"] is not None
+    response = await client.post(app.url_path_for("create_template"), json=params)
+    assert response.status_code == status.HTTP_201_CREATED
+    assert response.json()["template_id"] is not None
 
     expected_response = {"template_type": "iou",
                          "builtin": False,
@@ -622,20 +606,19 @@ async def test_iou_template_create(controller_api):
                          "l1_keepalives": False}
 
     for item, value in expected_response.items():
-        assert response.json.get(item) == value
+        assert response.json().get(item) == value
 
 
-@pytest.mark.asyncio
-async def test_docker_template_create(controller_api):
+async def test_docker_template_create(app: FastAPI, client: AsyncClient) -> None:
 
     params = {"name": "Docker template",
               "compute_id": "local",
               "image": "gns3/endhost:latest",
               "template_type": "docker"}
 
-    response = await controller_api.post("/templates", params)
-    assert response.status_code == 201
-    assert response.json["template_id"] is not None
+    response = await client.post(app.url_path_for("create_template"), json=params)
+    assert response.status_code == status.HTTP_201_CREATED
+    assert response.json()["template_id"] is not None
 
     expected_response = {"adapters": 1,
                          "template_type": "docker",
@@ -657,11 +640,10 @@ async def test_docker_template_create(controller_api):
                          "custom_adapters": []}
 
     for item, value in expected_response.items():
-        assert response.json.get(item) == value
+        assert response.json().get(item) == value
 
 
-@pytest.mark.asyncio
-async def test_qemu_template_create(controller_api):
+async def test_qemu_template_create(app: FastAPI, client: AsyncClient) -> None:
 
     params = {"name": "Qemu template",
               "compute_id": "local",
@@ -670,9 +652,9 @@ async def test_qemu_template_create(controller_api):
               "ram": 512,
               "template_type": "qemu"}
 
-    response = await controller_api.post("/templates", params)
-    assert response.status_code == 201
-    assert response.json["template_id"] is not None
+    response = await client.post(app.url_path_for("create_template"), json=params)
+    assert response.status_code == status.HTTP_201_CREATED
+    assert response.json()["template_id"] is not None
 
     expected_response = {"adapter_type": "e1000",
                          "adapters": 1,
@@ -717,11 +699,10 @@ async def test_qemu_template_create(controller_api):
                          "custom_adapters": []}
 
     for item, value in expected_response.items():
-        assert response.json.get(item) == value
+        assert response.json().get(item) == value
 
 
-@pytest.mark.asyncio
-async def test_vmware_template_create(controller_api):
+async def test_vmware_template_create(app: FastAPI, client: AsyncClient) -> None:
 
     vmx_path = str(Path("/path/to/vm.vmx"))
     params = {"name": "VMware template",
@@ -729,9 +710,9 @@ async def test_vmware_template_create(controller_api):
               "template_type": "vmware",
               "vmx_path": vmx_path}
 
-    response = await controller_api.post("/templates", params)
-    assert response.status_code == 201
-    assert response.json["template_id"] is not None
+    response = await client.post(app.url_path_for("create_template"), json=params)
+    assert response.status_code == status.HTTP_201_CREATED
+    assert response.json()["template_id"] is not None
 
     expected_response = {"adapter_type": "e1000",
                          "adapters": 1,
@@ -755,20 +736,19 @@ async def test_vmware_template_create(controller_api):
                          "custom_adapters": []}
 
     for item, value in expected_response.items():
-        assert response.json.get(item) == value
+        assert response.json().get(item) == value
 
 
-@pytest.mark.asyncio
-async def test_virtualbox_template_create(controller_api):
+async def test_virtualbox_template_create(app: FastAPI, client: AsyncClient) -> None:
 
     params = {"name": "VirtualBox template",
               "compute_id": "local",
               "template_type": "virtualbox",
               "vmname": "My VirtualBox VM"}
 
-    response = await controller_api.post("/templates", params)
-    assert response.status_code == 201
-    assert response.json["template_id"] is not None
+    response = await client.post(app.url_path_for("create_template"), json=params)
+    assert response.status_code == status.HTTP_201_CREATED
+    assert response.json()["template_id"] is not None
 
     expected_response = {"adapter_type": "Intel PRO/1000 MT Desktop (82540EM)",
                          "adapters": 1,
@@ -793,19 +773,18 @@ async def test_virtualbox_template_create(controller_api):
                          "custom_adapters": []}
 
     for item, value in expected_response.items():
-        assert response.json.get(item) == value
+        assert response.json().get(item) == value
 
 
-@pytest.mark.asyncio
-async def test_vpcs_template_create(controller_api):
+async def test_vpcs_template_create(app: FastAPI, client: AsyncClient) -> None:
 
     params = {"name": "VPCS template",
               "compute_id": "local",
               "template_type": "vpcs"}
 
-    response = await controller_api.post("/templates", params)
-    assert response.status_code == 201
-    assert response.json["template_id"] is not None
+    response = await client.post(app.url_path_for("create_template"), json=params)
+    assert response.status_code == status.HTTP_201_CREATED
+    assert response.json()["template_id"] is not None
 
     expected_response = {"template_type": "vpcs",
                          "base_script_file": "vpcs_base_config.txt",
@@ -819,19 +798,18 @@ async def test_vpcs_template_create(controller_api):
                          "symbol": ":/symbols/vpcs_guest.svg"}
 
     for item, value in expected_response.items():
-        assert response.json.get(item) == value
+        assert response.json().get(item) == value
 
 
-@pytest.mark.asyncio
-async def test_ethernet_switch_template_create(controller_api):
+async def test_ethernet_switch_template_create(app: FastAPI, client: AsyncClient) -> None:
 
     params = {"name": "Ethernet switch template",
               "compute_id": "local",
               "template_type": "ethernet_switch"}
 
-    response = await controller_api.post("/templates", params)
-    assert response.status_code == 201
-    assert response.json["template_id"] is not None
+    response = await client.post(app.url_path_for("create_template"), json=params)
+    assert response.status_code == status.HTTP_201_CREATED
+    assert response.json()["template_id"] is not None
 
     expected_response = {"template_type": "ethernet_switch",
                          "builtin": False,
@@ -840,49 +818,49 @@ async def test_ethernet_switch_template_create(controller_api):
                          "console_type": "none",
                          "default_name_format": "Switch{0}",
                          "name": "Ethernet switch template",
-                         "ports_mapping": [{"ethertype": "",
+                         "ports_mapping": [{"ethertype": "0x8100",
                                             "name": "Ethernet0",
                                             "port_number": 0,
                                             "type": "access",
                                             "vlan": 1
                                             },
-                                           {"ethertype": "",
+                                           {"ethertype": "0x8100",
                                             "name": "Ethernet1",
                                             "port_number": 1,
                                             "type": "access",
                                             "vlan": 1
                                             },
-                                           {"ethertype": "",
+                                           {"ethertype": "0x8100",
                                             "name": "Ethernet2",
                                             "port_number": 2,
                                             "type": "access",
                                             "vlan": 1
                                             },
-                                           {"ethertype": "",
+                                           {"ethertype": "0x8100",
                                             "name": "Ethernet3",
                                             "port_number": 3,
                                             "type": "access",
                                             "vlan": 1
                                             },
-                                           {"ethertype": "",
+                                           {"ethertype": "0x8100",
                                             "name": "Ethernet4",
                                             "port_number": 4,
                                             "type": "access",
                                             "vlan": 1
                                             },
-                                           {"ethertype": "",
+                                           {"ethertype": "0x8100",
                                             "name": "Ethernet5",
                                             "port_number": 5,
                                             "type": "access",
                                             "vlan": 1
                                             },
-                                           {"ethertype": "",
+                                           {"ethertype": "0x8100",
                                             "name": "Ethernet6",
                                             "port_number": 6,
                                             "type": "access",
                                             "vlan": 1
                                             },
-                                           {"ethertype": "",
+                                           {"ethertype": "0x8100",
                                             "name": "Ethernet7",
                                             "port_number": 7,
                                             "type": "access",
@@ -891,19 +869,18 @@ async def test_ethernet_switch_template_create(controller_api):
                          "symbol": ":/symbols/ethernet_switch.svg"}
 
     for item, value in expected_response.items():
-        assert response.json.get(item) == value
+        assert response.json().get(item) == value
 
 
-@pytest.mark.asyncio
-async def test_cloud_template_create(controller_api):
+async def test_cloud_template_create(app: FastAPI, client: AsyncClient) -> None:
 
     params = {"name": "Cloud template",
               "compute_id": "local",
               "template_type": "cloud"}
 
-    response = await controller_api.post("/templates", params)
-    assert response.status_code == 201
-    assert response.json["template_id"] is not None
+    response = await client.post(app.url_path_for("create_template"), json=params)
+    assert response.status_code == status.HTTP_201_CREATED
+    assert response.json()["template_id"] is not None
 
     expected_response = {"template_type": "cloud",
                          "builtin": False,
@@ -919,19 +896,18 @@ async def test_cloud_template_create(controller_api):
                          "remote_console_http_path": "/"}
 
     for item, value in expected_response.items():
-        assert response.json.get(item) == value
+        assert response.json().get(item) == value
 
 
-@pytest.mark.asyncio
-async def test_ethernet_hub_template_create(controller_api):
+async def test_ethernet_hub_template_create(app: FastAPI, client: AsyncClient) -> None:
 
     params = {"name": "Ethernet hub template",
               "compute_id": "local",
               "template_type": "ethernet_hub"}
 
-    response = await controller_api.post("/templates", params)
-    assert response.status_code == 201
-    assert response.json["template_id"] is not None
+    response = await client.post(app.url_path_for("create_template"), json=params)
+    assert response.status_code == status.HTTP_201_CREATED
+    assert response.json()["template_id"] is not None
 
     expected_response = {"ports_mapping": [{"port_number": 0,
                                             "name": "Ethernet0"
@@ -966,7 +942,7 @@ async def test_ethernet_hub_template_create(controller_api):
                          "builtin": False}
 
     for item, value in expected_response.items():
-        assert response.json.get(item) == value
+        assert response.json().get(item) == value
 
 
 # @pytest.mark.asyncio
@@ -982,9 +958,9 @@ async def test_ethernet_hub_template_create(controller_api):
 #         "compute_id": "example.com"
 #     })}
 #     with asyncio_patch("gns3server.controller.project.Project.add_node_from_template", return_value={"name": "test", "node_type": "qemu", "compute_id": "example.com"}) as mock:
-#         response = await controller_api.post("/projects/{}/templates/{}".format(project.id, id), {
+#         response = await client.post("/projects/{}/templates/{}".format(project.id, id), {
 #             "x": 42,
 #             "y": 12
 #         })
 #     mock.assert_called_with(id, x=42, y=12, compute_id=None)
-#     assert response.status_code == 201
+#     assert response.status_code == status.HTTP_201_CREATED

tests/api/routes/controller/test_users.py

@@ -0,0 +1,62 @@
+#!/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 pytest
+
+from fastapi import FastAPI, status
+from fastapi.encoders import jsonable_encoder
+from httpx import AsyncClient
+
+from gns3server.db.repositories.users import UsersRepository
+from gns3server.schemas.users import User
+
+pytestmark = pytest.mark.asyncio
+
+
+# async def test_route_exist(app: FastAPI, client: AsyncClient) -> None:
+#
+#     params = {"username": "test_username", "email": "user@email.com", "password": "test_password"}
+#     response = await client.post(app.url_path_for("create_user"), json=params)
+#     assert response.status_code != status.HTTP_404_NOT_FOUND
+#
+#
+# async def test_users_can_register_successfully(app: FastAPI, client: AsyncClient) -> None:
+#
+#     user_repo = UsersRepository()
+#     params = {"username": "test_username2", "email": "user2@email.com", "password": "test_password2"}
+#
+#     # make sure the user doesn't exist in the database
+#     user_in_db = await user_repo.get_user_by_username(params["username"])
+#     assert user_in_db is None
+#
+#     # register the user
+#     res = await client.post(app.url_path_for("create_user"), json=params)
+#     assert res.status_code == status.HTTP_201_CREATED
+#
+#     # make sure the user does exists in the database now
+#     user_in_db = await user_repo.get_user_by_username(params["username"])
+#     assert user_in_db is not None
+#     assert user_in_db.email == params["email"]
+#     assert user_in_db.username == params["username"]
+#
+#     # check that the user returned in the response is equal to the user in the database
+#     created_user = User(**res.json()).json()
+#     print(created_user)
+#     #print(user_in_db.__dict__)
+#     test = jsonable_encoder(user_in_db.__dict__, exclude={"_sa_instance_state", "hashed_password"})
+#     print(test)
+#     assert created_user == test

tests/api/routes/controller/test_version.py

@@ -17,47 +17,47 @@
 
 import pytest
 
+from fastapi import FastAPI, status
+from httpx import AsyncClient
+
 from gns3server.version import __version__
 
+pytestmark = pytest.mark.asyncio
 
-@pytest.mark.asyncio
-async def test_version_output(controller_api, config):
+
+async def test_version_output(app: FastAPI, client: AsyncClient, config) -> None:
 
     config.set("Server", "local", "true")
-    response = await controller_api.get('/version')
-    assert response.status_code == 200
-    assert response.json == {'local': True, 'version': __version__}
+    response = await client.get(app.url_path_for("get_version"))
+    assert response.status_code == status.HTTP_200_OK
+    assert response.json() == {'local': True, 'version': __version__}
 
 
-@pytest.mark.asyncio
-async def test_version_input(controller_api):
+async def test_version_input(app: FastAPI, client: AsyncClient) -> None:
 
     params = {'version': __version__}
-    response = await controller_api.post('/version', params)
-    assert response.status_code == 200
-    assert response.json == {'version': __version__}
+    response = await client.post(app.url_path_for("check_version"), json=params)
+    assert response.status_code == status.HTTP_200_OK
+    assert response.json() == {'version': __version__}
 
 
-@pytest.mark.asyncio
-async def test_version_invalid_input(controller_api):
+async def test_version_invalid_input(app: FastAPI, client: AsyncClient) -> None:
 
     params = {'version': "0.4.2"}
-    response = await controller_api.post('/version', params)
-    assert response.status_code == 409
-    assert response.json == {'message': 'Client version 0.4.2 is not the same as server version {}'.format(__version__)}
+    response = await client.post(app.url_path_for("check_version"), json=params)
+    assert response.status_code == status.HTTP_409_CONFLICT
+    assert response.json() == {'message': 'Client version 0.4.2 is not the same as server version {}'.format(__version__)}
 
 
-@pytest.mark.asyncio
-async def test_version_invalid_input_schema(controller_api):
+async def test_version_invalid_input_schema(app: FastAPI, client: AsyncClient) -> None:
 
     params = {'version': "0.4.2", "bla": "blu"}
-    response = await controller_api.post('/version', params)
-    assert response.status_code == 409
+    response = await client.post(app.url_path_for("check_version"), json=params)
+    assert response.status_code == status.HTTP_409_CONFLICT
 
 
-@pytest.mark.asyncio
-async def test_version_invalid_json(controller_api):
+async def test_version_invalid_json(app: FastAPI, client: AsyncClient) -> None:
 
     params = "BOUM"
-    response = await controller_api.post('/version', params, raw=True)
-    assert response.status_code == 422
+    response = await client.post(app.url_path_for("check_version"), json=params)
+    assert response.status_code == status.HTTP_422_UNPROCESSABLE_ENTITY