arno/gns3-server
1
0
Fork 0
mirror of https://github.com/GNS3/gns3-server synced 2025-03-13 07:26:19 +00:00
Code Issues Releases Wiki Activity

Refactor tests and upgrade dev package requirements

Browse Source
This commit is contained in:
grossmj 2025-01-17 19:12:44 +10:00
parent f6725a37dd
commit ba4e0c945d
No known key found for this signature in database
GPG Key ID: 1E7DD6DBB53FF3D7
29 changed files with 5074 additions and 4558 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
dev-requirements.txt
View File

@ -1,7 +1,7 @@
pytest==8.3.3 pytest==8.3.4
flake8==7.1.1 flake8==7.1.1
pytest-timeout==2.3.1 pytest-timeout==2.3.1
pytest-asyncio==0.21.2 pytest-asyncio==0.25.2
requests==2.32.3 requests==2.32.3
httpx==0.27.2 # version 0.24.1 is required by httpx_ws httpx==0.28.1
httpx_ws==0.6.2 httpx_ws==0.7.1

6
tests/api/routes/compute/test_capabilities.py
View File

@ -29,7 +29,9 @@ from gns3server.utils.path import get_default_project_directory
pytestmark = pytest.mark.asyncio pytestmark = pytest.mark.asyncio
async def test_get(app: FastAPI, compute_client: AsyncClient, windows_platform) -> None: class TestCapabilitiesRoutes:
async def test_get(self, app: FastAPI, compute_client: AsyncClient, windows_platform) -> None:
response = await compute_client.get(app.url_path_for("compute:get_capabilities")) response = await compute_client.get(app.url_path_for("compute:get_capabilities"))
assert response.status_code == status.HTTP_200_OK assert response.status_code == status.HTTP_200_OK
@ -42,7 +44,7 @@ async def test_get(app: FastAPI, compute_client: AsyncClient, windows_platform)
} }
async def test_get_on_gns3vm(app: FastAPI, compute_client: AsyncClient, on_gns3vm) -> None: async def test_get_on_gns3vm(self, app: FastAPI, compute_client: AsyncClient, on_gns3vm) -> None:
response = await compute_client.get(app.url_path_for("compute:get_capabilities")) response = await compute_client.get(app.url_path_for("compute:get_capabilities"))
assert response.status_code == status.HTTP_200_OK assert response.status_code == status.HTTP_200_OK

63
tests/api/routes/compute/test_cloud_nodes.py
View File

@ -28,8 +28,10 @@ from gns3server.compute.project import Project
pytestmark = pytest.mark.asyncio pytestmark = pytest.mark.asyncio
@pytest_asyncio.fixture(scope="function") class TestCloudNodesRoutes:
async def vm(app: FastAPI, compute_client: AsyncClient, compute_project: Project, on_gns3vm) -> dict:
@pytest_asyncio.fixture
async def vm(self, app: FastAPI, compute_client: AsyncClient, compute_project: Project, on_gns3vm) -> dict:
with asyncio_patch("gns3server.compute.builtin.nodes.cloud.Cloud._start_ubridge"): with asyncio_patch("gns3server.compute.builtin.nodes.cloud.Cloud._start_ubridge"):
response = await compute_client.post(app.url_path_for("compute:create_cloud", project_id=compute_project.id), response = await compute_client.post(app.url_path_for("compute:create_cloud", project_id=compute_project.id),
@ -38,7 +40,11 @@ async def vm(app: FastAPI, compute_client: AsyncClient, compute_project: Project
return response.json() return response.json()
async def test_cloud_create(app: FastAPI, compute_client: AsyncClient, compute_project: Project) -> None: async def test_cloud_create(
self, app: FastAPI,
compute_client: AsyncClient,
compute_project: Project
) -> None:
with asyncio_patch("gns3server.compute.builtin.nodes.cloud.Cloud._start_ubridge"): with asyncio_patch("gns3server.compute.builtin.nodes.cloud.Cloud._start_ubridge"):
response = await compute_client.post(app.url_path_for("compute:create_cloud", project_id=compute_project.id), response = await compute_client.post(app.url_path_for("compute:create_cloud", project_id=compute_project.id),
@ -48,7 +54,12 @@ async def test_cloud_create(app: FastAPI, compute_client: AsyncClient, compute_p
assert response.json()["project_id"] == compute_project.id assert response.json()["project_id"] == compute_project.id
async def test_get_cloud(app: FastAPI, compute_client: AsyncClient, compute_project: Project, vm: dict) -> None: async def test_get_cloud(
self, app: FastAPI,
compute_client: AsyncClient,
compute_project: Project,
vm: dict
) -> None:
response = await compute_client.get(app.url_path_for("compute:get_cloud", project_id=vm["project_id"], node_id=vm["node_id"])) response = await compute_client.get(app.url_path_for("compute:get_cloud", project_id=vm["project_id"], node_id=vm["node_id"]))
assert response.status_code == status.HTTP_200_OK assert response.status_code == status.HTTP_200_OK
@ -57,7 +68,12 @@ async def test_get_cloud(app: FastAPI, compute_client: AsyncClient, compute_proj
assert response.json()["status"] == "started" assert response.json()["status"] == "started"
async def test_cloud_nio_create_udp(app: FastAPI, compute_client: AsyncClient, compute_project: Project, vm: dict) -> None: async def test_cloud_nio_create_udp(
self, app: FastAPI,
compute_client: AsyncClient,
compute_project: Project,
vm: dict
) -> None:
params = {"type": "nio_udp", params = {"type": "nio_udp",
"lport": 4242, "lport": 4242,
@ -74,7 +90,12 @@ async def test_cloud_nio_create_udp(app: FastAPI, compute_client: AsyncClient, c
assert response.json()["type"] == "nio_udp" assert response.json()["type"] == "nio_udp"
async def test_cloud_nio_update_udp(app: FastAPI, compute_client: AsyncClient, compute_project: Project, vm: dict) -> None: async def test_cloud_nio_update_udp(
self, app: FastAPI,
compute_client: AsyncClient,
compute_project: Project,
vm: dict
) -> None:
params = {"type": "nio_udp", params = {"type": "nio_udp",
"lport": 4242, "lport": 4242,
@ -99,7 +120,12 @@ async def test_cloud_nio_update_udp(app: FastAPI, compute_client: AsyncClient, c
assert response.json()["type"] == "nio_udp" assert response.json()["type"] == "nio_udp"
async def test_cloud_delete_nio(app: FastAPI, compute_client: AsyncClient, compute_project: Project, vm: dict) -> None: async def test_cloud_delete_nio(
self, app: FastAPI,
compute_client: AsyncClient,
compute_project: Project,
vm: dict
) -> None:
params = {"type": "nio_udp", params = {"type": "nio_udp",
"lport": 4242, "lport": 4242,
@ -123,13 +149,22 @@ async def test_cloud_delete_nio(app: FastAPI, compute_client: AsyncClient, compu
assert response.status_code == status.HTTP_204_NO_CONTENT assert response.status_code == status.HTTP_204_NO_CONTENT
async def test_cloud_delete(app: FastAPI, compute_client: AsyncClient, compute_project: Project, vm: dict) -> None: async def test_cloud_delete(
self, app: FastAPI,
compute_client: AsyncClient,
compute_project: Project,
vm: dict
) -> None:
response = await compute_client.delete(app.url_path_for("compute:delete_cloud", project_id=vm["project_id"], node_id=vm["node_id"])) response = await compute_client.delete(app.url_path_for("compute:delete_cloud", project_id=vm["project_id"], node_id=vm["node_id"]))
assert response.status_code == status.HTTP_204_NO_CONTENT assert response.status_code == status.HTTP_204_NO_CONTENT
async def test_cloud_update(app: FastAPI, compute_client: AsyncClient, vm: dict) -> None: async def test_cloud_update(
self, app: FastAPI,
compute_client: AsyncClient,
vm: dict
) -> None:
response = await compute_client.put(app.url_path_for("compute:update_cloud", project_id=vm["project_id"], node_id=vm["node_id"]), response = await compute_client.put(app.url_path_for("compute:update_cloud", project_id=vm["project_id"], node_id=vm["node_id"]),
json={"name": "test"}) json={"name": "test"})
@ -137,7 +172,11 @@ async def test_cloud_update(app: FastAPI, compute_client: AsyncClient, vm: dict)
assert response.json()["name"] == "test" assert response.json()["name"] == "test"
async def test_cloud_start_capture(app: FastAPI, compute_client: AsyncClient, vm: dict) -> None: async def test_cloud_start_capture(
self, app: FastAPI,
compute_client: AsyncClient,
vm: dict
) -> None:
params = { params = {
"capture_file_name": "test.pcap", "capture_file_name": "test.pcap",
@ -156,7 +195,7 @@ async def test_cloud_start_capture(app: FastAPI, compute_client: AsyncClient, vm
assert "test.pcap" in response.json()["pcap_file_path"] assert "test.pcap" in response.json()["pcap_file_path"]
async def test_cloud_stop_capture(app: FastAPI, compute_client: AsyncClient, vm: dict) -> None: async def test_cloud_stop_capture(self, app: FastAPI, compute_client: AsyncClient, vm: dict) -> None:
with asyncio_patch("gns3server.compute.builtin.nodes.cloud.Cloud.stop_capture") as mock: with asyncio_patch("gns3server.compute.builtin.nodes.cloud.Cloud.stop_capture") as mock:
response = await compute_client.post(app.url_path_for("compute:stop_cloud_capture", response = await compute_client.post(app.url_path_for("compute:stop_cloud_capture",
@ -169,7 +208,7 @@ async def test_cloud_stop_capture(app: FastAPI, compute_client: AsyncClient, vm:
# @pytest.mark.asyncio # @pytest.mark.asyncio
# async def test_cloud_pcap(compute_api, vm, compute_project): # async def test_cloud_pcap(self, compute_api, vm, compute_project):
# #
# from itertools import repeat # from itertools import repeat
# stream = repeat(42, times=10) # stream = repeat(42, times=10)

17
tests/api/routes/compute/test_compute.py
View File

@ -26,28 +26,35 @@ from gns3server.compute.project import Project
pytestmark = pytest.mark.asyncio pytestmark = pytest.mark.asyncio
async def test_udp_allocation(app: FastAPI, compute_client: AsyncClient, compute_project: Project) -> None: class TestComputeRoutes:
async def test_udp_allocation(
self,
app: FastAPI,
compute_client: AsyncClient,
compute_project: Project
) -> None:
response = await compute_client.post(app.url_path_for("compute:allocate_udp_port", project_id=compute_project.id), json={}) response = await compute_client.post(app.url_path_for("compute:allocate_udp_port", project_id=compute_project.id), json={})
assert response.status_code == status.HTTP_201_CREATED assert response.status_code == status.HTTP_201_CREATED
assert response.json()['udp_port'] is not None assert response.json()['udp_port'] is not None
async def test_interfaces(app: FastAPI, compute_client: AsyncClient) -> None: async def test_interfaces(self, app: FastAPI, compute_client: AsyncClient) -> None:
response = await compute_client.get(app.url_path_for("compute:network_interfaces")) response = await compute_client.get(app.url_path_for("compute:network_interfaces"))
assert response.status_code == status.HTTP_200_OK assert response.status_code == status.HTTP_200_OK
assert isinstance(response.json(), list) assert isinstance(response.json(), list)
async def test_version_output(app: FastAPI, compute_client: AsyncClient) -> None: async def test_version_output(self, app: FastAPI, compute_client: AsyncClient) -> None:
response = await compute_client.get(app.url_path_for("compute:compute_version")) response = await compute_client.get(app.url_path_for("compute:compute_version"))
assert response.status_code == status.HTTP_200_OK assert response.status_code == status.HTTP_200_OK
assert response.json() == {'version': __version__} assert response.json() == {'version': __version__}
async def test_compute_authentication(app: FastAPI, compute_client: AsyncClient) -> None: async def test_compute_authentication(self, app: FastAPI, compute_client: AsyncClient) -> None:
response = await compute_client.get(app.url_path_for("compute:compute_version"), auth=("admin", "invalid_password")) response = await compute_client.get(app.url_path_for("compute:compute_version"), auth=("admin", "invalid_password"))
assert response.status_code == status.HTTP_401_UNAUTHORIZED assert response.status_code == status.HTTP_401_UNAUTHORIZED
@ -60,7 +67,7 @@ async def test_compute_authentication(app: FastAPI, compute_client: AsyncClient)
# assert response.status_code == 200 # assert response.status_code == 200
async def test_statistics_output(app: FastAPI, compute_client: AsyncClient) -> None: async def test_statistics_output(self, app: FastAPI, compute_client: AsyncClient) -> None:
response = await compute_client.get(app.url_path_for("compute:compute_statistics")) response = await compute_client.get(app.url_path_for("compute:compute_statistics"))
assert response.status_code == status.HTTP_200_OK assert response.status_code == status.HTTP_200_OK

48
tests/api/routes/compute/test_docker_nodes.py
View File

@ -25,11 +25,13 @@ from unittest.mock import patch
from gns3server.compute.project import Project from gns3server.compute.project import Project
pytestmark = [pytest.mark.asyncio] pytestmark = pytest.mark.asyncio
class TestDockerNodesRoutes:
@pytest.fixture @pytest.fixture
def base_params() -> dict: def base_params(self) -> dict:
"""Return standard parameters""" """Return standard parameters"""
params = { params = {
@ -56,7 +58,13 @@ def base_params() -> dict:
@pytest_asyncio.fixture @pytest_asyncio.fixture
async def vm(app: FastAPI, compute_client: AsyncClient, compute_project: Project, base_params: dict) -> dict: async def vm(
self,
app: FastAPI,
compute_client: AsyncClient,
compute_project: Project,
base_params: dict
) -> dict:
with asyncio_patch("gns3server.compute.docker.Docker.list_images", return_value=[{"image": "nginx"}]): with asyncio_patch("gns3server.compute.docker.Docker.list_images", return_value=[{"image": "nginx"}]):
with asyncio_patch("gns3server.compute.docker.Docker.query", return_value={"Id": "8bd8153ea8f5"}): with asyncio_patch("gns3server.compute.docker.Docker.query", return_value={"Id": "8bd8153ea8f5"}):
@ -67,7 +75,12 @@ async def vm(app: FastAPI, compute_client: AsyncClient, compute_project: Project
return response.json() return response.json()
async def test_docker_create(app: FastAPI, compute_client: AsyncClient, compute_project: Project, base_params: dict) -> None: async def test_docker_create(
self, app: FastAPI,
compute_client: AsyncClient,
compute_project: Project,
base_params: dict
) -> None:
with asyncio_patch("gns3server.compute.docker.Docker.list_images", return_value=[{"image": "nginx"}]): with asyncio_patch("gns3server.compute.docker.Docker.list_images", return_value=[{"image": "nginx"}]):
with asyncio_patch("gns3server.compute.docker.Docker.query", return_value={"Id": "8bd8153ea8f5"}): with asyncio_patch("gns3server.compute.docker.Docker.query", return_value={"Id": "8bd8153ea8f5"}):
@ -102,6 +115,7 @@ async def test_docker_create(app: FastAPI, compute_client: AsyncClient, compute_
), ),
) )
async def test_docker_create_with_invalid_name( async def test_docker_create_with_invalid_name(
self,
app: FastAPI, app: FastAPI,
compute_client: AsyncClient, compute_client: AsyncClient,
compute_project: Project, compute_project: Project,
@ -119,7 +133,7 @@ async def test_docker_create_with_invalid_name(
assert response.status_code == status_code assert response.status_code == status_code
async def test_docker_start(app: FastAPI, compute_client: AsyncClient, vm: dict) -> None: async def test_docker_start(self, app: FastAPI, compute_client: AsyncClient, vm: dict) -> None:
with asyncio_patch("gns3server.compute.docker.docker_vm.DockerVM.start", return_value=True) as mock: with asyncio_patch("gns3server.compute.docker.docker_vm.DockerVM.start", return_value=True) as mock:
@ -130,7 +144,7 @@ async def test_docker_start(app: FastAPI, compute_client: AsyncClient, vm: dict)
assert response.status_code == status.HTTP_204_NO_CONTENT assert response.status_code == status.HTTP_204_NO_CONTENT
async def test_docker_stop(app: FastAPI, compute_client: AsyncClient, vm: dict) -> None: async def test_docker_stop(self, app: FastAPI, compute_client: AsyncClient, vm: dict) -> None:
with asyncio_patch("gns3server.compute.docker.docker_vm.DockerVM.stop", return_value=True) as mock: with asyncio_patch("gns3server.compute.docker.docker_vm.DockerVM.stop", return_value=True) as mock:
response = await compute_client.post(app.url_path_for("compute:stop_docker_node", response = await compute_client.post(app.url_path_for("compute:stop_docker_node",
@ -140,7 +154,7 @@ async def test_docker_stop(app: FastAPI, compute_client: AsyncClient, vm: dict)
assert response.status_code == status.HTTP_204_NO_CONTENT assert response.status_code == status.HTTP_204_NO_CONTENT
async def test_docker_reload(app: FastAPI, compute_client: AsyncClient, vm: dict) -> None: async def test_docker_reload(self, app: FastAPI, compute_client: AsyncClient, vm: dict) -> None:
with asyncio_patch("gns3server.compute.docker.docker_vm.DockerVM.restart", return_value=True) as mock: with asyncio_patch("gns3server.compute.docker.docker_vm.DockerVM.restart", return_value=True) as mock:
response = await compute_client.post(app.url_path_for("compute:reload_docker_node", response = await compute_client.post(app.url_path_for("compute:reload_docker_node",
@ -150,7 +164,7 @@ async def test_docker_reload(app: FastAPI, compute_client: AsyncClient, vm: dict
assert response.status_code == status.HTTP_204_NO_CONTENT assert response.status_code == status.HTTP_204_NO_CONTENT
async def test_docker_delete(app: FastAPI, compute_client: AsyncClient, vm: dict) -> None: async def test_docker_delete(self, app: FastAPI, compute_client: AsyncClient, vm: dict) -> None:
with asyncio_patch("gns3server.compute.docker.docker_vm.DockerVM.delete", return_value=True) as mock: with asyncio_patch("gns3server.compute.docker.docker_vm.DockerVM.delete", return_value=True) as mock:
response = await compute_client.delete(app.url_path_for("compute:delete_docker_node", response = await compute_client.delete(app.url_path_for("compute:delete_docker_node",
@ -160,7 +174,7 @@ async def test_docker_delete(app: FastAPI, compute_client: AsyncClient, vm: dict
assert response.status_code == status.HTTP_204_NO_CONTENT assert response.status_code == status.HTTP_204_NO_CONTENT
async def test_docker_pause(app: FastAPI, compute_client: AsyncClient, vm: dict) -> None: async def test_docker_pause(self, app: FastAPI, compute_client: AsyncClient, vm: dict) -> None:
with asyncio_patch("gns3server.compute.docker.docker_vm.DockerVM.pause", return_value=True) as mock: with asyncio_patch("gns3server.compute.docker.docker_vm.DockerVM.pause", return_value=True) as mock:
response = await compute_client.post(app.url_path_for("compute:pause_docker_node", response = await compute_client.post(app.url_path_for("compute:pause_docker_node",
@ -170,7 +184,7 @@ async def test_docker_pause(app: FastAPI, compute_client: AsyncClient, vm: dict)
assert response.status_code == status.HTTP_204_NO_CONTENT assert response.status_code == status.HTTP_204_NO_CONTENT
async def test_docker_unpause(app: FastAPI, compute_client: AsyncClient, vm: dict) -> None: async def test_docker_unpause(self, app: FastAPI, compute_client: AsyncClient, vm: dict) -> None:
with asyncio_patch("gns3server.compute.docker.docker_vm.DockerVM.unpause", return_value=True) as mock: with asyncio_patch("gns3server.compute.docker.docker_vm.DockerVM.unpause", return_value=True) as mock:
response = await compute_client.post(app.url_path_for("compute:unpause_docker_node", response = await compute_client.post(app.url_path_for("compute:unpause_docker_node",
@ -180,7 +194,7 @@ async def test_docker_unpause(app: FastAPI, compute_client: AsyncClient, vm: dic
assert response.status_code == status.HTTP_204_NO_CONTENT assert response.status_code == status.HTTP_204_NO_CONTENT
async def test_docker_nio_create_udp(app: FastAPI, compute_client: AsyncClient, vm: dict) -> None: async def test_docker_nio_create_udp(self, app: FastAPI, compute_client: AsyncClient, vm: dict) -> None:
params = { params = {
"type": "nio_udp", "type": "nio_udp",
@ -198,7 +212,7 @@ async def test_docker_nio_create_udp(app: FastAPI, compute_client: AsyncClient,
assert response.json()["type"] == "nio_udp" assert response.json()["type"] == "nio_udp"
async def test_docker_update_nio(app: FastAPI, compute_client: AsyncClient, vm: dict) -> None: async def test_docker_update_nio(self, app: FastAPI, compute_client: AsyncClient, vm: dict) -> None:
params = { params = {
"type": "nio_udp", "type": "nio_udp",
@ -225,7 +239,7 @@ async def test_docker_update_nio(app: FastAPI, compute_client: AsyncClient, vm:
assert response.status_code == status.HTTP_201_CREATED assert response.status_code == status.HTTP_201_CREATED
async def test_docker_delete_nio(app: FastAPI, compute_client: AsyncClient, vm: dict) -> None: async def test_docker_delete_nio(self, app: FastAPI, compute_client: AsyncClient, vm: dict) -> None:
url = app.url_path_for("compute:delete_docker_node_nio", url = app.url_path_for("compute:delete_docker_node_nio",
project_id=vm["project_id"], project_id=vm["project_id"],
@ -237,7 +251,7 @@ async def test_docker_delete_nio(app: FastAPI, compute_client: AsyncClient, vm:
assert response.status_code == status.HTTP_204_NO_CONTENT assert response.status_code == status.HTTP_204_NO_CONTENT
async def test_docker_update(app: FastAPI, compute_client: AsyncClient, vm: dict, free_console_port: int) -> None: async def test_docker_update(self, app: FastAPI, compute_client: AsyncClient, vm: dict, free_console_port: int) -> None:
params = { params = {
"name": "test", "name": "test",
@ -261,7 +275,7 @@ async def test_docker_update(app: FastAPI, compute_client: AsyncClient, vm: dict
assert response.json()["extra_hosts"] == "test:127.0.0.1" assert response.json()["extra_hosts"] == "test:127.0.0.1"
async def test_docker_start_capture(app: FastAPI, compute_client: AsyncClient, vm: dict) -> None: async def test_docker_start_capture(self, app: FastAPI, compute_client: AsyncClient, vm: dict) -> None:
url = app.url_path_for("compute:start_docker_node_capture", url = app.url_path_for("compute:start_docker_node_capture",
project_id=vm["project_id"], project_id=vm["project_id"],
@ -278,7 +292,7 @@ async def test_docker_start_capture(app: FastAPI, compute_client: AsyncClient, v
assert "test.pcap" in response.json()["pcap_file_path"] assert "test.pcap" in response.json()["pcap_file_path"]
async def test_docker_stop_capture(app: FastAPI, compute_client: AsyncClient, vm: dict) -> None: async def test_docker_stop_capture(self, app: FastAPI, compute_client: AsyncClient, vm: dict) -> None:
url = app.url_path_for("compute:stop_docker_node_capture", url = app.url_path_for("compute:stop_docker_node_capture",
project_id=vm["project_id"], project_id=vm["project_id"],
@ -293,7 +307,7 @@ async def test_docker_stop_capture(app: FastAPI, compute_client: AsyncClient, vm
assert mock.called assert mock.called
async def test_docker_duplicate(app: FastAPI, compute_client: AsyncClient, vm: dict, base_params: dict) -> None: async def test_docker_duplicate(self, app: FastAPI, compute_client: AsyncClient, vm: dict, base_params: dict) -> None:
# create destination node first # create destination node first
with asyncio_patch("gns3server.compute.docker.Docker.list_images", return_value=[{"image": "nginx"}]): with asyncio_patch("gns3server.compute.docker.Docker.list_images", return_value=[{"image": "nginx"}]):

28
tests/api/routes/compute/test_dynamips_nodes.py
View File

@ -26,6 +26,9 @@ from httpx import AsyncClient
pytestmark = pytest.mark.asyncio pytestmark = pytest.mark.asyncio
class TestDynamipsNodesRoutes:
# @pytest.yield_fixture(scope="module") # @pytest.yield_fixture(scope="module")
# async def vm(compute_api, compute_project, fake_image): # async def vm(compute_api, compute_project, fake_image):
# #
@ -141,7 +144,7 @@ pytestmark = pytest.mark.asyncio
@pytest.fixture @pytest.fixture
def fake_image(tmpdir) -> str: def fake_image(self, tmpdir) -> str:
"""Create a fake Dynamips image on disk""" """Create a fake Dynamips image on disk"""
path = str(tmpdir / "7200.bin") path = str(tmpdir / "7200.bin")
@ -152,7 +155,7 @@ def fake_image(tmpdir) -> str:
@pytest.fixture @pytest.fixture
def fake_file(tmpdir) -> str: def fake_file(self, tmpdir) -> str:
"""Create a fake file disk""" """Create a fake file disk"""
path = str(tmpdir / "7200.txt") path = str(tmpdir / "7200.txt")
@ -162,7 +165,12 @@ def fake_file(tmpdir) -> str:
return path return path
async def test_images(app: FastAPI, compute_client: AsyncClient, tmpdir, fake_image: str, fake_file: str) -> None: async def test_images(
self, app: FastAPI,
compute_client: AsyncClient,
tmpdir, fake_image: str,
fake_file: str
) -> None:
with patch("gns3server.utils.images.default_images_directory", return_value=str(tmpdir)): with patch("gns3server.utils.images.default_images_directory", return_value=str(tmpdir)):
response = await compute_client.get(app.url_path_for("compute:get_dynamips_images")) response = await compute_client.get(app.url_path_for("compute:get_dynamips_images"))
@ -173,7 +181,7 @@ async def test_images(app: FastAPI, compute_client: AsyncClient, tmpdir, fake_im
"md5sum": "b0d5aa897d937aced5a6b1046e8f7e2e"}] "md5sum": "b0d5aa897d937aced5a6b1046e8f7e2e"}]
async def test_upload_image(app: FastAPI, compute_client: AsyncClient, images_dir: str) -> None: async def test_upload_image(self, app: FastAPI, compute_client: AsyncClient, images_dir: str) -> None:
response = await compute_client.post(app.url_path_for("compute:upload_dynamips_image", filename="test2"), content=b"TEST") response = await compute_client.post(app.url_path_for("compute:upload_dynamips_image", filename="test2"), content=b"TEST")
assert response.status_code == status.HTTP_204_NO_CONTENT assert response.status_code == status.HTTP_204_NO_CONTENT
@ -186,14 +194,14 @@ async def test_upload_image(app: FastAPI, compute_client: AsyncClient, images_di
assert checksum == "033bd94b1168d7e4f0d644c3c95e35bf" assert checksum == "033bd94b1168d7e4f0d644c3c95e35bf"
async def test_upload_image_forbidden_location(app: FastAPI, compute_client: AsyncClient) -> None: async def test_upload_image_forbidden_location(self, app: FastAPI, compute_client: AsyncClient) -> None:
file_path = "%2e%2e/hello" file_path = "%2e%2e/hello"
response = await compute_client.post(app.url_path_for("compute:upload_dynamips_image", filename=file_path), content=b"TEST") response = await compute_client.post(app.url_path_for("compute:upload_dynamips_image", filename=file_path), content=b"TEST")
assert response.status_code == status.HTTP_403_FORBIDDEN assert response.status_code == status.HTTP_403_FORBIDDEN
async def test_download_image(app: FastAPI, compute_client: AsyncClient, images_dir: str) -> None: async def test_download_image(self, app: FastAPI, compute_client: AsyncClient, images_dir: str) -> None:
response = await compute_client.post(app.url_path_for("compute:upload_dynamips_image", filename="test3"), content=b"TEST") response = await compute_client.post(app.url_path_for("compute:upload_dynamips_image", filename="test3"), content=b"TEST")
assert response.status_code == status.HTTP_204_NO_CONTENT assert response.status_code == status.HTTP_204_NO_CONTENT
@ -202,7 +210,7 @@ async def test_download_image(app: FastAPI, compute_client: AsyncClient, images_
assert response.status_code == status.HTTP_200_OK assert response.status_code == status.HTTP_200_OK
async def test_download_image_forbidden(app: FastAPI, compute_client: AsyncClient, tmpdir) -> None: async def test_download_image_forbidden(self, app: FastAPI, compute_client: AsyncClient, tmpdir) -> None:
file_path = "foo/%2e%2e/%2e%2e/%2e%2e/%2e%2e/%2e%2e/%2e%2e/etc/passwd" file_path = "foo/%2e%2e/%2e%2e/%2e%2e/%2e%2e/%2e%2e/%2e%2e/etc/passwd"
response = await compute_client.get(app.url_path_for("compute:download_dynamips_image", filename=file_path)) response = await compute_client.get(app.url_path_for("compute:download_dynamips_image", filename=file_path))
@ -210,7 +218,11 @@ async def test_download_image_forbidden(app: FastAPI, compute_client: AsyncClien
@pytest.mark.skipif(os.getuid() == 0, reason="Root can delete any image") @pytest.mark.skipif(os.getuid() == 0, reason="Root can delete any image")
async def test_upload_image_permission_denied(app: FastAPI, compute_client: AsyncClient, images_dir: str) -> None: async def test_upload_image_permission_denied(
self, app: FastAPI,
compute_client: AsyncClient,
images_dir: str
) -> None:
os.makedirs(os.path.join(images_dir, "IOS"), exist_ok=True) os.makedirs(os.path.join(images_dir, "IOS"), exist_ok=True)
with open(os.path.join(images_dir, "IOS", "test2.tmp"), "w+") as f: with open(os.path.join(images_dir, "IOS", "test2.tmp"), "w+") as f:

67
tests/api/routes/compute/test_ethernet_switch_nodes.py
View File

@ -28,8 +28,10 @@ from gns3server.compute.project import Project
pytestmark = pytest.mark.asyncio pytestmark = pytest.mark.asyncio
class TestEthernetSwitchNodesRoutes:
@pytest_asyncio.fixture @pytest_asyncio.fixture
async def ethernet_switch(app: FastAPI, compute_client: AsyncClient, compute_project: Project) -> dict: async def ethernet_switch(self, app: FastAPI, compute_client: AsyncClient, compute_project: Project) -> dict:
params = {"name": "Ethernet Switch"} params = {"name": "Ethernet Switch"}
with asyncio_patch("gns3server.compute.dynamips.nodes.ethernet_switch.EthernetSwitch.create") as mock: with asyncio_patch("gns3server.compute.dynamips.nodes.ethernet_switch.EthernetSwitch.create") as mock:
@ -48,7 +50,11 @@ async def ethernet_switch(app: FastAPI, compute_client: AsyncClient, compute_pro
return json_response return json_response
async def test_ethernet_switch_create(app: FastAPI, compute_client: AsyncClient, compute_project: Project) -> None: async def test_ethernet_switch_create(
self, app: FastAPI,
compute_client: AsyncClient,
compute_project: Project
) -> None:
params = {"name": "Ethernet Switch 1"} params = {"name": "Ethernet Switch 1"}
with asyncio_patch("gns3server.compute.dynamips.nodes.ethernet_switch.EthernetSwitch.create") as mock: with asyncio_patch("gns3server.compute.dynamips.nodes.ethernet_switch.EthernetSwitch.create") as mock:
@ -62,7 +68,12 @@ async def test_ethernet_switch_create(app: FastAPI, compute_client: AsyncClient,
assert response.json()["project_id"] == compute_project.id assert response.json()["project_id"] == compute_project.id
async def test_ethernet_switch_get(app: FastAPI, compute_client: AsyncClient, compute_project: Project, ethernet_switch: dict) -> None: async def test_ethernet_switch_get(
self, app: FastAPI,
compute_client: AsyncClient,
compute_project: Project,
ethernet_switch: dict
) -> None:
response = await compute_client.get( response = await compute_client.get(
app.url_path_for( app.url_path_for(
@ -78,6 +89,7 @@ async def test_ethernet_switch_get(app: FastAPI, compute_client: AsyncClient, co
async def test_ethernet_switch_duplicate( async def test_ethernet_switch_duplicate(
self,
app: FastAPI, app: FastAPI,
compute_client: AsyncClient, compute_client: AsyncClient,
compute_project: Project, compute_project: Project,
@ -107,6 +119,7 @@ async def test_ethernet_switch_duplicate(
async def test_ethernet_switch_update( async def test_ethernet_switch_update(
self,
app: FastAPI, app: FastAPI,
compute_client: AsyncClient, compute_client: AsyncClient,
compute_project: Project, compute_project: Project,
@ -133,6 +146,7 @@ async def test_ethernet_switch_update(
async def test_ethernet_switch_update_ports( async def test_ethernet_switch_update_ports(
self,
app: FastAPI, app: FastAPI,
compute_client: AsyncClient, compute_client: AsyncClient,
compute_project: Project, compute_project: Project,
@ -265,6 +279,7 @@ async def test_ethernet_switch_update_ports(
) )
) )
async def test_ethernet_switch_update_ports_invalid( async def test_ethernet_switch_update_ports_invalid(
self,
app: FastAPI, app: FastAPI,
compute_client: AsyncClient, compute_client: AsyncClient,
ethernet_switch: dict, ethernet_switch: dict,
@ -285,7 +300,11 @@ async def test_ethernet_switch_update_ports_invalid(
assert response.status_code == status.HTTP_422_UNPROCESSABLE_ENTITY assert response.status_code == status.HTTP_422_UNPROCESSABLE_ENTITY
async def test_ethernet_switch_delete(app: FastAPI, compute_client: AsyncClient, ethernet_switch: dict) -> None: async def test_ethernet_switch_delete(
self, app: FastAPI,
compute_client: AsyncClient,
ethernet_switch: dict
) -> None:
response = await compute_client.delete( response = await compute_client.delete(
app.url_path_for( app.url_path_for(
@ -297,7 +316,11 @@ async def test_ethernet_switch_delete(app: FastAPI, compute_client: AsyncClient,
assert response.status_code == status.HTTP_204_NO_CONTENT assert response.status_code == status.HTTP_204_NO_CONTENT
async def test_ethernet_switch_start(app: FastAPI, compute_client: AsyncClient, ethernet_switch: dict) -> None: async def test_ethernet_switch_start(
self, app: FastAPI,
compute_client: AsyncClient,
ethernet_switch: dict
) -> None:
response = await compute_client.post( response = await compute_client.post(
app.url_path_for( app.url_path_for(
@ -308,7 +331,11 @@ async def test_ethernet_switch_start(app: FastAPI, compute_client: AsyncClient,
assert response.status_code == status.HTTP_204_NO_CONTENT assert response.status_code == status.HTTP_204_NO_CONTENT
async def test_ethernet_switch_stop(app: FastAPI, compute_client: AsyncClient, ethernet_switch: dict) -> None: async def test_ethernet_switch_stop(
self, app: FastAPI,
compute_client: AsyncClient,
ethernet_switch: dict
) -> None:
response = await compute_client.post( response = await compute_client.post(
app.url_path_for( app.url_path_for(
@ -319,7 +346,11 @@ async def test_ethernet_switch_stop(app: FastAPI, compute_client: AsyncClient, e
assert response.status_code == status.HTTP_204_NO_CONTENT assert response.status_code == status.HTTP_204_NO_CONTENT
async def test_ethernet_switch_suspend(app: FastAPI, compute_client: AsyncClient, ethernet_switch: dict) -> None: async def test_ethernet_switch_suspend(
self, app: FastAPI,
compute_client: AsyncClient,
ethernet_switch: dict
) -> None:
response = await compute_client.post( response = await compute_client.post(
app.url_path_for( app.url_path_for(
@ -330,7 +361,11 @@ async def test_ethernet_switch_suspend(app: FastAPI, compute_client: AsyncClient
assert response.status_code == status.HTTP_204_NO_CONTENT assert response.status_code == status.HTTP_204_NO_CONTENT
async def test_ethernet_switch_reload(app: FastAPI, compute_client: AsyncClient, ethernet_switch: dict) -> None: async def test_ethernet_switch_reload(
self, app: FastAPI,
compute_client: AsyncClient,
ethernet_switch: dict
) -> None:
response = await compute_client.post( response = await compute_client.post(
app.url_path_for( app.url_path_for(
@ -342,6 +377,7 @@ async def test_ethernet_switch_reload(app: FastAPI, compute_client: AsyncClient,
async def test_ethernet_switch_create_udp( async def test_ethernet_switch_create_udp(
self,
app: FastAPI, app: FastAPI,
compute_client: AsyncClient, compute_client: AsyncClient,
compute_project: Project, compute_project: Project,
@ -377,6 +413,7 @@ async def test_ethernet_switch_create_udp(
async def test_ethernet_switch_delete_nio( async def test_ethernet_switch_delete_nio(
self,
app: FastAPI, app: FastAPI,
compute_client: AsyncClient, compute_client: AsyncClient,
compute_project: Project, compute_project: Project,
@ -420,7 +457,12 @@ async def test_ethernet_switch_delete_nio(
node._hypervisor.send.assert_has_calls(calls) node._hypervisor.send.assert_has_calls(calls)
async def test_ethernet_switch_start_capture(app: FastAPI, compute_client: AsyncClient, ethernet_switch: dict) -> None: async def test_ethernet_switch_start_capture(
self,
app: FastAPI,
compute_client: AsyncClient,
ethernet_switch: dict
) -> None:
params = { params = {
"capture_file_name": "test.pcap", "capture_file_name": "test.pcap",
@ -440,7 +482,12 @@ async def test_ethernet_switch_start_capture(app: FastAPI, compute_client: Async
assert "test.pcap" in response.json()["pcap_file_path"] assert "test.pcap" in response.json()["pcap_file_path"]
async def test_ethernet_switch_stop_capture(app: FastAPI, compute_client: AsyncClient, ethernet_switch: dict) -> None: async def test_ethernet_switch_stop_capture(
self,
app: FastAPI,
compute_client: AsyncClient,
ethernet_switch: dict
) -> None:
url = app.url_path_for("compute:stop_ethernet_switch_capture", url = app.url_path_for("compute:stop_ethernet_switch_capture",
project_id=ethernet_switch["project_id"], project_id=ethernet_switch["project_id"],

116
tests/api/routes/compute/test_iou_nodes.py
View File

@ -28,11 +28,13 @@ from unittest.mock import patch
from gns3server.compute.project import Project from gns3server.compute.project import Project
pytestmark = [pytest.mark.asyncio] pytestmark = pytest.mark.asyncio
class TestIOUNodesRoutes:
@pytest.fixture @pytest.fixture
def fake_iou_bin(images_dir) -> str: def fake_iou_bin(self, images_dir) -> str:
"""Create a fake IOU image on disk""" """Create a fake IOU image on disk"""
path = os.path.join(images_dir, "IOU", "iou.bin") path = os.path.join(images_dir, "IOU", "iou.bin")
@ -43,28 +45,40 @@ def fake_iou_bin(images_dir) -> str:
@pytest.fixture @pytest.fixture
def base_params(tmpdir, fake_iou_bin) -> dict: def base_params(self, tmpdir, fake_iou_bin) -> dict:
"""Return standard parameters""" """Return standard parameters"""
return {"application_id": 42, "name": "IOU-TEST-1", "path": "iou.bin"} return {"application_id": 42, "name": "IOU-TEST-1", "path": "iou.bin"}
@pytest_asyncio.fixture @pytest_asyncio.fixture
async def vm(app: FastAPI, compute_client: AsyncClient, compute_project: Project, base_params: dict) -> dict: async def vm(
self,
app: FastAPI,
compute_client: AsyncClient,
compute_project: Project,
base_params: dict
) -> dict:
response = await compute_client.post(app.url_path_for("compute:create_iou_node", project_id=compute_project.id), json=base_params) response = await compute_client.post(app.url_path_for("compute:create_iou_node", project_id=compute_project.id), json=base_params)
assert response.status_code == status.HTTP_201_CREATED assert response.status_code == status.HTTP_201_CREATED
return response.json() return response.json()
def startup_config_file(compute_project: Project, vm: dict) -> str: def startup_config_file(self, compute_project: Project, vm: dict) -> str:
directory = os.path.join(compute_project.path, "project-files", "iou", vm["node_id"]) directory = os.path.join(compute_project.path, "project-files", "iou", vm["node_id"])
os.makedirs(directory, exist_ok=True) os.makedirs(directory, exist_ok=True)
return os.path.join(directory, "startup-config.cfg") return os.path.join(directory, "startup-config.cfg")
async def test_iou_create(app: FastAPI, compute_client: AsyncClient, compute_project: Project, base_params: dict) -> None: async def test_iou_create(
self,
app: FastAPI,
compute_client: AsyncClient,
compute_project: Project,
base_params: dict
) -> None:
response = await compute_client.post(app.url_path_for("compute:create_iou_node", project_id=compute_project.id), json=base_params) response = await compute_client.post(app.url_path_for("compute:create_iou_node", project_id=compute_project.id), json=base_params)
assert response.status_code == status.HTTP_201_CREATED assert response.status_code == status.HTTP_201_CREATED
@ -77,10 +91,13 @@ async def test_iou_create(app: FastAPI, compute_client: AsyncClient, compute_pro
assert response.json()["l1_keepalives"] is False assert response.json()["l1_keepalives"] is False
async def test_iou_create_with_params(app: FastAPI, async def test_iou_create_with_params(
self,
app: FastAPI,
compute_client: AsyncClient, compute_client: AsyncClient,
compute_project: Project, compute_project: Project,
base_params: dict) -> None: base_params: dict
) -> None:
params = base_params params = base_params
params["ram"] = 1024 params["ram"] = 1024
@ -102,7 +119,7 @@ async def test_iou_create_with_params(app: FastAPI,
assert response.json()["l1_keepalives"] is True assert response.json()["l1_keepalives"] is True
assert response.json()["use_default_iou_values"] is False assert response.json()["use_default_iou_values"] is False
with open(startup_config_file(compute_project, response.json())) as f: with open(self.startup_config_file(compute_project, response.json())) as f:
assert f.read() == "hostname test" assert f.read() == "hostname test"
@ -119,6 +136,7 @@ async def test_iou_create_with_params(app: FastAPI,
), ),
) )
async def test_iou_create_with_invalid_name( async def test_iou_create_with_invalid_name(
self,
app: FastAPI, app: FastAPI,
compute_client: AsyncClient, compute_client: AsyncClient,
compute_project: Project, compute_project: Project,
@ -135,6 +153,7 @@ async def test_iou_create_with_invalid_name(
async def test_iou_create_startup_config_already_exist( async def test_iou_create_startup_config_already_exist(
self,
app: FastAPI, app: FastAPI,
compute_client: AsyncClient, compute_client: AsyncClient,
compute_project: Project, compute_project: Project,
@ -142,7 +161,7 @@ async def test_iou_create_startup_config_already_exist(
"""We don't erase a startup-config if already exist at project creation""" """We don't erase a startup-config if already exist at project creation"""
node_id = str(uuid.uuid4()) node_id = str(uuid.uuid4())
startup_config_file_path = startup_config_file(compute_project, {'node_id': node_id}) startup_config_file_path = self.startup_config_file(compute_project, {'node_id': node_id})
with open(startup_config_file_path, 'w+') as f: with open(startup_config_file_path, 'w+') as f:
f.write("echo hello") f.write("echo hello")
@ -153,11 +172,17 @@ async def test_iou_create_startup_config_already_exist(
response = await compute_client.post(app.url_path_for("compute:create_iou_node", project_id=compute_project.id), json=params) response = await compute_client.post(app.url_path_for("compute:create_iou_node", project_id=compute_project.id), json=params)
assert response.status_code == status.HTTP_201_CREATED assert response.status_code == status.HTTP_201_CREATED
with open(startup_config_file(compute_project, response.json())) as f: with open(self.startup_config_file(compute_project, response.json())) as f:
assert f.read() == "echo hello" assert f.read() == "echo hello"
async def test_iou_get(app: FastAPI, compute_client: AsyncClient, compute_project: Project, vm: dict) -> None: async def test_iou_get(
self,
app: FastAPI,
compute_client: AsyncClient,
compute_project: Project,
vm: dict
) -> None:
response = await compute_client.get(app.url_path_for("compute:get_iou_node", project_id=vm["project_id"], node_id=vm["node_id"])) response = await compute_client.get(app.url_path_for("compute:get_iou_node", project_id=vm["project_id"], node_id=vm["node_id"]))
assert response.status_code == status.HTTP_200_OK assert response.status_code == status.HTTP_200_OK
@ -170,7 +195,7 @@ async def test_iou_get(app: FastAPI, compute_client: AsyncClient, compute_projec
assert response.json()["l1_keepalives"] is False assert response.json()["l1_keepalives"] is False
async def test_iou_start(app: FastAPI, compute_client: AsyncClient, vm: dict) -> None: async def test_iou_start(self, app: FastAPI, compute_client: AsyncClient, vm: dict) -> None:
with asyncio_patch("gns3server.compute.iou.iou_vm.IOUVM.start", return_value=True) as mock: with asyncio_patch("gns3server.compute.iou.iou_vm.IOUVM.start", return_value=True) as mock:
response = await compute_client.post(app.url_path_for("compute:start_iou_node", response = await compute_client.post(app.url_path_for("compute:start_iou_node",
@ -180,7 +205,7 @@ async def test_iou_start(app: FastAPI, compute_client: AsyncClient, vm: dict) ->
assert response.status_code == status.HTTP_204_NO_CONTENT assert response.status_code == status.HTTP_204_NO_CONTENT
async def test_iou_start_with_iourc(app: FastAPI, compute_client: AsyncClient, vm: dict) -> None: async def test_iou_start_with_iourc(self, app: FastAPI, compute_client: AsyncClient, vm: dict) -> None:
params = {"iourc_content": "test"} params = {"iourc_content": "test"}
with asyncio_patch("gns3server.compute.iou.iou_vm.IOUVM.start", return_value=True) as mock: with asyncio_patch("gns3server.compute.iou.iou_vm.IOUVM.start", return_value=True) as mock:
@ -191,7 +216,7 @@ async def test_iou_start_with_iourc(app: FastAPI, compute_client: AsyncClient, v
assert response.status_code == status.HTTP_204_NO_CONTENT assert response.status_code == status.HTTP_204_NO_CONTENT
async def test_iou_stop(app: FastAPI, compute_client: AsyncClient, vm: dict) -> None: async def test_iou_stop(self, app: FastAPI, compute_client: AsyncClient, vm: dict) -> None:
with asyncio_patch("gns3server.compute.iou.iou_vm.IOUVM.stop", return_value=True) as mock: with asyncio_patch("gns3server.compute.iou.iou_vm.IOUVM.stop", return_value=True) as mock:
response = await compute_client.post(app.url_path_for("compute:stop_iou_node", response = await compute_client.post(app.url_path_for("compute:stop_iou_node",
@ -201,7 +226,7 @@ async def test_iou_stop(app: FastAPI, compute_client: AsyncClient, vm: dict) ->
assert response.status_code == status.HTTP_204_NO_CONTENT assert response.status_code == status.HTTP_204_NO_CONTENT
async def test_iou_reload(app: FastAPI, compute_client: AsyncClient, vm: dict) -> None: async def test_iou_reload(self, app: FastAPI, compute_client: AsyncClient, vm: dict) -> None:
with asyncio_patch("gns3server.compute.iou.iou_vm.IOUVM.reload", return_value=True) as mock: with asyncio_patch("gns3server.compute.iou.iou_vm.IOUVM.reload", return_value=True) as mock:
response = await compute_client.post(app.url_path_for("compute:reload_iou_node", response = await compute_client.post(app.url_path_for("compute:reload_iou_node",
@ -211,7 +236,7 @@ async def test_iou_reload(app: FastAPI, compute_client: AsyncClient, vm: dict) -
assert response.status_code == status.HTTP_204_NO_CONTENT assert response.status_code == status.HTTP_204_NO_CONTENT
async def test_iou_delete(app: FastAPI, compute_client: AsyncClient, vm: dict) -> None: async def test_iou_delete(self, app: FastAPI, compute_client: AsyncClient, vm: dict) -> None:
with asyncio_patch("gns3server.compute.iou.IOU.delete_node", return_value=True) as mock: with asyncio_patch("gns3server.compute.iou.IOU.delete_node", return_value=True) as mock:
response = await compute_client.delete(app.url_path_for("compute:delete_iou_node", response = await compute_client.delete(app.url_path_for("compute:delete_iou_node",
@ -221,7 +246,12 @@ async def test_iou_delete(app: FastAPI, compute_client: AsyncClient, vm: dict) -
assert response.status_code == status.HTTP_204_NO_CONTENT assert response.status_code == status.HTTP_204_NO_CONTENT
async def test_iou_update(app: FastAPI, compute_client: AsyncClient, vm: dict, free_console_port: int) -> None: async def test_iou_update(
self, app: FastAPI,
compute_client: AsyncClient,
vm: dict,
free_console_port: int
) -> None:
params = { params = {
"name": "test", "name": "test",
@ -248,7 +278,7 @@ async def test_iou_update(app: FastAPI, compute_client: AsyncClient, vm: dict, f
assert response.json()["use_default_iou_values"] is True assert response.json()["use_default_iou_values"] is True
async def test_iou_nio_create_udp(app: FastAPI, compute_client: AsyncClient, vm: dict) -> None: async def test_iou_nio_create_udp(self, app: FastAPI, compute_client: AsyncClient, vm: dict) -> None:
params = {"type": "nio_udp", params = {"type": "nio_udp",
"lport": 4242, "lport": 4242,
@ -265,7 +295,7 @@ async def test_iou_nio_create_udp(app: FastAPI, compute_client: AsyncClient, vm:
assert response.json()["type"] == "nio_udp" assert response.json()["type"] == "nio_udp"
async def test_iou_nio_update_udp(app: FastAPI, compute_client: AsyncClient, vm: dict) -> None: async def test_iou_nio_update_udp(self, app: FastAPI, compute_client: AsyncClient, vm: dict) -> None:
params = {"type": "nio_udp", params = {"type": "nio_udp",
"lport": 4242, "lport": 4242,
@ -291,7 +321,13 @@ async def test_iou_nio_update_udp(app: FastAPI, compute_client: AsyncClient, vm:
assert response.json()["type"] == "nio_udp" assert response.json()["type"] == "nio_udp"
async def test_iou_nio_create_ethernet(app: FastAPI, compute_client: AsyncClient, vm: dict, ethernet_device: str) -> None: async def test_iou_nio_create_ethernet(
self,
app: FastAPI,
compute_client: AsyncClient,
vm: dict,
ethernet_device: str
) -> None:
params = { params = {
"type": "nio_ethernet", "type": "nio_ethernet",
@ -310,10 +346,13 @@ async def test_iou_nio_create_ethernet(app: FastAPI, compute_client: AsyncClient
assert response.json()["ethernet_device"] == ethernet_device assert response.json()["ethernet_device"] == ethernet_device
async def test_iou_nio_create_ethernet_different_port(app: FastAPI, async def test_iou_nio_create_ethernet_different_port(
self,
app: FastAPI,
compute_client: AsyncClient, compute_client: AsyncClient,
vm: dict, vm: dict,
ethernet_device: str) -> None: ethernet_device: str
) -> None:
params = { params = {
"type": "nio_ethernet", "type": "nio_ethernet",
@ -331,7 +370,13 @@ async def test_iou_nio_create_ethernet_different_port(app: FastAPI,
assert response.json()["ethernet_device"] == ethernet_device assert response.json()["ethernet_device"] == ethernet_device
async def test_iou_nio_create_tap(app: FastAPI, compute_client: AsyncClient, vm: dict, ethernet_device: str) -> None: async def test_iou_nio_create_tap(
self,
app: FastAPI,
compute_client: AsyncClient,
vm: dict,
ethernet_device: str
) -> None:
params = { params = {
"type": "nio_tap", "type": "nio_tap",
@ -349,7 +394,12 @@ async def test_iou_nio_create_tap(app: FastAPI, compute_client: AsyncClient, vm:
assert response.json()["type"] == "nio_tap" assert response.json()["type"] == "nio_tap"
async def test_iou_delete_nio(app: FastAPI, compute_client: AsyncClient, vm: dict) -> None: async def test_iou_delete_nio(
self,
app: FastAPI,
compute_client: AsyncClient,
vm: dict
) -> None:
params = { params = {
"type": "nio_udp", "type": "nio_udp",
@ -376,7 +426,7 @@ async def test_iou_delete_nio(app: FastAPI, compute_client: AsyncClient, vm: dic
assert response.status_code == status.HTTP_204_NO_CONTENT assert response.status_code == status.HTTP_204_NO_CONTENT
async def test_iou_start_capture(app: FastAPI, compute_client: AsyncClient, vm: dict) -> None: async def test_iou_start_capture(self, app: FastAPI, compute_client: AsyncClient, vm: dict) -> None:
params = { params = {
"capture_file_name": "test.pcap", "capture_file_name": "test.pcap",
@ -397,7 +447,7 @@ async def test_iou_start_capture(app: FastAPI, compute_client: AsyncClient, vm:
assert "test.pcap" in response.json()["pcap_file_path"] assert "test.pcap" in response.json()["pcap_file_path"]
async def test_iou_stop_capture(app: FastAPI, compute_client: AsyncClient, vm: dict) -> None: async def test_iou_stop_capture(self, app: FastAPI, compute_client: AsyncClient, vm: dict) -> None:
url = app.url_path_for("compute:stop_iou_node_capture", url = app.url_path_for("compute:stop_iou_node_capture",
project_id=vm["project_id"], project_id=vm["project_id"],
@ -421,14 +471,14 @@ async def test_iou_stop_capture(app: FastAPI, compute_client: AsyncClient, vm: d
# assert response.status_code == status.HTTP_200_OK # assert response.status_code == status.HTTP_200_OK
async def test_images(app: FastAPI, compute_client: AsyncClient, fake_iou_bin: str) -> None: async def test_images(self, app: FastAPI, compute_client: AsyncClient, fake_iou_bin: str) -> None:
response = await compute_client.get(app.url_path_for("compute:get_iou_images")) response = await compute_client.get(app.url_path_for("compute:get_iou_images"))
assert response.status_code == status.HTTP_200_OK assert response.status_code == status.HTTP_200_OK
assert response.json() == [{"filename": "iou.bin", "path": "iou.bin", "filesize": 7, "md5sum": "e573e8f5c93c6c00783f20c7a170aa6c"}] assert response.json() == [{"filename": "iou.bin", "path": "iou.bin", "filesize": 7, "md5sum": "e573e8f5c93c6c00783f20c7a170aa6c"}]
async def test_upload_image(app: FastAPI, compute_client: AsyncClient, tmpdir) -> None: async def test_upload_image(self, app: FastAPI, compute_client: AsyncClient, tmpdir) -> None:
with patch("gns3server.compute.IOU.get_images_directory", return_value=str(tmpdir)): with patch("gns3server.compute.IOU.get_images_directory", return_value=str(tmpdir)):
response = await compute_client.post(app.url_path_for("compute:upload_iou_image", filename="test2"), content=b"TEST") response = await compute_client.post(app.url_path_for("compute:upload_iou_image", filename="test2"), content=b"TEST")
@ -442,14 +492,14 @@ async def test_upload_image(app: FastAPI, compute_client: AsyncClient, tmpdir) -
assert checksum == "033bd94b1168d7e4f0d644c3c95e35bf" assert checksum == "033bd94b1168d7e4f0d644c3c95e35bf"
async def test_upload_image_forbidden_location(app: FastAPI, compute_client: AsyncClient) -> None: async def test_upload_image_forbidden_location(self, app: FastAPI, compute_client: AsyncClient) -> None:
file_path = "%2e%2e/hello" file_path = "%2e%2e/hello"
response = await compute_client.post(app.url_path_for("compute:upload_dynamips_image", filename=file_path), content=b"TEST") response = await compute_client.post(app.url_path_for("compute:upload_dynamips_image", filename=file_path), content=b"TEST")
assert response.status_code == status.HTTP_403_FORBIDDEN assert response.status_code == status.HTTP_403_FORBIDDEN
async def test_download_image(app: FastAPI, compute_client: AsyncClient, images_dir: str) -> None: async def test_download_image(self, app: FastAPI, compute_client: AsyncClient, images_dir: str) -> None:
response = await compute_client.post(app.url_path_for("compute:upload_dynamips_image", filename="test3"), content=b"TEST") response = await compute_client.post(app.url_path_for("compute:upload_dynamips_image", filename="test3"), content=b"TEST")
assert response.status_code == status.HTTP_204_NO_CONTENT assert response.status_code == status.HTTP_204_NO_CONTENT
@ -458,14 +508,14 @@ async def test_download_image(app: FastAPI, compute_client: AsyncClient, images_
assert response.status_code == status.HTTP_200_OK assert response.status_code == status.HTTP_200_OK
async def test_download_image_forbidden(app: FastAPI, compute_client: AsyncClient, tmpdir) -> None: async def test_download_image_forbidden(self, app: FastAPI, compute_client: AsyncClient, tmpdir) -> None:
file_path = "foo/%2e%2e/%2e%2e/%2e%2e/%2e%2e/%2e%2e/%2e%2e/etc/passwd" file_path = "foo/%2e%2e/%2e%2e/%2e%2e/%2e%2e/%2e%2e/%2e%2e/etc/passwd"
response = await compute_client.get(app.url_path_for("compute:download_iou_image", filename=file_path)) response = await compute_client.get(app.url_path_for("compute:download_iou_image", filename=file_path))
assert response.status_code == status.HTTP_403_FORBIDDEN assert response.status_code == status.HTTP_403_FORBIDDEN
async def test_iou_duplicate(app: FastAPI, compute_client: AsyncClient, vm: dict, base_params: dict) -> None: async def test_iou_duplicate(self, app: FastAPI, compute_client: AsyncClient, vm: dict, base_params: dict) -> None:
# create destination node first # create destination node first
response = await compute_client.post(app.url_path_for("compute:create_iou_node", project_id=vm["project_id"]), json=base_params) response = await compute_client.post(app.url_path_for("compute:create_iou_node", project_id=vm["project_id"]), json=base_params)

45
tests/api/routes/compute/test_nat_nodes.py
View File

@ -27,8 +27,17 @@ from gns3server.compute.project import Project
pytestmark = pytest.mark.asyncio pytestmark = pytest.mark.asyncio
@pytest_asyncio.fixture(scope="function") class TestNATNodesRoutes:
async def vm(app: FastAPI, compute_client: AsyncClient, compute_project: Project, ubridge_path: str, on_gns3vm) -> dict:
@pytest_asyncio.fixture
async def vm(
self,
app: FastAPI,
compute_client: AsyncClient,
compute_project: Project,
ubridge_path: str,
on_gns3vm
) -> dict:
with asyncio_patch("gns3server.compute.builtin.nodes.nat.Nat._start_ubridge"): with asyncio_patch("gns3server.compute.builtin.nodes.nat.Nat._start_ubridge"):
response = await compute_client.post(app.url_path_for("compute:create_nat_node", project_id=compute_project.id), response = await compute_client.post(app.url_path_for("compute:create_nat_node", project_id=compute_project.id),
@ -37,7 +46,13 @@ async def vm(app: FastAPI, compute_client: AsyncClient, compute_project: Project
return response.json() return response.json()
async def test_nat_create(app: FastAPI, compute_client: AsyncClient, compute_project: Project, on_gns3vm) -> None: async def test_nat_create(
self,
app: FastAPI,
compute_client: AsyncClient,
compute_project: Project,
on_gns3vm
) -> None:
with asyncio_patch("gns3server.compute.builtin.nodes.nat.Nat._start_ubridge"): with asyncio_patch("gns3server.compute.builtin.nodes.nat.Nat._start_ubridge"):
response = await compute_client.post(app.url_path_for("compute:create_nat_node", project_id=compute_project.id), response = await compute_client.post(app.url_path_for("compute:create_nat_node", project_id=compute_project.id),
@ -47,7 +62,13 @@ async def test_nat_create(app: FastAPI, compute_client: AsyncClient, compute_pro
assert response.json()["project_id"] == compute_project.id assert response.json()["project_id"] == compute_project.id
async def test_nat_get(app: FastAPI, compute_client: AsyncClient, compute_project: Project, vm: dict) -> None: async def test_nat_get(
self,
app: FastAPI,
compute_client: AsyncClient,
compute_project: Project,
vm: dict
) -> None:
response = await compute_client.get(app.url_path_for("compute:get_nat_node", project_id=vm["project_id"], node_id=vm["node_id"])) response = await compute_client.get(app.url_path_for("compute:get_nat_node", project_id=vm["project_id"], node_id=vm["node_id"]))
assert response.status_code == status.HTTP_200_OK assert response.status_code == status.HTTP_200_OK
@ -56,7 +77,7 @@ async def test_nat_get(app: FastAPI, compute_client: AsyncClient, compute_projec
assert response.json()["status"] == "started" assert response.json()["status"] == "started"
async def test_nat_nio_create_udp(app: FastAPI, compute_client: AsyncClient, vm: dict) -> None: async def test_nat_nio_create_udp(self, app: FastAPI, compute_client: AsyncClient, vm: dict) -> None:
params = { params = {
"type": "nio_udp", "type": "nio_udp",
@ -77,7 +98,7 @@ async def test_nat_nio_create_udp(app: FastAPI, compute_client: AsyncClient, vm:
assert response.json()["type"] == "nio_udp" assert response.json()["type"] == "nio_udp"
async def test_nat_nio_update_udp(app: FastAPI, compute_client: AsyncClient, vm: dict) -> None: async def test_nat_nio_update_udp(self, app: FastAPI, compute_client: AsyncClient, vm: dict) -> None:
params = { params = {
"type": "nio_udp", "type": "nio_udp",
@ -105,7 +126,7 @@ async def test_nat_nio_update_udp(app: FastAPI, compute_client: AsyncClient, vm:
assert response.json()["type"] == "nio_udp" assert response.json()["type"] == "nio_udp"
async def test_nat_delete_nio(app: FastAPI, compute_client: AsyncClient, vm: dict) -> None: async def test_nat_delete_nio(self, app: FastAPI, compute_client: AsyncClient, vm: dict) -> None:
params = { params = {
"type": "nio_udp", "type": "nio_udp",
@ -133,7 +154,7 @@ async def test_nat_delete_nio(app: FastAPI, compute_client: AsyncClient, vm: dic
assert response.status_code == status.HTTP_204_NO_CONTENT assert response.status_code == status.HTTP_204_NO_CONTENT
async def test_nat_delete(app: FastAPI, compute_client: AsyncClient, vm: dict) -> None: async def test_nat_delete(self, app: FastAPI, compute_client: AsyncClient, vm: dict) -> None:
response = await compute_client.delete(app.url_path_for("compute:delete_nat_node", response = await compute_client.delete(app.url_path_for("compute:delete_nat_node",
project_id=vm["project_id"], project_id=vm["project_id"],
@ -142,7 +163,7 @@ async def test_nat_delete(app: FastAPI, compute_client: AsyncClient, vm: dict) -
assert response.status_code == status.HTTP_204_NO_CONTENT assert response.status_code == status.HTTP_204_NO_CONTENT
async def test_nat_update(app: FastAPI, compute_client: AsyncClient, vm: dict) -> None: async def test_nat_update(self, app: FastAPI, compute_client: AsyncClient, vm: dict) -> None:
response = await compute_client.put(app.url_path_for("compute:update_nat_node", response = await compute_client.put(app.url_path_for("compute:update_nat_node",
project_id=vm["project_id"], project_id=vm["project_id"],
@ -151,7 +172,7 @@ async def test_nat_update(app: FastAPI, compute_client: AsyncClient, vm: dict) -
assert response.json()["name"] == "test" assert response.json()["name"] == "test"
async def test_nat_start_capture(app: FastAPI, compute_client: AsyncClient, vm: dict) -> None: async def test_nat_start_capture(self, app: FastAPI, compute_client: AsyncClient, vm: dict) -> None:
params = { params = {
"capture_file_name": "test.pcap", "capture_file_name": "test.pcap",
@ -170,7 +191,7 @@ async def test_nat_start_capture(app: FastAPI, compute_client: AsyncClient, vm:
assert "test.pcap" in response.json()["pcap_file_path"] assert "test.pcap" in response.json()["pcap_file_path"]
async def test_nat_stop_capture(app: FastAPI, compute_client: AsyncClient, vm: dict) -> None: async def test_nat_stop_capture(self, app: FastAPI, compute_client: AsyncClient, vm: dict) -> None:
url = app.url_path_for("compute:stop_nat_node_capture", url = app.url_path_for("compute:stop_nat_node_capture",
project_id=vm["project_id"], project_id=vm["project_id"],
@ -185,7 +206,7 @@ async def test_nat_stop_capture(app: FastAPI, compute_client: AsyncClient, vm: d
# @pytest.mark.asyncio # @pytest.mark.asyncio
# async def test_nat_pcap(compute_api, vm, compute_project): # async def test_nat_pcap(self, compute_api, vm, compute_project):
# #
# with asyncio_patch("gns3server.compute.builtin.nodes.nat.Nat.get_nio"): # with asyncio_patch("gns3server.compute.builtin.nodes.nat.Nat.get_nio"):
# with asyncio_patch("gns3server.compute.builtin.Builtin.stream_pcap_file"): # with asyncio_patch("gns3server.compute.builtin.Builtin.stream_pcap_file"):

52
tests/api/routes/compute/test_projects.py
View File

@ -30,8 +30,10 @@ from gns3server.compute.project import Project
pytestmark = pytest.mark.asyncio pytestmark = pytest.mark.asyncio
class TestComputeProjectRoutes:
@pytest.fixture @pytest.fixture
def base_params(tmpdir) -> dict: def base_params(self, tmpdir) -> dict:
"""Return standard parameters""" """Return standard parameters"""
params = { params = {
@ -41,7 +43,12 @@ def base_params(tmpdir) -> dict:
return params return params
async def test_create_project_without_dir(app: FastAPI, compute_client: AsyncClient, base_params: dict) -> None: async def test_create_project_without_dir(
self,
app: FastAPI,
compute_client: AsyncClient,
base_params: dict
) -> None:
response = await compute_client.post(app.url_path_for("compute:create_compute_project"), json=base_params) response = await compute_client.post(app.url_path_for("compute:create_compute_project"), json=base_params)
assert response.status_code == status.HTTP_201_CREATED assert response.status_code == status.HTTP_201_CREATED
@ -49,7 +56,12 @@ async def test_create_project_without_dir(app: FastAPI, compute_client: AsyncCli
assert response.json()["name"] == base_params["name"] assert response.json()["name"] == base_params["name"]
async def test_show_project(app: FastAPI, compute_client: AsyncClient, base_params: dict) -> None: async def test_show_project(
self,
app: FastAPI,
compute_client: AsyncClient,
base_params: dict
) -> None:
response = await compute_client.post(app.url_path_for("compute:create_compute_project"), json=base_params) response = await compute_client.post(app.url_path_for("compute:create_compute_project"), json=base_params)
assert response.status_code == status.HTTP_201_CREATED assert response.status_code == status.HTTP_201_CREATED
@ -62,14 +74,14 @@ async def test_show_project(app: FastAPI, compute_client: AsyncClient, base_para
assert response.json()["variables"] is None assert response.json()["variables"] is None
async def test_show_project_invalid_uuid(app: FastAPI, compute_client: AsyncClient) -> None: async def test_show_project_invalid_uuid(self, app: FastAPI, compute_client: AsyncClient) -> None:
response = await compute_client.get(app.url_path_for("compute:get_compute_project", response = await compute_client.get(app.url_path_for("compute:get_compute_project",
project_id="50010203-0405-0607-0809-0a0b0c0d0e42")) project_id="50010203-0405-0607-0809-0a0b0c0d0e42"))
assert response.status_code == status.HTTP_404_NOT_FOUND assert response.status_code == status.HTTP_404_NOT_FOUND
async def test_list_projects(app: FastAPI, compute_client: AsyncClient) -> dict: async def test_list_projects(self, app: FastAPI, compute_client: AsyncClient) -> dict:
ProjectManager.instance()._projects = {} ProjectManager.instance()._projects = {}
@ -86,7 +98,7 @@ async def test_list_projects(app: FastAPI, compute_client: AsyncClient) -> dict:
assert "51010203-0405-0607-0809-0a0b0c0d0e0f" in [p["project_id"] for p in response.json()] assert "51010203-0405-0607-0809-0a0b0c0d0e0f" in [p["project_id"] for p in response.json()]
async def test_delete_project(app: FastAPI, compute_client: AsyncClient, compute_project: Project) -> None: async def test_delete_project(self, app: FastAPI, compute_client: AsyncClient, compute_project: Project) -> None:
with asyncio_patch("gns3server.compute.project.Project.delete", return_value=True) as mock: with asyncio_patch("gns3server.compute.project.Project.delete", return_value=True) as mock:
response = await compute_client.delete(app.url_path_for("compute:delete_compute_project", project_id=compute_project.id)) response = await compute_client.delete(app.url_path_for("compute:delete_compute_project", project_id=compute_project.id))
@ -94,7 +106,7 @@ async def test_delete_project(app: FastAPI, compute_client: AsyncClient, compute
assert mock.called assert mock.called
async def test_update_project(app: FastAPI, compute_client: AsyncClient, base_params: dict) -> None: async def test_update_project(self, app: FastAPI, compute_client: AsyncClient, base_params: dict) -> None:
response = await compute_client.post(app.url_path_for("compute:create_compute_project"), json=base_params) response = await compute_client.post(app.url_path_for("compute:create_compute_project"), json=base_params)
assert response.status_code == status.HTTP_201_CREATED assert response.status_code == status.HTTP_201_CREATED
@ -106,13 +118,13 @@ async def test_update_project(app: FastAPI, compute_client: AsyncClient, base_pa
assert response.json()["variables"] == [{"name": "TEST1", "value": "VAL1"}] assert response.json()["variables"] == [{"name": "TEST1", "value": "VAL1"}]
async def test_delete_project_invalid_uuid(app: FastAPI, compute_client: AsyncClient) -> None: async def test_delete_project_invalid_uuid(self, app: FastAPI, compute_client: AsyncClient) -> None:
response = await compute_client.delete(app.url_path_for("compute:delete_compute_project", project_id=str(uuid.uuid4()))) response = await compute_client.delete(app.url_path_for("compute:delete_compute_project", project_id=str(uuid.uuid4())))
assert response.status_code == status.HTTP_404_NOT_FOUND assert response.status_code == status.HTTP_404_NOT_FOUND
async def test_close_project(app: FastAPI, compute_client: AsyncClient, compute_project: Project) -> None: async def test_close_project(self, app: FastAPI, compute_client: AsyncClient, compute_project: Project) -> None:
with asyncio_patch("gns3server.compute.project.Project.close", return_value=True) as mock: with asyncio_patch("gns3server.compute.project.Project.close", return_value=True) as mock:
response = await compute_client.post(app.url_path_for("compute:close_compute_project", project_id=compute_project.id)) response = await compute_client.post(app.url_path_for("compute:close_compute_project", project_id=compute_project.id))
@ -130,13 +142,13 @@ async def test_close_project(app: FastAPI, compute_client: AsyncClient, compute_
# assert not mock.called # assert not mock.called
async def test_close_project_invalid_uuid(app: FastAPI, compute_client: AsyncClient) -> None: async def test_close_project_invalid_uuid(self, app: FastAPI, compute_client: AsyncClient) -> None:
response = await compute_client.post(app.url_path_for("compute:close_compute_project", project_id=str(uuid.uuid4()))) response = await compute_client.post(app.url_path_for("compute:close_compute_project", project_id=str(uuid.uuid4())))
assert response.status_code == status.HTTP_404_NOT_FOUND assert response.status_code == status.HTTP_404_NOT_FOUND
async def test_get_file(app: FastAPI, compute_client: AsyncClient) -> None: async def test_get_file(self, app: FastAPI, compute_client: AsyncClient) -> None:
project = ProjectManager.instance().create_project(project_id="01010203-0405-0607-0809-0a0b0c0d0e0b") project = ProjectManager.instance().create_project(project_id="01010203-0405-0607-0809-0a0b0c0d0e0b")
@ -156,7 +168,13 @@ async def test_get_file(app: FastAPI, compute_client: AsyncClient) -> None:
assert response.status_code == status.HTTP_404_NOT_FOUND assert response.status_code == status.HTTP_404_NOT_FOUND
async def test_get_file_forbidden_location(app: FastAPI, compute_client: AsyncClient, config, tmpdir) -> None: async def test_get_file_forbidden_location(
self,
app: FastAPI,
compute_client: AsyncClient,
config,
tmpdir
) -> None:
config.settings.Server.projects_path = str(tmpdir) config.settings.Server.projects_path = str(tmpdir)
project = ProjectManager.instance().create_project(project_id="01010203-0405-0607-0809-0a0b0c0d0e0b") project = ProjectManager.instance().create_project(project_id="01010203-0405-0607-0809-0a0b0c0d0e0b")
@ -171,7 +189,7 @@ async def test_get_file_forbidden_location(app: FastAPI, compute_client: AsyncCl
assert response.status_code == status.HTTP_403_FORBIDDEN assert response.status_code == status.HTTP_403_FORBIDDEN
async def test_write_file(app: FastAPI, compute_client: AsyncClient, config, tmpdir) -> None: async def test_write_file(self, app: FastAPI, compute_client: AsyncClient, config, tmpdir) -> None:
config.settings.Server.projects_path = str(tmpdir) config.settings.Server.projects_path = str(tmpdir)
project = ProjectManager.instance().create_project(project_id="01010203-0405-0607-0809-0a0b0c0d0e0b") project = ProjectManager.instance().create_project(project_id="01010203-0405-0607-0809-0a0b0c0d0e0b")
@ -190,7 +208,13 @@ async def test_write_file(app: FastAPI, compute_client: AsyncClient, config, tmp
assert response.status_code == status.HTTP_404_NOT_FOUND assert response.status_code == status.HTTP_404_NOT_FOUND
async def test_write_file_forbidden_location(app: FastAPI, compute_client: AsyncClient, config, tmpdir) -> None: async def test_write_file_forbidden_location(
self,
app: FastAPI,
compute_client: AsyncClient,
config,
tmpdir
) -> None:
config.settings.Server.projects_path = str(tmpdir) config.settings.Server.projects_path = str(tmpdir)
project = ProjectManager.instance().create_project(project_id="01010203-0405-0607-0809-0a0b0c0d0e0b") project = ProjectManager.instance().create_project(project_id="01010203-0405-0607-0809-0a0b0c0d0e0b")

119
tests/api/routes/compute/test_qemu_nodes.py
View File

@ -31,8 +31,10 @@ from gns3server.compute.project import Project
pytestmark = pytest.mark.asyncio pytestmark = pytest.mark.asyncio
class TestQemuNodesRoutes:
@pytest.fixture @pytest.fixture
def fake_qemu_bin(monkeypatch, tmpdir) -> str: def fake_qemu_bin(self, monkeypatch, tmpdir) -> str:
monkeypatch.setenv("PATH", str(tmpdir)) monkeypatch.setenv("PATH", str(tmpdir))
bin_path = os.path.join(os.environ["PATH"], "qemu-system-x86_64") bin_path = os.path.join(os.environ["PATH"], "qemu-system-x86_64")
@ -43,7 +45,7 @@ def fake_qemu_bin(monkeypatch, tmpdir) -> str:
@pytest.fixture @pytest.fixture
def fake_qemu_vm(images_dir) -> str: def fake_qemu_vm(self, images_dir) -> str:
img_dir = os.path.join(images_dir, "QEMU") img_dir = os.path.join(images_dir, "QEMU")
bin_path = os.path.join(img_dir, "linux载.img") bin_path = os.path.join(img_dir, "linux载.img")
@ -54,7 +56,7 @@ def fake_qemu_vm(images_dir) -> str:
@pytest.fixture @pytest.fixture
def fake_qemu_img_binary(tmpdir): def fake_qemu_img_binary(self, tmpdir):
bin_path = str(tmpdir / "qemu-img") bin_path = str(tmpdir / "qemu-img")
with open(bin_path, "w+") as f: with open(bin_path, "w+") as f:
@ -64,14 +66,20 @@ def fake_qemu_img_binary(tmpdir):
@pytest.fixture @pytest.fixture
def base_params(tmpdir, fake_qemu_bin) -> dict: def base_params(self, tmpdir, fake_qemu_bin) -> dict:
"""Return standard parameters""" """Return standard parameters"""
return {"name": "QEMU-TEST-1", "qemu_path": fake_qemu_bin} return {"name": "QEMU-TEST-1", "qemu_path": fake_qemu_bin}
@pytest_asyncio.fixture @pytest_asyncio.fixture
async def qemu_vm(app: FastAPI, compute_client: AsyncClient, compute_project: Project, base_params: dict) -> None: async def qemu_vm(
self,
app: FastAPI,
compute_client: AsyncClient,
compute_project: Project,
base_params: dict
) -> None:
response = await compute_client.post( response = await compute_client.post(
app.url_path_for("compute:create_qemu_node", project_id=compute_project.id), app.url_path_for("compute:create_qemu_node", project_id=compute_project.id),
@ -81,11 +89,14 @@ async def qemu_vm(app: FastAPI, compute_client: AsyncClient, compute_project: Pr
return response.json() return response.json()
async def test_qemu_create(app: FastAPI, async def test_qemu_create(
self,
app: FastAPI,
compute_client: AsyncClient, compute_client: AsyncClient,
compute_project: Project, compute_project: Project,
base_params: dict, base_params: dict,
fake_qemu_bin: str) -> None: fake_qemu_bin: str
) -> None:
response = await compute_client.post(app.url_path_for("compute:create_qemu_node", project_id=compute_project.id), json=base_params) response = await compute_client.post(app.url_path_for("compute:create_qemu_node", project_id=compute_project.id), json=base_params)
assert response.status_code == status.HTTP_201_CREATED assert response.status_code == status.HTTP_201_CREATED
@ -95,11 +106,14 @@ async def test_qemu_create(app: FastAPI,
assert response.json()["platform"] == "x86_64" assert response.json()["platform"] == "x86_64"
async def test_qemu_create_platform(app: FastAPI, async def test_qemu_create_platform(
self,
app: FastAPI,
compute_client: AsyncClient, compute_client: AsyncClient,
compute_project: Project, compute_project: Project,
base_params: dict, base_params: dict,
fake_qemu_bin: str): fake_qemu_bin: str
):
base_params["qemu_path"] = None base_params["qemu_path"] = None
base_params["platform"] = "x86_64" base_params["platform"] = "x86_64"
@ -112,11 +126,14 @@ async def test_qemu_create_platform(app: FastAPI,
@pytest.mark.asyncio @pytest.mark.asyncio
async def test_qemu_create_with_params(app: FastAPI, async def test_qemu_create_with_params(
self,
app: FastAPI,
compute_client: AsyncClient, compute_client: AsyncClient,
compute_project: Project, compute_project: Project,
base_params: dict, base_params: dict,
fake_qemu_vm: str): fake_qemu_vm: str
):
params = base_params params = base_params
params["ram"] = 1024 params["ram"] = 1024
@ -147,6 +164,7 @@ async def test_qemu_create_with_params(app: FastAPI,
), ),
) )
async def test_qemu_create_with_invalid_name( async def test_qemu_create_with_invalid_name(
self,
app: FastAPI, app: FastAPI,
compute_client: AsyncClient, compute_client: AsyncClient,
compute_project: Project, compute_project: Project,
@ -161,7 +179,7 @@ async def test_qemu_create_with_invalid_name(
) )
assert response.status_code == status_code assert response.status_code == status_code
# async def test_qemu_create_with_project_file(app: FastAPI, # async def test_qemu_create_with_project_file(self, app: FastAPI,
# compute_client: AsyncClient, # compute_client: AsyncClient,
# compute_project: Project, # compute_project: Project,
# base_params: dict, # base_params: dict,
@ -183,7 +201,13 @@ async def test_qemu_create_with_invalid_name(
# assert response.json()["hda_disk_image_md5sum"] == "7d793037a0760186574b0282f2f435e7" # assert response.json()["hda_disk_image_md5sum"] == "7d793037a0760186574b0282f2f435e7"
async def test_qemu_get(app: FastAPI, compute_client: AsyncClient, compute_project: Project, qemu_vm: dict): async def test_qemu_get(
self,
app: FastAPI,
compute_client: AsyncClient,
compute_project: Project,
qemu_vm: dict
):
response = await compute_client.get( response = await compute_client.get(
app.url_path_for("compute:get_qemu_node", project_id=qemu_vm["project_id"], node_id=qemu_vm["node_id"]) app.url_path_for("compute:get_qemu_node", project_id=qemu_vm["project_id"], node_id=qemu_vm["node_id"])
@ -199,7 +223,7 @@ async def test_qemu_get(app: FastAPI, compute_client: AsyncClient, compute_proje
) )
async def test_qemu_start(app: FastAPI, compute_client: AsyncClient, qemu_vm: dict) -> None: async def test_qemu_start(self, app: FastAPI, compute_client: AsyncClient, qemu_vm: dict) -> None:
with asyncio_patch("gns3server.compute.qemu.qemu_vm.QemuVM.start", return_value=True) as mock: with asyncio_patch("gns3server.compute.qemu.qemu_vm.QemuVM.start", return_value=True) as mock:
response = await compute_client.post( response = await compute_client.post(
@ -209,7 +233,7 @@ async def test_qemu_start(app: FastAPI, compute_client: AsyncClient, qemu_vm: di
assert response.status_code == status.HTTP_204_NO_CONTENT assert response.status_code == status.HTTP_204_NO_CONTENT
async def test_qemu_stop(app: FastAPI, compute_client: AsyncClient, qemu_vm: dict) -> None: async def test_qemu_stop(self, app: FastAPI, compute_client: AsyncClient, qemu_vm: dict) -> None:
with asyncio_patch("gns3server.compute.qemu.qemu_vm.QemuVM.stop", return_value=True) as mock: with asyncio_patch("gns3server.compute.qemu.qemu_vm.QemuVM.stop", return_value=True) as mock:
response = await compute_client.post( response = await compute_client.post(
@ -219,7 +243,7 @@ async def test_qemu_stop(app: FastAPI, compute_client: AsyncClient, qemu_vm: dic
assert response.status_code == status.HTTP_204_NO_CONTENT assert response.status_code == status.HTTP_204_NO_CONTENT
async def test_qemu_reload(app: FastAPI, compute_client: AsyncClient, qemu_vm: dict) -> None: async def test_qemu_reload(self, app: FastAPI, compute_client: AsyncClient, qemu_vm: dict) -> None:
with asyncio_patch("gns3server.compute.qemu.qemu_vm.QemuVM.reload", return_value=True) as mock: with asyncio_patch("gns3server.compute.qemu.qemu_vm.QemuVM.reload", return_value=True) as mock:
response = await compute_client.post( response = await compute_client.post(
@ -229,7 +253,7 @@ async def test_qemu_reload(app: FastAPI, compute_client: AsyncClient, qemu_vm: d
assert response.status_code == status.HTTP_204_NO_CONTENT assert response.status_code == status.HTTP_204_NO_CONTENT
async def test_qemu_suspend(app: FastAPI, compute_client: AsyncClient, qemu_vm: dict) -> None: async def test_qemu_suspend(self, app: FastAPI, compute_client: AsyncClient, qemu_vm: dict) -> None:
with asyncio_patch("gns3server.compute.qemu.qemu_vm.QemuVM.suspend", return_value=True) as mock: with asyncio_patch("gns3server.compute.qemu.qemu_vm.QemuVM.suspend", return_value=True) as mock:
response = await compute_client.post( response = await compute_client.post(
@ -239,7 +263,7 @@ async def test_qemu_suspend(app: FastAPI, compute_client: AsyncClient, qemu_vm:
assert response.status_code == status.HTTP_204_NO_CONTENT assert response.status_code == status.HTTP_204_NO_CONTENT
async def test_qemu_resume(app: FastAPI, compute_client: AsyncClient, qemu_vm: dict) -> None: async def test_qemu_resume(self, app: FastAPI, compute_client: AsyncClient, qemu_vm: dict) -> None:
with asyncio_patch("gns3server.compute.qemu.qemu_vm.QemuVM.resume", return_value=True) as mock: with asyncio_patch("gns3server.compute.qemu.qemu_vm.QemuVM.resume", return_value=True) as mock:
response = await compute_client.post( response = await compute_client.post(
@ -249,7 +273,7 @@ async def test_qemu_resume(app: FastAPI, compute_client: AsyncClient, qemu_vm: d
assert response.status_code == status.HTTP_204_NO_CONTENT assert response.status_code == status.HTTP_204_NO_CONTENT
async def test_qemu_delete(app: FastAPI, compute_client: AsyncClient, qemu_vm: dict) -> None: async def test_qemu_delete(self, app: FastAPI, compute_client: AsyncClient, qemu_vm: dict) -> None:
with asyncio_patch("gns3server.compute.qemu.Qemu.delete_node", return_value=True) as mock: with asyncio_patch("gns3server.compute.qemu.Qemu.delete_node", return_value=True) as mock:
response = await compute_client.delete( response = await compute_client.delete(
@ -259,11 +283,14 @@ async def test_qemu_delete(app: FastAPI, compute_client: AsyncClient, qemu_vm: d
assert response.status_code == status.HTTP_204_NO_CONTENT assert response.status_code == status.HTTP_204_NO_CONTENT
async def test_qemu_update(app: FastAPI, async def test_qemu_update(
self,
app: FastAPI,
compute_client: AsyncClient, compute_client: AsyncClient,
qemu_vm: dict, qemu_vm: dict,
free_console_port: int, free_console_port: int,
fake_qemu_vm: str) -> None: fake_qemu_vm: str
) -> None:
params = { params = {
"name": "test", "name": "test",
@ -283,7 +310,7 @@ async def test_qemu_update(app: FastAPI,
assert response.json()["ram"] == 1024 assert response.json()["ram"] == 1024
async def test_qemu_nio_create_udp(app: FastAPI, compute_client: AsyncClient, qemu_vm: dict) -> None: async def test_qemu_nio_create_udp(self, app: FastAPI, compute_client: AsyncClient, qemu_vm: dict) -> None:
params = { params = {
"type": "nio_udp", "type": "nio_udp",
@ -311,7 +338,7 @@ async def test_qemu_nio_create_udp(app: FastAPI, compute_client: AsyncClient, qe
assert response.json()["type"] == "nio_udp" assert response.json()["type"] == "nio_udp"
async def test_qemu_nio_update_udp(app: FastAPI, compute_client: AsyncClient, qemu_vm: dict) -> None: async def test_qemu_nio_update_udp(self, app: FastAPI, compute_client: AsyncClient, qemu_vm: dict) -> None:
params = { params = {
"type": "nio_udp", "type": "nio_udp",
@ -348,7 +375,7 @@ async def test_qemu_nio_update_udp(app: FastAPI, compute_client: AsyncClient, qe
assert response.json()["type"] == "nio_udp" assert response.json()["type"] == "nio_udp"
async def test_qemu_delete_nio(app: FastAPI, compute_client: AsyncClient, qemu_vm: dict) -> None: async def test_qemu_delete_nio(self, app: FastAPI, compute_client: AsyncClient, qemu_vm: dict) -> None:
params = { params = {
"type": "nio_udp", "type": "nio_udp",
@ -383,7 +410,7 @@ async def test_qemu_delete_nio(app: FastAPI, compute_client: AsyncClient, qemu_v
assert response.status_code == status.HTTP_204_NO_CONTENT assert response.status_code == status.HTTP_204_NO_CONTENT
async def test_images(app: FastAPI, compute_client: AsyncClient, fake_qemu_vm) -> None: async def test_images(self, app: FastAPI, compute_client: AsyncClient, fake_qemu_vm) -> None:
response = await compute_client.get(app.url_path_for("compute:get_qemu_images")) response = await compute_client.get(app.url_path_for("compute:get_qemu_images"))
assert response.status_code == status.HTTP_200_OK assert response.status_code == status.HTTP_200_OK
@ -391,7 +418,7 @@ async def test_images(app: FastAPI, compute_client: AsyncClient, fake_qemu_vm) -
assert {"filename": "linux载.img", "path": "linux载.img", "md5sum": "fcea920f7412b5da7be0cf42b8c93759", "filesize": 7} in response.json() assert {"filename": "linux载.img", "path": "linux载.img", "md5sum": "fcea920f7412b5da7be0cf42b8c93759", "filesize": 7} in response.json()
async def test_upload_image(app: FastAPI, compute_client: AsyncClient, tmpdir: str) -> None: async def test_upload_image(self, app: FastAPI, compute_client: AsyncClient, tmpdir: str) -> None:
with patch("gns3server.compute.Qemu.get_images_directory", return_value=str(tmpdir)): with patch("gns3server.compute.Qemu.get_images_directory", return_value=str(tmpdir)):
@ -407,7 +434,7 @@ async def test_upload_image(app: FastAPI, compute_client: AsyncClient, tmpdir: s
assert checksum == "033bd94b1168d7e4f0d644c3c95e35bf" assert checksum == "033bd94b1168d7e4f0d644c3c95e35bf"
async def test_upload_image_ova(app: FastAPI, compute_client: AsyncClient, tmpdir:str) -> None: async def test_upload_image_ova(self, app: FastAPI, compute_client: AsyncClient, tmpdir:str) -> None:
with patch("gns3server.compute.Qemu.get_images_directory", return_value=str(tmpdir)): with patch("gns3server.compute.Qemu.get_images_directory", return_value=str(tmpdir)):
@ -423,14 +450,18 @@ async def test_upload_image_ova(app: FastAPI, compute_client: AsyncClient, tmpdi
assert checksum == "033bd94b1168d7e4f0d644c3c95e35bf" assert checksum == "033bd94b1168d7e4f0d644c3c95e35bf"
async def test_upload_image_forbidden_location(app: FastAPI, compute_client: AsyncClient, tmpdir: str) -> None: async def test_upload_image_forbidden_location(
self, app: FastAPI,
compute_client: AsyncClient,
tmpdir: str
) -> None:
response = await compute_client.post(app.url_path_for("compute:upload_qemu_image", response = await compute_client.post(app.url_path_for("compute:upload_qemu_image",
filename="/qemu/images/../../test2"), content=b"TEST") filename="/qemu/images/../../test2"), content=b"TEST")
assert response.status_code == status.HTTP_403_FORBIDDEN assert response.status_code == status.HTTP_403_FORBIDDEN
async def test_download_image(app: FastAPI, compute_client: AsyncClient, images_dir: str) -> None: async def test_download_image(self, app: FastAPI, compute_client: AsyncClient, images_dir: str) -> None:
response = await compute_client.post(app.url_path_for("compute:upload_qemu_image", filename="test3"), content=b"TEST") response = await compute_client.post(app.url_path_for("compute:upload_qemu_image", filename="test3"), content=b"TEST")
assert response.status_code == status.HTTP_204_NO_CONTENT assert response.status_code == status.HTTP_204_NO_CONTENT
@ -439,7 +470,7 @@ async def test_download_image(app: FastAPI, compute_client: AsyncClient, images_
assert response.status_code == status.HTTP_200_OK assert response.status_code == status.HTTP_200_OK
async def test_download_image_forbidden_location(app: FastAPI, compute_client: AsyncClient, tmpdir) -> None: async def test_download_image_forbidden_location(self, app: FastAPI, compute_client: AsyncClient, tmpdir) -> None:
file_path = "foo/%2e%2e/%2e%2e/%2e%2e/%2e%2e/%2e%2e/%2e%2e/etc/passwd" file_path = "foo/%2e%2e/%2e%2e/%2e%2e/%2e%2e/%2e%2e/%2e%2e/etc/passwd"
response = await compute_client.get(app.url_path_for("compute:download_qemu_image", filename=file_path)) response = await compute_client.get(app.url_path_for("compute:download_qemu_image", filename=file_path))
@ -447,7 +478,7 @@ async def test_download_image_forbidden_location(app: FastAPI, compute_client: A
@pytest.mark.skipif(os.getuid() == 0, reason="Root can delete any image") @pytest.mark.skipif(os.getuid() == 0, reason="Root can delete any image")
async def test_upload_image_permission_denied(app: FastAPI, compute_client: AsyncClient, images_dir: str) -> None: async def test_upload_image_permission_denied(self, app: FastAPI, compute_client: AsyncClient, images_dir: str) -> None:
with open(os.path.join(images_dir, "QEMU", "test2.tmp"), "w+") as f: with open(os.path.join(images_dir, "QEMU", "test2.tmp"), "w+") as f:
f.write("") f.write("")
@ -458,7 +489,7 @@ async def test_upload_image_permission_denied(app: FastAPI, compute_client: Asyn
# @pytest.mark.asyncio # @pytest.mark.asyncio
# async def test_create_img_relative(app: FastAPI, compute_client: AsyncClient): # async def test_create_img_relative(self, app: FastAPI, compute_client: AsyncClient):
# #
# params = { # params = {
# "qemu_img": "/tmp/qemu-img", # "qemu_img": "/tmp/qemu-img",
@ -475,7 +506,7 @@ async def test_upload_image_permission_denied(app: FastAPI, compute_client: Asyn
# assert response.status_code == status.HTTP_204_NO_CONTENT # assert response.status_code == status.HTTP_204_NO_CONTENT
# #
# #
# async def test_create_img_absolute_non_local(app: FastAPI, compute_client: AsyncClient, config) -> None: # async def test_create_img_absolute_non_local(self, app: FastAPI, compute_client: AsyncClient, config) -> None:
# #
# config.settings.Server.local = False # config.settings.Server.local = False
# params = { # params = {
@ -493,7 +524,7 @@ async def test_upload_image_permission_denied(app: FastAPI, compute_client: Asyn
# assert response.status_code == 403 # assert response.status_code == 403
# #
# #
# async def test_create_img_absolute_local(app: FastAPI, compute_client: AsyncClient, config) -> None: # async def test_create_img_absolute_local(self, app: FastAPI, compute_client: AsyncClient, config) -> None:
# #
# params = { # params = {
# "qemu_img": "/tmp/qemu-img", # "qemu_img": "/tmp/qemu-img",
@ -510,18 +541,21 @@ async def test_upload_image_permission_denied(app: FastAPI, compute_client: Asyn
# assert response.status_code == status.HTTP_204_NO_CONTENT # assert response.status_code == status.HTTP_204_NO_CONTENT
async def test_capabilities(app: FastAPI, compute_client: AsyncClient) -> None: async def test_capabilities(self, app: FastAPI, compute_client: AsyncClient) -> None:
with asyncio_patch("gns3server.compute.Qemu.get_kvm_archs", return_value=["x86_64"]): with asyncio_patch("gns3server.compute.Qemu.get_kvm_archs", return_value=["x86_64"]):
response = await compute_client.get(app.url_path_for("compute:get_qemu_capabilities")) response = await compute_client.get(app.url_path_for("compute:get_qemu_capabilities"))
assert response.json()["kvm"] == ["x86_64"] assert response.json()["kvm"] == ["x86_64"]
async def test_qemu_duplicate(app: FastAPI, async def test_qemu_duplicate(
self,
app: FastAPI,
compute_client: AsyncClient, compute_client: AsyncClient,
compute_project: Project, compute_project: Project,
qemu_vm: dict, qemu_vm: dict,
base_params: dict) -> None: base_params: dict
) -> None:
# create destination node first # create destination node first
response = await compute_client.post( response = await compute_client.post(
@ -539,6 +573,7 @@ async def test_qemu_duplicate(app: FastAPI,
async def test_qemu_create_disk_image( async def test_qemu_create_disk_image(
self,
app: FastAPI, app: FastAPI,
compute_client: AsyncClient, compute_client: AsyncClient,
compute_project: Project, compute_project: Project,
@ -587,6 +622,7 @@ async def test_qemu_create_disk_image(
async def test_qemu_create_disk_image_already_exists( async def test_qemu_create_disk_image_already_exists(
self,
app: FastAPI, app: FastAPI,
compute_client: AsyncClient, compute_client: AsyncClient,
compute_project: Project, compute_project: Project,
@ -644,6 +680,7 @@ async def test_qemu_create_disk_image_already_exists(
async def test_qemu_update_disk_image( async def test_qemu_update_disk_image(
self,
app: FastAPI, app: FastAPI,
compute_client: AsyncClient, compute_client: AsyncClient,
compute_project: Project, compute_project: Project,
@ -677,6 +714,7 @@ async def test_qemu_update_disk_image(
async def test_qemu_delete_disk_image( async def test_qemu_delete_disk_image(
self,
app: FastAPI, app: FastAPI,
compute_client: AsyncClient, compute_client: AsyncClient,
compute_project: Project, compute_project: Project,
@ -698,6 +736,7 @@ async def test_qemu_delete_disk_image(
async def test_qemu_delete_disk_image_missing_image( async def test_qemu_delete_disk_image_missing_image(
self,
app: FastAPI, app: FastAPI,
compute_client: AsyncClient, compute_client: AsyncClient,
compute_project: Project, compute_project: Project,
@ -716,7 +755,7 @@ async def test_qemu_delete_disk_image_missing_image(
@pytest.mark.asyncio @pytest.mark.asyncio
async def test_qemu_start_capture(app: FastAPI, compute_client: AsyncClient, qemu_vm: dict): async def test_qemu_start_capture(self, app: FastAPI, compute_client: AsyncClient, qemu_vm: dict):
params = { params = {
"capture_file_name": "test.pcap", "capture_file_name": "test.pcap",
@ -740,7 +779,7 @@ async def test_qemu_start_capture(app: FastAPI, compute_client: AsyncClient, qem
@pytest.mark.asyncio @pytest.mark.asyncio
async def test_qemu_stop_capture(app: FastAPI, compute_client: AsyncClient, qemu_vm: dict): async def test_qemu_stop_capture(self, app: FastAPI, compute_client: AsyncClient, qemu_vm: dict):
url = app.url_path_for( url = app.url_path_for(
"compute:stop_qemu_node_capture", "compute:stop_qemu_node_capture",
@ -758,7 +797,7 @@ async def test_qemu_stop_capture(app: FastAPI, compute_client: AsyncClient, qemu
# @pytest.mark.asyncio # @pytest.mark.asyncio
# async def test_qemu_pcap(app: FastAPI, compute_client: AsyncClient, vm, compute_project): # async def test_qemu_pcap(self, app: FastAPI, compute_client: AsyncClient, vm, compute_project):
# #
# with asyncio_patch("gns3server.compute.qemu.qemu_vm.QemuVM.get_nio"): # with asyncio_patch("gns3server.compute.qemu.qemu_vm.QemuVM.get_nio"):
# with asyncio_patch("gns3server.compute.qemu.Qemu.stream_pcap_file"): # with asyncio_patch("gns3server.compute.qemu.Qemu.stream_pcap_file"):

34
tests/api/routes/compute/test_virtualbox_nodes.py
View File

@ -28,8 +28,10 @@ from gns3server.compute.project import Project
pytestmark = pytest.mark.asyncio pytestmark = pytest.mark.asyncio
@pytest_asyncio.fixture(scope="function") class TestVirtualBoxNodesRoutes:
async def vm(app: FastAPI, compute_client: AsyncClient, compute_project: Project) -> None:
@pytest_asyncio.fixture
async def vm(self, app: FastAPI, compute_client: AsyncClient, compute_project: Project) -> None:
vboxmanage_path = "/fake/VboxManage" vboxmanage_path = "/fake/VboxManage"
params = { params = {
@ -48,7 +50,7 @@ async def vm(app: FastAPI, compute_client: AsyncClient, compute_project: Project
return response.json() return response.json()
async def test_vbox_create(app: FastAPI, compute_client: AsyncClient, compute_project: Project) -> None: async def test_vbox_create(self, app: FastAPI, compute_client: AsyncClient, compute_project: Project) -> None:
params = { params = {
"name": "VM1", "name": "VM1",
@ -64,7 +66,7 @@ async def test_vbox_create(app: FastAPI, compute_client: AsyncClient, compute_pr
assert response.json()["project_id"] == compute_project.id assert response.json()["project_id"] == compute_project.id
async def test_vbox_get(app: FastAPI, compute_client: AsyncClient, compute_project: Project, vm: dict) -> None: async def test_vbox_get(self, app: FastAPI, compute_client: AsyncClient, compute_project: Project, vm: dict) -> None:
response = await compute_client.get(app.url_path_for("compute:get_virtualbox_node", response = await compute_client.get(app.url_path_for("compute:get_virtualbox_node",
project_id=vm["project_id"], project_id=vm["project_id"],
@ -74,7 +76,7 @@ async def test_vbox_get(app: FastAPI, compute_client: AsyncClient, compute_proje
assert response.json()["project_id"] == compute_project.id assert response.json()["project_id"] == compute_project.id
async def test_vbox_start(app: FastAPI, compute_client: AsyncClient, vm: dict) -> None: async def test_vbox_start(self, app: FastAPI, compute_client: AsyncClient, vm: dict) -> None:
with asyncio_patch("gns3server.compute.virtualbox.virtualbox_vm.VirtualBoxVM.start", return_value=True) as mock: with asyncio_patch("gns3server.compute.virtualbox.virtualbox_vm.VirtualBoxVM.start", return_value=True) as mock:
@ -85,7 +87,7 @@ async def test_vbox_start(app: FastAPI, compute_client: AsyncClient, vm: dict) -
assert response.status_code == status.HTTP_204_NO_CONTENT assert response.status_code == status.HTTP_204_NO_CONTENT
async def test_vbox_stop(app: FastAPI, compute_client: AsyncClient, vm: dict) -> None: async def test_vbox_stop(self, app: FastAPI, compute_client: AsyncClient, vm: dict) -> None:
with asyncio_patch("gns3server.compute.virtualbox.virtualbox_vm.VirtualBoxVM.stop", return_value=True) as mock: with asyncio_patch("gns3server.compute.virtualbox.virtualbox_vm.VirtualBoxVM.stop", return_value=True) as mock:
response = await compute_client.post(app.url_path_for("compute:stop_virtualbox_node", response = await compute_client.post(app.url_path_for("compute:stop_virtualbox_node",
@ -95,7 +97,7 @@ async def test_vbox_stop(app: FastAPI, compute_client: AsyncClient, vm: dict) ->
assert response.status_code == status.HTTP_204_NO_CONTENT assert response.status_code == status.HTTP_204_NO_CONTENT
async def test_vbox_suspend(app: FastAPI, compute_client: AsyncClient, vm: dict) -> None: async def test_vbox_suspend(self, app: FastAPI, compute_client: AsyncClient, vm: dict) -> None:
with asyncio_patch("gns3server.compute.virtualbox.virtualbox_vm.VirtualBoxVM.suspend", return_value=True) as mock: with asyncio_patch("gns3server.compute.virtualbox.virtualbox_vm.VirtualBoxVM.suspend", return_value=True) as mock:
response = await compute_client.post(app.url_path_for("compute:suspend_virtualbox_node", response = await compute_client.post(app.url_path_for("compute:suspend_virtualbox_node",
@ -105,7 +107,7 @@ async def test_vbox_suspend(app: FastAPI, compute_client: AsyncClient, vm: dict)
assert response.status_code == status.HTTP_204_NO_CONTENT assert response.status_code == status.HTTP_204_NO_CONTENT
async def test_vbox_resume(app: FastAPI, compute_client: AsyncClient, vm: dict) -> None: async def test_vbox_resume(self, app: FastAPI, compute_client: AsyncClient, vm: dict) -> None:
with asyncio_patch("gns3server.compute.virtualbox.virtualbox_vm.VirtualBoxVM.resume", return_value=True) as mock: with asyncio_patch("gns3server.compute.virtualbox.virtualbox_vm.VirtualBoxVM.resume", return_value=True) as mock:
response = await compute_client.post(app.url_path_for("compute:resume_virtualbox_node", response = await compute_client.post(app.url_path_for("compute:resume_virtualbox_node",
@ -115,7 +117,7 @@ async def test_vbox_resume(app: FastAPI, compute_client: AsyncClient, vm: dict)
assert response.status_code == status.HTTP_204_NO_CONTENT assert response.status_code == status.HTTP_204_NO_CONTENT
async def test_vbox_reload(app: FastAPI, compute_client: AsyncClient, vm: dict) -> None: async def test_vbox_reload(self, app: FastAPI, compute_client: AsyncClient, vm: dict) -> None:
with asyncio_patch("gns3server.compute.virtualbox.virtualbox_vm.VirtualBoxVM.reload", return_value=True) as mock: with asyncio_patch("gns3server.compute.virtualbox.virtualbox_vm.VirtualBoxVM.reload", return_value=True) as mock:
response = await compute_client.post(app.url_path_for("compute:reload_virtualbox_node", response = await compute_client.post(app.url_path_for("compute:reload_virtualbox_node",
@ -125,7 +127,7 @@ async def test_vbox_reload(app: FastAPI, compute_client: AsyncClient, vm: dict)
assert response.status_code == status.HTTP_204_NO_CONTENT assert response.status_code == status.HTTP_204_NO_CONTENT
async def test_vbox_nio_create_udp(app: FastAPI, compute_client: AsyncClient, vm: dict) -> None: async def test_vbox_nio_create_udp(self, app: FastAPI, compute_client: AsyncClient, vm: dict) -> None:
params = { params = {
"type": "nio_udp", "type": "nio_udp",
@ -151,7 +153,7 @@ async def test_vbox_nio_create_udp(app: FastAPI, compute_client: AsyncClient, vm
# @pytest.mark.asyncio # @pytest.mark.asyncio
# async def test_vbox_nio_update_udp(app: FastAPI, compute_client: AsyncClient, vm): # async def test_vbox_nio_update_udp(self, app: FastAPI, compute_client: AsyncClient, vm):
# #
# params = { # params = {
# "type": "nio_udp", # "type": "nio_udp",
@ -169,7 +171,7 @@ async def test_vbox_nio_create_udp(app: FastAPI, compute_client: AsyncClient, vm
# assert response.json()["type"] == "nio_udp" # assert response.json()["type"] == "nio_udp"
async def test_vbox_delete_nio(app: FastAPI, compute_client: AsyncClient, vm: dict) -> None: async def test_vbox_delete_nio(self, app: FastAPI, compute_client: AsyncClient, vm: dict) -> None:
url = app.url_path_for("compute:delete_virtualbox_node_nio", url = app.url_path_for("compute:delete_virtualbox_node_nio",
project_id=vm["project_id"], project_id=vm["project_id"],
@ -186,7 +188,7 @@ async def test_vbox_delete_nio(app: FastAPI, compute_client: AsyncClient, vm: di
@pytest.mark.asyncio @pytest.mark.asyncio
async def test_vbox_update(app: FastAPI, compute_client: AsyncClient, vm, free_console_port): async def test_vbox_update(self, app: FastAPI, compute_client: AsyncClient, vm, free_console_port):
params = { params = {
"name": "test", "name": "test",
@ -202,7 +204,7 @@ async def test_vbox_update(app: FastAPI, compute_client: AsyncClient, vm, free_c
@pytest.mark.asyncio @pytest.mark.asyncio
async def test_virtualbox_start_capture(app: FastAPI, compute_client: AsyncClient, vm): async def test_virtualbox_start_capture(self, app: FastAPI, compute_client: AsyncClient, vm):
params = { params = {
"capture_file_name": "test.pcap", "capture_file_name": "test.pcap",
@ -224,7 +226,7 @@ async def test_virtualbox_start_capture(app: FastAPI, compute_client: AsyncClien
@pytest.mark.asyncio @pytest.mark.asyncio
async def test_virtualbox_stop_capture(app: FastAPI, compute_client: AsyncClient, vm): async def test_virtualbox_stop_capture(self, app: FastAPI, compute_client: AsyncClient, vm):
url = app.url_path_for("compute:stop_virtualbox_node_capture", url = app.url_path_for("compute:stop_virtualbox_node_capture",
project_id=vm["project_id"], project_id=vm["project_id"],
@ -240,7 +242,7 @@ async def test_virtualbox_stop_capture(app: FastAPI, compute_client: AsyncClient
# @pytest.mark.asyncio # @pytest.mark.asyncio
# async def test_virtualbox_pcap(app: FastAPI, compute_client: AsyncClient, vm, compute_project): # async def test_virtualbox_pcap(self, app: FastAPI, compute_client: AsyncClient, vm, compute_project):
# #
# with asyncio_patch("gns3server.compute.virtualbox.virtualbox_vm.VirtualBoxVM.get_nio"): # with asyncio_patch("gns3server.compute.virtualbox.virtualbox_vm.VirtualBoxVM.get_nio"):
# with asyncio_patch("gns3server.compute.virtualbox.VirtualBox.stream_pcap_file"): # with asyncio_patch("gns3server.compute.virtualbox.VirtualBox.stream_pcap_file"):

54
tests/api/routes/compute/test_vmware_nodes.py
View File

@ -28,8 +28,10 @@ from gns3server.compute.project import Project
pytestmark = pytest.mark.asyncio pytestmark = pytest.mark.asyncio
@pytest_asyncio.fixture(scope="function") class TestVMwareNodesRoutes:
async def vm(app: FastAPI, compute_client: AsyncClient, compute_project: Project, vmx_path: str) -> dict:
@pytest_asyncio.fixture
async def vm(self, app: FastAPI, compute_client: AsyncClient, compute_project: Project, vmx_path: str) -> dict:
params = { params = {
"name": "VMTEST", "name": "VMTEST",
@ -46,7 +48,7 @@ async def vm(app: FastAPI, compute_client: AsyncClient, compute_project: Project
@pytest.fixture @pytest.fixture
def vmx_path(tmpdir: str) -> str: def vmx_path(self, tmpdir: str) -> str:
""" """
Return a fake VMX file Return a fake VMX file
""" """
@ -57,7 +59,13 @@ def vmx_path(tmpdir: str) -> str:
return path return path
async def test_vmware_create(app: FastAPI, compute_client: AsyncClient, compute_project: Project, vmx_path: str) -> None: async def test_vmware_create(
self,
app: FastAPI,
compute_client: AsyncClient,
compute_project: Project,
vmx_path: str
) -> None:
params = { params = {
"name": "VM1", "name": "VM1",
@ -73,7 +81,13 @@ async def test_vmware_create(app: FastAPI, compute_client: AsyncClient, compute_
assert response.json()["project_id"] == compute_project.id assert response.json()["project_id"] == compute_project.id
async def test_vmware_get(app: FastAPI, compute_client: AsyncClient, compute_project: Project, vm: dict) -> None: async def test_vmware_get(
self,
app: FastAPI,
compute_client: AsyncClient,
compute_project: Project,
vm: dict
) -> None:
response = await compute_client.get(app.url_path_for("compute:get_vmware_node", project_id=vm["project_id"], node_id=vm["node_id"])) response = await compute_client.get(app.url_path_for("compute:get_vmware_node", project_id=vm["project_id"], node_id=vm["node_id"]))
assert response.status_code == status.HTTP_200_OK assert response.status_code == status.HTTP_200_OK
@ -81,7 +95,7 @@ async def test_vmware_get(app: FastAPI, compute_client: AsyncClient, compute_pro
assert response.json()["project_id"] == compute_project.id assert response.json()["project_id"] == compute_project.id
async def test_vmware_start(app: FastAPI, compute_client: AsyncClient, vm: dict) -> None: async def test_vmware_start(self, app: FastAPI, compute_client: AsyncClient, vm: dict) -> None:
with asyncio_patch("gns3server.compute.vmware.vmware_vm.VMwareVM.start", return_value=True) as mock: with asyncio_patch("gns3server.compute.vmware.vmware_vm.VMwareVM.start", return_value=True) as mock:
response = await compute_client.post(app.url_path_for("compute:start_vmware_node", response = await compute_client.post(app.url_path_for("compute:start_vmware_node",
@ -91,7 +105,7 @@ async def test_vmware_start(app: FastAPI, compute_client: AsyncClient, vm: dict)
assert response.status_code == status.HTTP_204_NO_CONTENT assert response.status_code == status.HTTP_204_NO_CONTENT
async def test_vmware_stop(app: FastAPI, compute_client: AsyncClient, vm: dict) -> None: async def test_vmware_stop(self, app: FastAPI, compute_client: AsyncClient, vm: dict) -> None:
with asyncio_patch("gns3server.compute.vmware.vmware_vm.VMwareVM.stop", return_value=True) as mock: with asyncio_patch("gns3server.compute.vmware.vmware_vm.VMwareVM.stop", return_value=True) as mock:
response = await compute_client.post(app.url_path_for("compute:stop_vmware_node", response = await compute_client.post(app.url_path_for("compute:stop_vmware_node",
@ -101,7 +115,7 @@ async def test_vmware_stop(app: FastAPI, compute_client: AsyncClient, vm: dict)
assert response.status_code == status.HTTP_204_NO_CONTENT assert response.status_code == status.HTTP_204_NO_CONTENT
async def test_vmware_suspend(app: FastAPI, compute_client: AsyncClient, vm: dict) -> None: async def test_vmware_suspend(self, app: FastAPI, compute_client: AsyncClient, vm: dict) -> None:
with asyncio_patch("gns3server.compute.vmware.vmware_vm.VMwareVM.suspend", return_value=True) as mock: with asyncio_patch("gns3server.compute.vmware.vmware_vm.VMwareVM.suspend", return_value=True) as mock:
response = await compute_client.post(app.url_path_for("compute:suspend_vmware_node", response = await compute_client.post(app.url_path_for("compute:suspend_vmware_node",
@ -111,7 +125,7 @@ async def test_vmware_suspend(app: FastAPI, compute_client: AsyncClient, vm: dic
assert response.status_code == status.HTTP_204_NO_CONTENT assert response.status_code == status.HTTP_204_NO_CONTENT
async def test_vmware_resume(app: FastAPI, compute_client: AsyncClient, vm: dict) -> None: async def test_vmware_resume(self, app: FastAPI, compute_client: AsyncClient, vm: dict) -> None:
with asyncio_patch("gns3server.compute.vmware.vmware_vm.VMwareVM.resume", return_value=True) as mock: with asyncio_patch("gns3server.compute.vmware.vmware_vm.VMwareVM.resume", return_value=True) as mock:
response = await compute_client.post(app.url_path_for("compute:resume_vmware_node", response = await compute_client.post(app.url_path_for("compute:resume_vmware_node",
@ -121,7 +135,7 @@ async def test_vmware_resume(app: FastAPI, compute_client: AsyncClient, vm: dict
assert response.status_code == status.HTTP_204_NO_CONTENT assert response.status_code == status.HTTP_204_NO_CONTENT
async def test_vmware_reload(app: FastAPI, compute_client: AsyncClient, vm: dict) -> None: async def test_vmware_reload(self, app: FastAPI, compute_client: AsyncClient, vm: dict) -> None:
with asyncio_patch("gns3server.compute.vmware.vmware_vm.VMwareVM.reload", return_value=True) as mock: with asyncio_patch("gns3server.compute.vmware.vmware_vm.VMwareVM.reload", return_value=True) as mock:
response = await compute_client.post(app.url_path_for("compute:reload_vmware_node", response = await compute_client.post(app.url_path_for("compute:reload_vmware_node",
@ -131,7 +145,7 @@ async def test_vmware_reload(app: FastAPI, compute_client: AsyncClient, vm: dict
assert response.status_code == status.HTTP_204_NO_CONTENT assert response.status_code == status.HTTP_204_NO_CONTENT
async def test_vmware_nio_create_udp(app: FastAPI, compute_client: AsyncClient, vm: dict) -> None: async def test_vmware_nio_create_udp(self, app: FastAPI, compute_client: AsyncClient, vm: dict) -> None:
params = { params = {
"type": "nio_udp", "type": "nio_udp",
@ -157,7 +171,7 @@ async def test_vmware_nio_create_udp(app: FastAPI, compute_client: AsyncClient,
# @pytest.mark.asyncio # @pytest.mark.asyncio
# async def test_vmware_nio_update_udp(app: FastAPI, compute_client: AsyncClient, vm): # async def test_vmware_nio_update_udp(self, app: FastAPI, compute_client: AsyncClient, vm):
# #
# params = { # params = {
# "type": "nio_udp", # "type": "nio_udp",
@ -175,7 +189,7 @@ async def test_vmware_nio_create_udp(app: FastAPI, compute_client: AsyncClient,
# assert response.json()["type"] == "nio_udp" # assert response.json()["type"] == "nio_udp"
async def test_vmware_delete_nio(app: FastAPI, compute_client: AsyncClient, vm: dict) -> None: async def test_vmware_delete_nio(self, app: FastAPI, compute_client: AsyncClient, vm: dict) -> None:
url = app.url_path_for("compute:delete_vmware_node_nio", url = app.url_path_for("compute:delete_vmware_node_nio",
project_id=vm["project_id"], project_id=vm["project_id"],
@ -192,7 +206,13 @@ async def test_vmware_delete_nio(app: FastAPI, compute_client: AsyncClient, vm:
assert response.status_code == status.HTTP_204_NO_CONTENT assert response.status_code == status.HTTP_204_NO_CONTENT
async def test_vmware_update(app: FastAPI, compute_client: AsyncClient, vm: dict, free_console_port: int) -> None: async def test_vmware_update(
self,
app: FastAPI,
compute_client: AsyncClient,
vm: dict,
free_console_port: int
) -> None:
params = { params = {
"name": "test", "name": "test",
@ -207,7 +227,7 @@ async def test_vmware_update(app: FastAPI, compute_client: AsyncClient, vm: dict
assert response.json()["console"] == free_console_port assert response.json()["console"] == free_console_port
async def test_vmware_start_capture(app: FastAPI, compute_client: AsyncClient, vm: dict) -> None: async def test_vmware_start_capture(self, app: FastAPI, compute_client: AsyncClient, vm: dict) -> None:
params = { params = {
"capture_file_name": "test.pcap", "capture_file_name": "test.pcap",
@ -229,7 +249,7 @@ async def test_vmware_start_capture(app: FastAPI, compute_client: AsyncClient, v
assert "test.pcap" in response.json()["pcap_file_path"] assert "test.pcap" in response.json()["pcap_file_path"]
async def test_vmware_stop_capture(app: FastAPI, compute_client: AsyncClient, vm: dict) -> None: async def test_vmware_stop_capture(self, app: FastAPI, compute_client: AsyncClient, vm: dict) -> None:
url = app.url_path_for("compute:stop_vmware_node_capture", url = app.url_path_for("compute:stop_vmware_node_capture",
project_id=vm["project_id"], project_id=vm["project_id"],
@ -245,7 +265,7 @@ async def test_vmware_stop_capture(app: FastAPI, compute_client: AsyncClient, vm
# @pytest.mark.asyncio # @pytest.mark.asyncio
# async def test_vmware_pcap(app: FastAPI, compute_client: AsyncClient, vm, compute_project): # async def test_vmware_pcap(self, app: FastAPI, compute_client: AsyncClient, vm, compute_project):
# #
# with asyncio_patch("gns3server.compute.vmware.vmware_vm.VMwareVM.get_nio"): # with asyncio_patch("gns3server.compute.vmware.vmware_vm.VMwareVM.get_nio"):
# with asyncio_patch("gns3server.compute.vmware.VMware.stream_pcap_file"): # with asyncio_patch("gns3server.compute.vmware.VMware.stream_pcap_file"):

64
tests/api/routes/compute/test_vpcs_nodes.py
View File

@ -28,8 +28,10 @@ from gns3server.compute.project import Project
pytestmark = pytest.mark.asyncio pytestmark = pytest.mark.asyncio
class TestVPCSNodesRoutes:
@pytest_asyncio.fixture @pytest_asyncio.fixture
async def vm(app: FastAPI, compute_client: AsyncClient, compute_project: Project) -> None: async def vm(self, app: FastAPI, compute_client: AsyncClient, compute_project: Project) -> None:
params = {"name": "PC TEST 1"} params = {"name": "PC TEST 1"}
response = await compute_client.post(app.url_path_for("compute:create_vpcs_node", project_id=compute_project.id), json=params) response = await compute_client.post(app.url_path_for("compute:create_vpcs_node", project_id=compute_project.id), json=params)
@ -37,7 +39,7 @@ async def vm(app: FastAPI, compute_client: AsyncClient, compute_project: Project
return response.json() return response.json()
async def test_vpcs_create(app: FastAPI, compute_client: AsyncClient, compute_project: Project) -> None: async def test_vpcs_create(self, app: FastAPI, compute_client: AsyncClient, compute_project: Project) -> None:
params = {"name": "PC TEST 1"} params = {"name": "PC TEST 1"}
response = await compute_client.post(app.url_path_for("compute:create_vpcs_node", project_id=compute_project.id), json=params) response = await compute_client.post(app.url_path_for("compute:create_vpcs_node", project_id=compute_project.id), json=params)
@ -46,7 +48,13 @@ async def test_vpcs_create(app: FastAPI, compute_client: AsyncClient, compute_pr
assert response.json()["project_id"] == compute_project.id assert response.json()["project_id"] == compute_project.id
async def test_vpcs_get(app: FastAPI, compute_client: AsyncClient, compute_project: Project, vm: dict) -> None: async def test_vpcs_get(
self,
app: FastAPI,
compute_client: AsyncClient,
compute_project: Project,
vm: dict
) -> None:
response = await compute_client.get(app.url_path_for("compute:get_vpcs_node", project_id=vm["project_id"], node_id=vm["node_id"])) response = await compute_client.get(app.url_path_for("compute:get_vpcs_node", project_id=vm["project_id"], node_id=vm["node_id"]))
assert response.status_code == status.HTTP_200_OK assert response.status_code == status.HTTP_200_OK
@ -55,7 +63,12 @@ async def test_vpcs_get(app: FastAPI, compute_client: AsyncClient, compute_proje
assert response.json()["status"] == "stopped" assert response.json()["status"] == "stopped"
async def test_vpcs_create_startup_script(app: FastAPI, compute_client: AsyncClient, compute_project: Project) -> None: async def test_vpcs_create_startup_script(
self,
app: FastAPI,
compute_client: AsyncClient,
compute_project: Project
) -> None:
params = { params = {
"name": "PC TEST 1", "name": "PC TEST 1",
@ -68,10 +81,13 @@ async def test_vpcs_create_startup_script(app: FastAPI, compute_client: AsyncCli
assert response.json()["project_id"] == compute_project.id assert response.json()["project_id"] == compute_project.id
async def test_vpcs_create_port(app: FastAPI, async def test_vpcs_create_port(
self,
app: FastAPI,
compute_client: AsyncClient, compute_client: AsyncClient,
compute_project: Project, compute_project: Project,
free_console_port: int) -> None: free_console_port: int
) -> None:
params = { params = {
"name": "PC TEST 1", "name": "PC TEST 1",
@ -85,7 +101,7 @@ async def test_vpcs_create_port(app: FastAPI,
assert response.json()["console"] == free_console_port assert response.json()["console"] == free_console_port
async def test_vpcs_nio_create_udp(app: FastAPI, compute_client: AsyncClient, vm: dict) -> None: async def test_vpcs_nio_create_udp(self, app: FastAPI, compute_client: AsyncClient, vm: dict) -> None:
params = { params = {
"type": "nio_udp", "type": "nio_udp",
@ -106,7 +122,7 @@ async def test_vpcs_nio_create_udp(app: FastAPI, compute_client: AsyncClient, vm
assert response.json()["type"] == "nio_udp" assert response.json()["type"] == "nio_udp"
async def test_vpcs_nio_update_udp(app: FastAPI, compute_client: AsyncClient, vm: dict) -> None: async def test_vpcs_nio_update_udp(self, app: FastAPI, compute_client: AsyncClient, vm: dict) -> None:
params = { params = {
"type": "nio_udp", "type": "nio_udp",
@ -136,7 +152,7 @@ async def test_vpcs_nio_update_udp(app: FastAPI, compute_client: AsyncClient, vm
assert response.json()["type"] == "nio_udp" assert response.json()["type"] == "nio_udp"
async def test_vpcs_delete_nio(app: FastAPI, compute_client: AsyncClient, vm: dict) -> None: async def test_vpcs_delete_nio(self, app: FastAPI, compute_client: AsyncClient, vm: dict) -> None:
params = { params = {
"type": "nio_udp", "type": "nio_udp",
@ -162,7 +178,7 @@ async def test_vpcs_delete_nio(app: FastAPI, compute_client: AsyncClient, vm: di
assert response.status_code == status.HTTP_204_NO_CONTENT assert response.status_code == status.HTTP_204_NO_CONTENT
async def test_vpcs_start(app: FastAPI, compute_client: AsyncClient, vm: dict) -> None: async def test_vpcs_start(self, app: FastAPI, compute_client: AsyncClient, vm: dict) -> None:
with asyncio_patch("gns3server.compute.vpcs.vpcs_vm.VPCSVM.start", return_value=True) as mock: with asyncio_patch("gns3server.compute.vpcs.vpcs_vm.VPCSVM.start", return_value=True) as mock:
response = await compute_client.post(app.url_path_for("compute:start_vpcs_node", response = await compute_client.post(app.url_path_for("compute:start_vpcs_node",
@ -172,7 +188,7 @@ async def test_vpcs_start(app: FastAPI, compute_client: AsyncClient, vm: dict) -
assert response.status_code == status.HTTP_204_NO_CONTENT assert response.status_code == status.HTTP_204_NO_CONTENT
async def test_vpcs_stop(app: FastAPI, compute_client: AsyncClient, vm: dict) -> None: async def test_vpcs_stop(self, app: FastAPI, compute_client: AsyncClient, vm: dict) -> None:
with asyncio_patch("gns3server.compute.vpcs.vpcs_vm.VPCSVM.stop", return_value=True) as mock: with asyncio_patch("gns3server.compute.vpcs.vpcs_vm.VPCSVM.stop", return_value=True) as mock:
@ -183,7 +199,7 @@ async def test_vpcs_stop(app: FastAPI, compute_client: AsyncClient, vm: dict) ->
assert response.status_code == status.HTTP_204_NO_CONTENT assert response.status_code == status.HTTP_204_NO_CONTENT
async def test_vpcs_reload(app: FastAPI, compute_client: AsyncClient, vm: dict) -> None: async def test_vpcs_reload(self, app: FastAPI, compute_client: AsyncClient, vm: dict) -> None:
with asyncio_patch("gns3server.compute.vpcs.vpcs_vm.VPCSVM.reload", return_value=True) as mock: with asyncio_patch("gns3server.compute.vpcs.vpcs_vm.VPCSVM.reload", return_value=True) as mock:
response = await compute_client.post(app.url_path_for("compute:reload_vpcs_node", response = await compute_client.post(app.url_path_for("compute:reload_vpcs_node",
@ -193,7 +209,7 @@ async def test_vpcs_reload(app: FastAPI, compute_client: AsyncClient, vm: dict)
assert response.status_code == status.HTTP_204_NO_CONTENT assert response.status_code == status.HTTP_204_NO_CONTENT
async def test_vpcs_delete(app: FastAPI, compute_client: AsyncClient, vm: dict) -> None: async def test_vpcs_delete(self, app: FastAPI, compute_client: AsyncClient, vm: dict) -> None:
with asyncio_patch("gns3server.compute.vpcs.VPCS.delete_node", return_value=True) as mock: with asyncio_patch("gns3server.compute.vpcs.VPCS.delete_node", return_value=True) as mock:
response = await compute_client.delete(app.url_path_for("compute:delete_vpcs_node", response = await compute_client.delete(app.url_path_for("compute:delete_vpcs_node",
@ -203,7 +219,13 @@ async def test_vpcs_delete(app: FastAPI, compute_client: AsyncClient, vm: dict)
assert response.status_code == status.HTTP_204_NO_CONTENT assert response.status_code == status.HTTP_204_NO_CONTENT
async def test_vpcs_duplicate(app: FastAPI, compute_client: AsyncClient, compute_project: Project, vm: dict) -> None: async def test_vpcs_duplicate(
self,
app: FastAPI,
compute_client: AsyncClient,
compute_project: Project,
vm: dict
) -> None:
# create destination node first # create destination node first
params = {"name": "PC TEST 1"} params = {"name": "PC TEST 1"}
@ -217,7 +239,13 @@ async def test_vpcs_duplicate(app: FastAPI, compute_client: AsyncClient, compute
assert response.status_code == status.HTTP_201_CREATED assert response.status_code == status.HTTP_201_CREATED
async def test_vpcs_update(app: FastAPI, compute_client: AsyncClient, vm: dict, free_console_port: int) -> None: async def test_vpcs_update(
self,
app: FastAPI,
compute_client: AsyncClient,
vm: dict,
free_console_port: int
) -> None:
console_port = free_console_port console_port = free_console_port
params = { params = {
@ -233,7 +261,7 @@ async def test_vpcs_update(app: FastAPI, compute_client: AsyncClient, vm: dict,
assert response.json()["console"] == console_port assert response.json()["console"] == console_port
async def test_vpcs_start_capture(app: FastAPI, compute_client: AsyncClient, vm: dict) -> None: async def test_vpcs_start_capture(self, app: FastAPI, compute_client: AsyncClient, vm: dict) -> None:
params = { params = {
"capture_file_name": "test.pcap", "capture_file_name": "test.pcap",
@ -254,7 +282,7 @@ async def test_vpcs_start_capture(app: FastAPI, compute_client: AsyncClient, vm:
assert "test.pcap" in response.json()["pcap_file_path"] assert "test.pcap" in response.json()["pcap_file_path"]
async def test_vpcs_stop_capture(app: FastAPI, compute_client: AsyncClient, vm: dict) -> None: async def test_vpcs_stop_capture(self, app: FastAPI, compute_client: AsyncClient, vm: dict) -> None:
url = app.url_path_for("compute:stop_vpcs_node_capture", url = app.url_path_for("compute:stop_vpcs_node_capture",
project_id=vm["project_id"], project_id=vm["project_id"],
@ -270,7 +298,7 @@ async def test_vpcs_stop_capture(app: FastAPI, compute_client: AsyncClient, vm:
# @pytest.mark.asyncio # @pytest.mark.asyncio
# async def test_vpcs_pcap(app: FastAPI, compute_client: AsyncClient, vm, compute_project: Project): # async def test_vpcs_pcap(self, app: FastAPI, compute_client: AsyncClient, vm, compute_project: Project):
# #
# with asyncio_patch("gns3server.compute.vpcs.vpcs_vm.VPCSVM.get_nio"): # with asyncio_patch("gns3server.compute.vpcs.vpcs_vm.VPCSVM.get_nio"):
# with asyncio_patch("gns3server.compute.vpcs.VPCS.stream_pcap_file"): # with asyncio_patch("gns3server.compute.vpcs.VPCS.stream_pcap_file"):

8
tests/api/routes/controller/test_controller.py
View File

@ -27,7 +27,9 @@ from gns3server.config import Config
pytestmark = pytest.mark.asyncio pytestmark = pytest.mark.asyncio
async def test_shutdown_local(app: FastAPI, client: AsyncClient, config: Config) -> None: class TestControllerRoutes:
async def test_shutdown_local(self, app: FastAPI, client: AsyncClient, config: Config) -> None:
os.kill = MagicMock() os.kill = MagicMock()
config.settings.Server.local = True config.settings.Server.local = True
@ -36,7 +38,7 @@ async def test_shutdown_local(app: FastAPI, client: AsyncClient, config: Config)
assert os.kill.called assert os.kill.called
async def test_shutdown_non_local(app: FastAPI, client: AsyncClient, config: Config) -> None: async def test_shutdown_non_local(self, app: FastAPI, client: AsyncClient, config: Config) -> None:
response = await client.post(app.url_path_for("shutdown")) response = await client.post(app.url_path_for("shutdown"))
assert response.status_code == status.HTTP_403_FORBIDDEN assert response.status_code == status.HTTP_403_FORBIDDEN
@ -63,7 +65,7 @@ async def test_shutdown_non_local(app: FastAPI, client: AsyncClient, config: Con
# assert response.status_code == 403 # assert response.status_code == 403
async def test_statistics_output(app: FastAPI, client: AsyncClient) -> None: async def test_statistics_output(self, app: FastAPI, client: AsyncClient) -> None:
response = await client.get(app.url_path_for("statistics")) response = await client.get(app.url_path_for("statistics"))
assert response.status_code == status.HTTP_200_OK assert response.status_code == status.HTTP_200_OK

12
tests/api/routes/controller/test_drawings.py
View File

@ -26,7 +26,9 @@ from gns3server.controller.project import Project
pytestmark = pytest.mark.asyncio pytestmark = pytest.mark.asyncio
async def test_create_drawing(app: FastAPI, client: AsyncClient, project: Project) -> None: class TestDrawingsRoutes:
async def test_create_drawing(self, app: FastAPI, client: AsyncClient, project: Project) -> None:
params = { 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>', "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>',
@ -40,7 +42,7 @@ async def test_create_drawing(app: FastAPI, client: AsyncClient, project: Projec
assert response.json()["drawing_id"] is not None assert response.json()["drawing_id"] is not None
async def test_get_drawing(app: FastAPI, client: AsyncClient, project: Project) -> None: async def test_get_drawing(self, app: FastAPI, client: AsyncClient, project: Project) -> None:
params = { 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>', "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>',
@ -59,7 +61,7 @@ async def test_get_drawing(app: FastAPI, client: AsyncClient, project: Project)
assert response.json()["x"] == 10 assert response.json()["x"] == 10
async def test_update_drawing(app: FastAPI, client: AsyncClient, project: Project) -> None: async def test_update_drawing(self, app: FastAPI, client: AsyncClient, project: Project) -> None:
params = { 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>', "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>',
@ -80,7 +82,7 @@ async def test_update_drawing(app: FastAPI, client: AsyncClient, project: Projec
assert response.json()["x"] == 42 assert response.json()["x"] == 42
async def test_all_drawings(app: FastAPI, client: AsyncClient, project: Project) -> None: async def test_all_drawings(self, app: FastAPI, client: AsyncClient, project: Project) -> None:
params = { 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>', "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>',
@ -101,7 +103,7 @@ async def test_all_drawings(app: FastAPI, client: AsyncClient, project: Project)
assert len(response.json()) == 1 assert len(response.json()) == 1
async def test_delete_drawing(app: FastAPI, client: AsyncClient, project: Project) -> None: async def test_delete_drawing(self, app: FastAPI, client: AsyncClient, project: Project) -> None:
drawing = Drawing(project) drawing = Drawing(project)
project._drawings = {drawing.id: drawing} project._drawings = {drawing.id: drawing}

10
tests/api/routes/controller/test_gns3vm.py
View File

@ -24,7 +24,9 @@ from tests.utils import asyncio_patch
pytestmark = pytest.mark.asyncio pytestmark = pytest.mark.asyncio
async def test_list_vms(app: FastAPI, client: AsyncClient) -> None: class TestGNS3VMRoutes:
async def test_list_vms(self, app: FastAPI, client: AsyncClient) -> None:
with asyncio_patch("gns3server.controller.gns3vm.vmware_gns3_vm.VMwareGNS3VM.list", return_value=[{"vmname": "test"}]): with asyncio_patch("gns3server.controller.gns3vm.vmware_gns3_vm.VMwareGNS3VM.list", return_value=[{"vmname": "test"}]):
response = await client.get(app.url_path_for("get_vms", engine="vmware")) response = await client.get(app.url_path_for("get_vms", engine="vmware"))
@ -36,20 +38,20 @@ async def test_list_vms(app: FastAPI, client: AsyncClient) -> None:
] ]
async def test_engines(app: FastAPI, client: AsyncClient) -> None: async def test_engines(self, app: FastAPI, client: AsyncClient) -> None:
response = await client.get(app.url_path_for("get_engines")) response = await client.get(app.url_path_for("get_engines"))
assert response.status_code == status.HTTP_200_OK assert response.status_code == status.HTTP_200_OK
assert len(response.json()) > 0 assert len(response.json()) > 0
async def test_put_gns3vm(app: FastAPI, client: AsyncClient) -> None: async def test_put_gns3vm(self, app: FastAPI, client: AsyncClient) -> None:
response = await client.put(app.url_path_for("update_gns3vm_settings"), 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.status_code == status.HTTP_200_OK
assert response.json()["vmname"] == "TEST VM" assert response.json()["vmname"] == "TEST VM"
async def test_get_gns3vm(app: FastAPI, client: AsyncClient) -> None: async def test_get_gns3vm(self, app: FastAPI, client: AsyncClient) -> None:
response = await client.get(app.url_path_for("get_gns3vm_settings")) response = await client.get(app.url_path_for("get_gns3vm_settings"))
assert response.status_code == status.HTTP_200_OK assert response.status_code == status.HTTP_200_OK

62
tests/api/routes/controller/test_links.py
View File

@ -35,8 +35,10 @@ from gns3server.controller.udp_link import UDPLink
pytestmark = pytest.mark.asyncio pytestmark = pytest.mark.asyncio
class TestLinkRoutes:
@pytest_asyncio.fixture @pytest_asyncio.fixture
async def nodes(compute: Compute, project: Project) -> Tuple[Node, Node]: async def nodes(self, compute: Compute, project: Project) -> Tuple[Node, Node]:
response = MagicMock() response = MagicMock()
response.json = {"console": 2048} response.json = {"console": 2048}
@ -49,7 +51,13 @@ async def nodes(compute: Compute, project: Project) -> Tuple[Node, Node]:
return node1, node2 return node1, node2
async def test_create_link(app: FastAPI, client: AsyncClient, project: Project, nodes: Tuple[Node, Node]) -> None: async def test_create_link(
self,
app: FastAPI,
client: AsyncClient,
project: Project,
nodes: Tuple[Node, Node]
) -> None:
node1, node2 = nodes node1, node2 = nodes
@ -89,7 +97,13 @@ async def test_create_link(app: FastAPI, client: AsyncClient, project: Project,
assert list(project.links.values())[0].filters == filters assert list(project.links.values())[0].filters == filters
async def test_create_link_failure(app: FastAPI, client: AsyncClient, compute: Compute, project: Project) -> None: async def test_create_link_failure(
self,
app: FastAPI,
client: AsyncClient,
compute: Compute,
project: Project
) -> None:
""" """
Make sure the link is deleted if we failed to create it. Make sure the link is deleted if we failed to create it.
@ -127,7 +141,13 @@ async def test_create_link_failure(app: FastAPI, client: AsyncClient, compute: C
assert len(project.links) == 0 assert len(project.links) == 0
async def test_get_link(app: FastAPI, client: AsyncClient, project: Project, nodes: Tuple[Node, Node]) -> None: async def test_get_link(
self,
app: FastAPI,
client: AsyncClient,
project: Project,
nodes: Tuple[Node, Node]
) -> None:
node1, node2 = nodes node1, node2 = nodes
with asyncio_patch("gns3server.controller.udp_link.UDPLink.create") as mock: with asyncio_patch("gns3server.controller.udp_link.UDPLink.create") as mock:
@ -159,7 +179,13 @@ async def test_get_link(app: FastAPI, client: AsyncClient, project: Project, nod
assert response.json()["nodes"][0]["label"]["x"] == 42 assert response.json()["nodes"][0]["label"]["x"] == 42
async def test_update_link_suspend(app: FastAPI, client: AsyncClient, project: Project, nodes: Tuple[Node, Node]) -> None: async def test_update_link_suspend(
self,
app: FastAPI,
client: AsyncClient,
project: Project,
nodes: Tuple[Node, Node]
) -> None:
node1, node2 = nodes node1, node2 = nodes
with asyncio_patch("gns3server.controller.udp_link.UDPLink.create") as mock: with asyncio_patch("gns3server.controller.udp_link.UDPLink.create") as mock:
@ -214,7 +240,13 @@ async def test_update_link_suspend(app: FastAPI, client: AsyncClient, project: P
assert response.json()["filters"] == {} assert response.json()["filters"] == {}
async def test_update_link(app: FastAPI, client: AsyncClient, project: Project, nodes: Tuple[Node, Node]) -> None: async def test_update_link(
self,
app: FastAPI,
client: AsyncClient,
project: Project,
nodes: Tuple[Node, Node]
) -> None:
filters = { filters = {
"latency": [10], "latency": [10],
@ -273,7 +305,13 @@ async def test_update_link(app: FastAPI, client: AsyncClient, project: Project,
assert list(project.links.values())[0].filters == filters assert list(project.links.values())[0].filters == filters
async def test_list_link(app: FastAPI, client: AsyncClient, project: Project, nodes: Tuple[Node, Node]) -> None: async def test_list_link(
self,
app: FastAPI,
client: AsyncClient,
project: Project,
nodes: Tuple[Node, Node]
) -> None:
filters = { filters = {
"latency": [10], "latency": [10],
@ -313,7 +351,7 @@ async def test_list_link(app: FastAPI, client: AsyncClient, project: Project, no
assert response.json()[0]["filters"] == filters assert response.json()[0]["filters"] == filters
async def test_reset_link(app: FastAPI, client: AsyncClient, project: Project) -> None: async def test_reset_link(self, app: FastAPI, client: AsyncClient, project: Project) -> None:
link = UDPLink(project) link = UDPLink(project)
project._links = {link.id: link} project._links = {link.id: link}
@ -325,7 +363,7 @@ async def test_reset_link(app: FastAPI, client: AsyncClient, project: Project) -
assert response.status_code == status.HTTP_200_OK assert response.status_code == status.HTTP_200_OK
async def test_start_capture(app: FastAPI, client: AsyncClient, project: Project) -> None: async def test_start_capture(self, app: FastAPI, client: AsyncClient, project: Project) -> None:
link = Link(project) link = Link(project)
project._links = {link.id: link} project._links = {link.id: link}
@ -335,7 +373,7 @@ async def test_start_capture(app: FastAPI, client: AsyncClient, project: Project
assert response.status_code == status.HTTP_201_CREATED assert response.status_code == status.HTTP_201_CREATED
async def test_stop_capture(app: FastAPI, client: AsyncClient, project: Project) -> None: async def test_stop_capture(self, app: FastAPI, client: AsyncClient, project: Project) -> None:
link = Link(project) link = Link(project)
project._links = {link.id: link} project._links = {link.id: link}
@ -366,7 +404,7 @@ async def test_stop_capture(app: FastAPI, client: AsyncClient, project: Project)
# assert b'hello' == response.body # assert b'hello' == response.body
async def test_delete_link(app: FastAPI, client: AsyncClient, project: Project) -> None: async def test_delete_link(self, app: FastAPI, client: AsyncClient, project: Project) -> None:
link = Link(project) link = Link(project)
project._links = {link.id: link} project._links = {link.id: link}
@ -376,7 +414,7 @@ async def test_delete_link(app: FastAPI, client: AsyncClient, project: Project)
assert response.status_code == status.HTTP_204_NO_CONTENT assert response.status_code == status.HTTP_204_NO_CONTENT
async def test_list_filters(app: FastAPI, client: AsyncClient, project: Project) -> None: async def test_list_filters(self, app: FastAPI, client: AsyncClient, project: Project) -> None:
link = Link(project) link = Link(project)
project._links = {link.id: link} project._links = {link.id: link}

161
tests/api/routes/controller/test_nodes.py
View File

@ -31,15 +31,18 @@ from gns3server.controller.compute import Compute
pytestmark = pytest.mark.asyncio pytestmark = pytest.mark.asyncio
class TestNodeRoutes:
@pytest.fixture @pytest.fixture
def node(project: Project, compute: Compute) -> Node: def node(self, project: Project, compute: Compute) -> Node:
node = Node(project, compute, "test", node_type="vpcs") node = Node(project, compute, "test", node_type="vpcs")
project._nodes[node.id] = node project._nodes[node.id] = node
return node return node
async def test_create_node(app: FastAPI, client: AsyncClient, project: Project, compute: Compute) -> None: async def test_create_node(self, app: FastAPI, client: AsyncClient, project: Project, compute: Compute) -> None:
response = MagicMock() response = MagicMock()
response.json = {"console": 2048} response.json = {"console": 2048}
@ -59,7 +62,7 @@ async def test_create_node(app: FastAPI, client: AsyncClient, project: Project,
assert "name" not in response.json()["properties"] assert "name" not in response.json()["properties"]
async def test_list_node(app: FastAPI, client: AsyncClient, project: Project, compute: Compute) -> None: async def test_list_node(self, app: FastAPI, client: AsyncClient, project: Project, compute: Compute) -> None:
response = MagicMock() response = MagicMock()
response.json = {"console": 2048} response.json = {"console": 2048}
@ -85,7 +88,13 @@ async def test_list_node(app: FastAPI, client: AsyncClient, project: Project, co
assert response.json()[0]["name"] == "test" assert response.json()[0]["name"] == "test"
async def test_get_node(app: FastAPI, client: AsyncClient, project: Project, compute: Compute) -> None: async def test_get_node(
self,
app: FastAPI,
client: AsyncClient,
project: Project,
compute: Compute
) -> None:
response = MagicMock() response = MagicMock()
response.json = {"console": 2048} response.json = {"console": 2048}
@ -105,7 +114,14 @@ async def test_get_node(app: FastAPI, client: AsyncClient, project: Project, com
assert response.json()["name"] == "test" assert response.json()["name"] == "test"
async def test_update_node(app: FastAPI, client: AsyncClient, project: Project, compute: Compute, node: Node) -> None: async def test_update_node(
self,
app: FastAPI,
client: AsyncClient,
project: Project,
compute: Compute,
node: Node
) -> None:
response = MagicMock() response = MagicMock()
response.json = {"console": 2048} response.json = {"console": 2048}
@ -125,76 +141,148 @@ async def test_update_node(app: FastAPI, client: AsyncClient, project: Project,
assert "name" not in response.json()["properties"] assert "name" not in response.json()["properties"]
async def test_start_all_nodes(app: FastAPI, client: AsyncClient, project: Project, compute: Compute) -> None: async def test_start_all_nodes(
self,
app: FastAPI,
client: AsyncClient,
project: Project,
compute: Compute
) -> None:
compute.post = AsyncioMagicMock() compute.post = AsyncioMagicMock()
response = await client.post(app.url_path_for("start_all_nodes", project_id=project.id)) response = await client.post(app.url_path_for("start_all_nodes", project_id=project.id))
assert response.status_code == status.HTTP_204_NO_CONTENT assert response.status_code == status.HTTP_204_NO_CONTENT
async def test_stop_all_nodes(app: FastAPI, client: AsyncClient, project: Project, compute: Compute) -> None: async def test_stop_all_nodes(
self,
app: FastAPI,
client: AsyncClient,
project: Project,
compute: Compute
) -> None:
compute.post = AsyncioMagicMock() compute.post = AsyncioMagicMock()
response = await client.post(app.url_path_for("stop_all_nodes", project_id=project.id)) response = await client.post(app.url_path_for("stop_all_nodes", project_id=project.id))
assert response.status_code == status.HTTP_204_NO_CONTENT assert response.status_code == status.HTTP_204_NO_CONTENT
async def test_suspend_all_nodes(app: FastAPI, client: AsyncClient, project: Project, compute: Compute) -> None: async def test_suspend_all_nodes(
self,
app: FastAPI,
client: AsyncClient,
project: Project,
compute: Compute
) -> None:
compute.post = AsyncioMagicMock() compute.post = AsyncioMagicMock()
response = await client.post(app.url_path_for("suspend_all_nodes", project_id=project.id)) response = await client.post(app.url_path_for("suspend_all_nodes", project_id=project.id))
assert response.status_code == status.HTTP_204_NO_CONTENT assert response.status_code == status.HTTP_204_NO_CONTENT
async def test_reload_all_nodes(app: FastAPI, client: AsyncClient, project: Project, compute: Compute) -> None: async def test_reload_all_nodes(
self,
app: FastAPI,
client: AsyncClient,
project: Project,
compute: Compute
) -> None:
compute.post = AsyncioMagicMock() compute.post = AsyncioMagicMock()
response = await client.post(app.url_path_for("reload_all_nodes", project_id=project.id)) response = await client.post(app.url_path_for("reload_all_nodes", project_id=project.id))
assert response.status_code == status.HTTP_204_NO_CONTENT assert response.status_code == status.HTTP_204_NO_CONTENT
async def test_reset_console_all_nodes(app: FastAPI, client: AsyncClient, project: Project, compute: Compute) -> None: async def test_reset_console_all_nodes(
self,
app: FastAPI,
client: AsyncClient,
project: Project,
compute: Compute
) -> None:
compute.post = AsyncioMagicMock() compute.post = AsyncioMagicMock()
response = await client.post(app.url_path_for("reset_console_all_nodes", project_id=project.id)) 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 assert response.status_code == status.HTTP_204_NO_CONTENT
async def test_start_node(app: FastAPI, client: AsyncClient, project: Project, compute: Compute, node: Node) -> None: async def test_start_node(
self,
app: FastAPI,
client: AsyncClient,
project: Project,
compute: Compute,
node: Node
) -> None:
compute.post = AsyncioMagicMock() compute.post = AsyncioMagicMock()
response = await client.post(app.url_path_for("start_node", project_id=project.id, node_id=node.id), json={}) 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 assert response.status_code == status.HTTP_204_NO_CONTENT
async def test_stop_node(app: FastAPI, client: AsyncClient, project: Project, compute: Compute, node: Node) -> None: async def test_stop_node(
self,
app: FastAPI,
client: AsyncClient,
project: Project,
compute: Compute,
node: Node
) -> None:
compute.post = AsyncioMagicMock() compute.post = AsyncioMagicMock()
response = await client.post(app.url_path_for("stop_node", project_id=project.id, node_id=node.id)) 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 assert response.status_code == status.HTTP_204_NO_CONTENT
async def test_suspend_node(app: FastAPI, client: AsyncClient, project: Project, compute: Compute, node: Node) -> None: async def test_suspend_node(
self,
app: FastAPI,
client: AsyncClient,
project: Project,
compute: Compute,
node: Node
) -> None:
compute.post = AsyncioMagicMock() compute.post = AsyncioMagicMock()
response = await client.post(app.url_path_for("suspend_node", project_id=project.id, node_id=node.id)) 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 assert response.status_code == status.HTTP_204_NO_CONTENT
async def test_reload_node(app: FastAPI, client: AsyncClient, project: Project, compute: Compute, node: Node): async def test_reload_node(
self,
app: FastAPI,
client: AsyncClient,
project: Project,
compute: Compute,
node: Node
):
compute.post = AsyncioMagicMock() compute.post = AsyncioMagicMock()
response = await client.post(app.url_path_for("reload_node", project_id=project.id, node_id=node.id)) 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 assert response.status_code == status.HTTP_204_NO_CONTENT
async def test_isolate_node(app: FastAPI, client: AsyncClient, project: Project, compute: Compute, node: Node): async def test_isolate_node(
self,
app: FastAPI,
client: AsyncClient,
project: Project,
compute: Compute,
node: Node
):
compute.post = AsyncioMagicMock() compute.post = AsyncioMagicMock()
response = await client.post(app.url_path_for("isolate_node", project_id=project.id, node_id=node.id)) response = await client.post(app.url_path_for("isolate_node", project_id=project.id, node_id=node.id))
assert response.status_code == status.HTTP_204_NO_CONTENT assert response.status_code == status.HTTP_204_NO_CONTENT
async def test_unisolate_node(app: FastAPI, client: AsyncClient, project: Project, compute: Compute, node: Node): async def test_unisolate_node(
self,
app: FastAPI,
client: AsyncClient,
project: Project,
compute: Compute,
node: Node
) -> None:
compute.post = AsyncioMagicMock() compute.post = AsyncioMagicMock()
response = await client.post(app.url_path_for("unisolate_node", project_id=project.id, node_id=node.id)) response = await client.post(app.url_path_for("unisolate_node", project_id=project.id, node_id=node.id))
@ -202,11 +290,13 @@ async def test_unisolate_node(app: FastAPI, client: AsyncClient, project: Projec
async def test_duplicate_node( async def test_duplicate_node(
self,
app: FastAPI, app: FastAPI,
client: AsyncClient, client: AsyncClient,
project: Project, project: Project,
compute: Compute, compute: Compute,
node: Node) -> None: node: Node
) -> None:
response = MagicMock() response = MagicMock()
response.json({"console": 2035}) response.json({"console": 2035})
@ -217,7 +307,14 @@ async def test_duplicate_node(
assert response.status_code == status.HTTP_201_CREATED assert response.status_code == status.HTTP_201_CREATED
async def test_delete_node(app: FastAPI, client: AsyncClient, project: Project, compute: Compute, node: Node) -> None: async def test_delete_node(
self,
app: FastAPI,
client: AsyncClient,
project: Project,
compute: Compute,
node: Node
) -> None:
compute.post = AsyncioMagicMock() compute.post = AsyncioMagicMock()
response = await client.delete(app.url_path_for("delete_node", project_id=project.id, node_id=node.id)) response = await client.delete(app.url_path_for("delete_node", project_id=project.id, node_id=node.id))
@ -225,6 +322,7 @@ async def test_delete_node(app: FastAPI, client: AsyncClient, project: Project,
async def test_dynamips_idle_pc( async def test_dynamips_idle_pc(
self,
app: FastAPI, app: FastAPI,
client: AsyncClient, client: AsyncClient,
project: Project, project: Project,
@ -243,6 +341,7 @@ async def test_dynamips_idle_pc(
async def test_dynamips_idle_pc_wrong_node_type( async def test_dynamips_idle_pc_wrong_node_type(
self,
app: FastAPI, app: FastAPI,
client: AsyncClient, client: AsyncClient,
project: Project, project: Project,
@ -255,6 +354,7 @@ async def test_dynamips_idle_pc_wrong_node_type(
async def test_dynamips_idlepc_proposals( async def test_dynamips_idlepc_proposals(
self,
app: FastAPI, app: FastAPI,
client: AsyncClient, client: AsyncClient,
project: Project, project: Project,
@ -273,6 +373,7 @@ async def test_dynamips_idlepc_proposals(
async def test_dynamips_idlepc_proposals_wrong_node_type( async def test_dynamips_idlepc_proposals_wrong_node_type(
self,
app: FastAPI, app: FastAPI,
client: AsyncClient, client: AsyncClient,
project: Project, project: Project,
@ -285,6 +386,7 @@ async def test_dynamips_idlepc_proposals_wrong_node_type(
async def test_qemu_disk_image_create( async def test_qemu_disk_image_create(
self,
app: FastAPI, app: FastAPI,
client: AsyncClient, client: AsyncClient,
project: Project, project: Project,
@ -304,6 +406,7 @@ async def test_qemu_disk_image_create(
async def test_qemu_disk_image_create_wrong_node_type( async def test_qemu_disk_image_create_wrong_node_type(
self,
app: FastAPI, app: FastAPI,
client: AsyncClient, client: AsyncClient,
project: Project, project: Project,
@ -319,6 +422,7 @@ async def test_qemu_disk_image_create_wrong_node_type(
async def test_qemu_disk_image_update( async def test_qemu_disk_image_update(
self,
app: FastAPI, app: FastAPI,
client: AsyncClient, client: AsyncClient,
project: Project, project: Project,
@ -338,6 +442,7 @@ async def test_qemu_disk_image_update(
async def test_qemu_disk_image_update_wrong_node_type( async def test_qemu_disk_image_update_wrong_node_type(
self,
app: FastAPI, app: FastAPI,
client: AsyncClient, client: AsyncClient,
project: Project, project: Project,
@ -353,6 +458,7 @@ async def test_qemu_disk_image_update_wrong_node_type(
async def test_qemu_disk_image_delete( async def test_qemu_disk_image_delete(
self,
app: FastAPI, app: FastAPI,
client: AsyncClient, client: AsyncClient,
project: Project, project: Project,
@ -371,6 +477,7 @@ async def test_qemu_disk_image_delete(
async def test_qemu_disk_image_delete_wrong_node_type( async def test_qemu_disk_image_delete_wrong_node_type(
self,
app: FastAPI, app: FastAPI,
client: AsyncClient, client: AsyncClient,
project: Project, project: Project,
@ -384,7 +491,14 @@ async def test_qemu_disk_image_delete_wrong_node_type(
assert response.status_code == status.HTTP_400_BAD_REQUEST assert response.status_code == status.HTTP_400_BAD_REQUEST
async def test_get_file(app: FastAPI, client: AsyncClient, project: Project, compute: Compute, node: Node) -> None: async def test_get_file(
self,
app: FastAPI,
client: AsyncClient,
project: Project,
compute: Compute,
node: Node
) -> None:
response = MagicMock() response = MagicMock()
response.body = b"world" response.body = b"world"
@ -411,7 +525,14 @@ async def test_get_file(app: FastAPI, client: AsyncClient, project: Project, com
assert response.status_code == status.HTTP_404_NOT_FOUND assert response.status_code == status.HTTP_404_NOT_FOUND
async def test_post_file(app: FastAPI, client: AsyncClient, project: Project, compute: Compute, node: Node) -> None: async def test_post_file(
self,
app: FastAPI,
client: AsyncClient,
project: Project,
compute: Compute,
node: Node
) -> None:
compute.http_query = AsyncioMagicMock() compute.http_query = AsyncioMagicMock()
response = await client.post(app.url_path_for( response = await client.post(app.url_path_for(

103
tests/api/routes/controller/test_projects.py
View File

@ -34,8 +34,10 @@ from gns3server.controller.compute import Compute
pytestmark = pytest.mark.asyncio pytestmark = pytest.mark.asyncio
class TestControllerProjectRoutes:
@pytest_asyncio.fixture @pytest_asyncio.fixture
async def project(app: FastAPI, client: AsyncClient, controller: Controller) -> Project: async def project(self, app: FastAPI, client: AsyncClient, controller: Controller) -> Project:
project_id = str(uuid.uuid4()) project_id = str(uuid.uuid4())
params = {"name": "test", "project_id": project_id} params = {"name": "test", "project_id": project_id}
@ -43,7 +45,13 @@ async def project(app: FastAPI, client: AsyncClient, controller: Controller) ->
return controller.get_project(project_id) return controller.get_project(project_id)
async def test_create_project_with_path(app: FastAPI, client: AsyncClient, controller: Controller, config) -> None: async def test_create_project_with_path(
self,
app: FastAPI,
client: AsyncClient,
controller: Controller,
config
) -> None:
params = {"name": "test", "path": str(config.settings.Server.projects_path), "project_id": "00010203-0405-0607-0809-0a0b0c0d0e0f"} params = {"name": "test", "path": str(config.settings.Server.projects_path), "project_id": "00010203-0405-0607-0809-0a0b0c0d0e0f"}
response = await client.post(app.url_path_for("create_project"), json=params) response = await client.post(app.url_path_for("create_project"), json=params)
@ -53,7 +61,12 @@ async def test_create_project_with_path(app: FastAPI, client: AsyncClient, contr
assert response.json()["status"] == "opened" assert response.json()["status"] == "opened"
async def test_create_project_without_dir(app: FastAPI, client: AsyncClient, controller: Controller) -> None: async def test_create_project_without_dir(
self,
app: FastAPI,
client: AsyncClient,
controller: Controller
) -> None:
params = {"name": "test", "project_id": "10010203-0405-0607-0809-0a0b0c0d0e0f"} params = {"name": "test", "project_id": "10010203-0405-0607-0809-0a0b0c0d0e0f"}
response = await client.post(app.url_path_for("create_project"), json=params) response = await client.post(app.url_path_for("create_project"), json=params)
@ -62,7 +75,12 @@ async def test_create_project_without_dir(app: FastAPI, client: AsyncClient, con
assert response.json()["name"] == "test" assert response.json()["name"] == "test"
async def test_create_project_with_uuid(app: FastAPI, client: AsyncClient, controller: Controller) -> None: async def test_create_project_with_uuid(
self,
app: FastAPI,
client: AsyncClient,
controller: Controller
) -> None:
params = {"name": "test", "project_id": "30010203-0405-0607-0809-0a0b0c0d0e0f"} params = {"name": "test", "project_id": "30010203-0405-0607-0809-0a0b0c0d0e0f"}
response = await client.post(app.url_path_for("create_project"), json=params) response = await client.post(app.url_path_for("create_project"), json=params)
@ -71,7 +89,12 @@ async def test_create_project_with_uuid(app: FastAPI, client: AsyncClient, contr
assert response.json()["name"] == "test" assert response.json()["name"] == "test"
async def test_create_project_with_variables(app: FastAPI, client: AsyncClient, controller: Controller) -> None: async def test_create_project_with_variables(
self,
app: FastAPI,
client: AsyncClient,
controller: Controller
) -> None:
variables = [ variables = [
{"name": "TEST1"}, {"name": "TEST1"},
@ -86,7 +109,12 @@ async def test_create_project_with_variables(app: FastAPI, client: AsyncClient,
] ]
async def test_create_project_with_supplier(app: FastAPI, client: AsyncClient, controller: Controller) -> None: async def test_create_project_with_supplier(
self,
app: FastAPI,
client: AsyncClient,
controller: Controller
) -> None:
supplier = { supplier = {
'logo': 'logo.png', 'logo': 'logo.png',
@ -98,7 +126,7 @@ async def test_create_project_with_supplier(app: FastAPI, client: AsyncClient, c
assert response.json()["supplier"] == supplier assert response.json()["supplier"] == supplier
async def test_update_project(app: FastAPI, client: AsyncClient, controller: Controller) -> None: async def test_update_project(self, app: FastAPI, client: AsyncClient, controller: Controller) -> None:
params = {"name": "test", "project_id": "10010203-0405-0607-0809-0a0b0c0d0e0f"} params = {"name": "test", "project_id": "10010203-0405-0607-0809-0a0b0c0d0e0f"}
response = await client.post(app.url_path_for("create_project"), json=params) response = await client.post(app.url_path_for("create_project"), json=params)
@ -113,7 +141,12 @@ async def test_update_project(app: FastAPI, client: AsyncClient, controller: Con
assert response.json()["name"] == "test2" assert response.json()["name"] == "test2"
async def test_update_project_with_variables(app: FastAPI, client: AsyncClient, controller: Controller) -> None: async def test_update_project_with_variables(
self,
app: FastAPI,
client: AsyncClient,
controller: Controller
) -> None:
variables = [ variables = [
{"name": "TEST1"}, {"name": "TEST1"},
@ -130,7 +163,7 @@ async def test_update_project_with_variables(app: FastAPI, client: AsyncClient,
assert response.json()["variables"] == variables assert response.json()["variables"] == variables
async def test_list_projects(app: FastAPI, client: AsyncClient, controller: Controller) -> None: async def test_list_projects(self, app: FastAPI, client: AsyncClient, controller: Controller) -> None:
params = {"name": "test", "project_id": "00010203-0405-0607-0809-0a0b0c0d0e0f"} params = {"name": "test", "project_id": "00010203-0405-0607-0809-0a0b0c0d0e0f"}
await client.post(app.url_path_for("create_project"), json=params) await client.post(app.url_path_for("create_project"), json=params)
@ -140,14 +173,20 @@ async def test_list_projects(app: FastAPI, client: AsyncClient, controller: Cont
assert projects[0]["name"] == "test" assert projects[0]["name"] == "test"
async def test_get_project(app: FastAPI, client: AsyncClient, project: Project) -> None: async def test_get_project(self, app: FastAPI, client: AsyncClient, project: Project) -> None:
response = await client.get(app.url_path_for("get_project", project_id=project.id)) response = await client.get(app.url_path_for("get_project", project_id=project.id))
assert response.status_code == status.HTTP_200_OK assert response.status_code == status.HTTP_200_OK
assert response.json()["name"] == "test" assert response.json()["name"] == "test"
async def test_delete_project(app: FastAPI, client: AsyncClient, project: Project, controller: Controller) -> None: async def test_delete_project(
self,
app: FastAPI,
client: AsyncClient,
project: Project,
controller: Controller
) -> None:
with asyncio_patch("gns3server.controller.project.Project.delete", return_value=True) as mock: with asyncio_patch("gns3server.controller.project.Project.delete", return_value=True) as mock:
response = await client.delete(app.url_path_for("delete_project", project_id=project.id)) response = await client.delete(app.url_path_for("delete_project", project_id=project.id))
@ -156,13 +195,13 @@ async def test_delete_project(app: FastAPI, client: AsyncClient, project: Projec
assert project not in controller.projects assert project not in controller.projects
async def test_delete_project_invalid_uuid(app: FastAPI, client: AsyncClient) -> None: async def test_delete_project_invalid_uuid(self, app: FastAPI, client: AsyncClient) -> None:
response = await client.delete(app.url_path_for("delete_project", project_id=str(uuid.uuid4()))) response = await client.delete(app.url_path_for("delete_project", project_id=str(uuid.uuid4())))
assert response.status_code == status.HTTP_404_NOT_FOUND assert response.status_code == status.HTTP_404_NOT_FOUND
async def test_close_project(app: FastAPI, client: AsyncClient, project: Project) -> None: async def test_close_project(self, app: FastAPI, client: AsyncClient, project: Project) -> None:
with asyncio_patch("gns3server.controller.project.Project.close", return_value=True) as mock: with asyncio_patch("gns3server.controller.project.Project.close", return_value=True) as mock:
response = await client.post(app.url_path_for("close_project", project_id=project.id)) response = await client.post(app.url_path_for("close_project", project_id=project.id))
@ -170,7 +209,7 @@ async def test_close_project(app: FastAPI, client: AsyncClient, project: Project
assert mock.called assert mock.called
async def test_open_project(app: FastAPI, client: AsyncClient, project: Project) -> None: async def test_open_project(self, app: FastAPI, client: AsyncClient, project: Project) -> None:
with asyncio_patch("gns3server.controller.project.Project.open", return_value=True) as mock: with asyncio_patch("gns3server.controller.project.Project.open", return_value=True) as mock:
response = await client.post(app.url_path_for("open_project", project_id=project.id)) response = await client.post(app.url_path_for("open_project", project_id=project.id))
@ -178,7 +217,7 @@ async def test_open_project(app: FastAPI, client: AsyncClient, project: Project)
assert mock.called assert mock.called
async def test_load_project(app: FastAPI, client: AsyncClient, project: Project, config) -> None: async def test_load_project(self, app: FastAPI, client: AsyncClient, project: Project, config) -> None:
with asyncio_patch("gns3server.controller.Controller.load_project", return_value=project) as mock: with asyncio_patch("gns3server.controller.Controller.load_project", return_value=project) as mock:
response = await client.post(app.url_path_for("load_project"), json={"path": "/tmp/test.gns3"}) response = await client.post(app.url_path_for("load_project"), json={"path": "/tmp/test.gns3"})
@ -227,7 +266,13 @@ async def test_load_project(app: FastAPI, client: AsyncClient, project: Project,
# assert project.status_code == "opened" # assert project.status_code == "opened"
async def test_export_with_images(app: FastAPI, client: AsyncClient, tmpdir, project: Project) -> None: async def test_export_with_images(
self,
app: FastAPI,
client: AsyncClient,
tmpdir,
project: Project
) -> None:
project.dump = MagicMock() project.dump = MagicMock()
os.makedirs(project.path, exist_ok=True) os.makedirs(project.path, exist_ok=True)
@ -270,7 +315,7 @@ async def test_export_with_images(app: FastAPI, client: AsyncClient, tmpdir, pro
myzip.getinfo("images/IOS/test.image") myzip.getinfo("images/IOS/test.image")
async def test_export_without_images(app: FastAPI, client: AsyncClient, tmpdir, project: Project) -> None: async def test_export_without_images(self, app: FastAPI, client: AsyncClient, tmpdir, project: Project) -> None:
project.dump = MagicMock() project.dump = MagicMock()
os.makedirs(project.path, exist_ok=True) os.makedirs(project.path, exist_ok=True)
@ -334,6 +379,7 @@ async def test_export_without_images(app: FastAPI, client: AsyncClient, tmpdir,
) )
) )
async def test_export_compression( async def test_export_compression(
self,
app: FastAPI, app: FastAPI,
client: AsyncClient, client: AsyncClient,
tmpdir, tmpdir,
@ -376,7 +422,7 @@ async def test_export_compression(
myfile.read() myfile.read()
async def test_get_file(app: FastAPI, client: AsyncClient, project: Project) -> None: async def test_get_file(self, app: FastAPI, client: AsyncClient, project: Project) -> None:
os.makedirs(project.path, exist_ok=True) os.makedirs(project.path, exist_ok=True)
with open(os.path.join(project.path, 'hello'), 'w+') as f: with open(os.path.join(project.path, 'hello'), 'w+') as f:
@ -393,14 +439,14 @@ async def test_get_file(app: FastAPI, client: AsyncClient, project: Project) ->
assert response.status_code == status.HTTP_404_NOT_FOUND assert response.status_code == status.HTTP_404_NOT_FOUND
async def test_get_file_forbidden_location(app: FastAPI, client: AsyncClient, project: Project) -> None: async def test_get_file_forbidden_location(self, app: FastAPI, client: AsyncClient, project: Project) -> None:
file_path = "foo/%2e%2e/%2e%2e/%2e%2e/%2e%2e/%2e%2e/%2e%2e/etc/passwd" file_path = "foo/%2e%2e/%2e%2e/%2e%2e/%2e%2e/%2e%2e/%2e%2e/etc/passwd"
response = await client.get(app.url_path_for("get_file", project_id=project.id, file_path=file_path)) response = await client.get(app.url_path_for("get_file", project_id=project.id, file_path=file_path))
assert response.status_code == status.HTTP_403_FORBIDDEN assert response.status_code == status.HTTP_403_FORBIDDEN
async def test_write_file(app: FastAPI, client: AsyncClient, project: Project) -> None: async def test_write_file(self, app: FastAPI, client: AsyncClient, project: Project) -> None:
response = await client.post(app.url_path_for("write_file", project_id=project.id, file_path="hello"), response = await client.post(app.url_path_for("write_file", project_id=project.id, file_path="hello"),
content=b"world") content=b"world")
@ -413,7 +459,7 @@ async def test_write_file(app: FastAPI, client: AsyncClient, project: Project) -
assert response.status_code == status.HTTP_404_NOT_FOUND assert response.status_code == status.HTTP_404_NOT_FOUND
async def test_write_file_forbidden_location(app: FastAPI, client: AsyncClient, project: Project) -> None: async def test_write_file_forbidden_location(self, app: FastAPI, client: AsyncClient, project: Project) -> None:
file_path = "%2e%2e/hello" file_path = "%2e%2e/hello"
response = await client.post(app.url_path_for("write_file", project_id=project.id, file_path=file_path), response = await client.post(app.url_path_for("write_file", project_id=project.id, file_path=file_path),
@ -422,6 +468,7 @@ async def test_write_file_forbidden_location(app: FastAPI, client: AsyncClient,
async def test_write_and_get_file_with_leading_slashes_in_filename( async def test_write_and_get_file_with_leading_slashes_in_filename(
self,
app: FastAPI, app: FastAPI,
client: AsyncClient, client: AsyncClient,
project: Project) -> None: project: Project) -> None:
@ -434,7 +481,7 @@ async def test_write_and_get_file_with_leading_slashes_in_filename(
assert response.status_code == status.HTTP_403_FORBIDDEN assert response.status_code == status.HTTP_403_FORBIDDEN
async def test_import(app: FastAPI, client: AsyncClient, tmpdir, controller: Controller) -> None: async def test_import(self, app: FastAPI, client: AsyncClient, tmpdir, controller: Controller) -> None:
with zipfile_zstd.ZipFile(str(tmpdir / "test.zip"), 'w') as myzip: with zipfile_zstd.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"}') myzip.writestr("project.gns3", b'{"project_id": "c6992992-ac72-47dc-833b-54aa334bcd05", "version": "2.0.0", "name": "test"}')
@ -451,7 +498,13 @@ async def test_import(app: FastAPI, client: AsyncClient, tmpdir, controller: Con
assert content == "hello" assert content == "hello"
async def test_import_with_project_name(app: FastAPI, client: AsyncClient, tmpdir, controller: Controller) -> None: async def test_import_with_project_name(
self,
app: FastAPI,
client: AsyncClient,
tmpdir,
controller: Controller
) -> None:
with zipfile_zstd.ZipFile(str(tmpdir / "test.zip"), 'w') as myzip: with zipfile_zstd.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"}') myzip.writestr("project.gns3", b'{"project_id": "c6992992-ac72-47dc-833b-54aa334bcd05", "version": "2.0.0", "name": "test"}')
@ -469,14 +522,14 @@ async def test_import_with_project_name(app: FastAPI, client: AsyncClient, tmpdi
assert project.name == "my-imported-project-name" assert project.name == "my-imported-project-name"
async def test_duplicate(app: FastAPI, client: AsyncClient, project: Project) -> None: async def test_duplicate(self, app: FastAPI, client: AsyncClient, project: Project) -> None:
response = await client.post(app.url_path_for("duplicate_project", project_id=project.id), 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.status_code == status.HTTP_201_CREATED
assert response.json()["name"] == "hello" assert response.json()["name"] == "hello"
async def test_lock_unlock(app: FastAPI, client: AsyncClient, project: Project, compute: Compute) -> None: async def test_lock_unlock(self, app: FastAPI, client: AsyncClient, project: Project, compute: Compute) -> None:
# add a drawing and node to the project # add a drawing and node to the project
params = { params = {

22
tests/api/routes/controller/test_snapshots.py
View File

@ -30,24 +30,26 @@ from gns3server.controller.snapshot import Snapshot
pytestmark = pytest.mark.asyncio pytestmark = pytest.mark.asyncio
class TestSnapshotRoutes:
@pytest_asyncio.fixture @pytest_asyncio.fixture
async def project(app: FastAPI, client: AsyncClient, controller: Controller) -> Project: async def project(self, app: FastAPI, client: AsyncClient, controller: Controller) -> Project:
u = str(uuid.uuid4()) u = str(uuid.uuid4())
params = {"name": "test", "project_id": u} params = {"name": "test", "project_id": u}
await client.post(app.url_path_for("create_project"), json=params) await client.post(app.url_path_for("create_project"), json=params)
project = controller.get_project(u) controller_project = controller.get_project(u)
return project return controller_project
@pytest_asyncio.fixture @pytest_asyncio.fixture
async def snapshot(project: Project): async def snapshot(self, project: Project):
snapshot = await project.snapshot("test") controller_snapshot = await project.snapshot("test")
return snapshot return controller_snapshot
async def test_list_snapshots(app: FastAPI, client: AsyncClient, project: Project, snapshot: Snapshot) -> None: async def test_list_snapshots(self, app: FastAPI, client: AsyncClient, project: Project, snapshot: Snapshot) -> None:
assert snapshot.name == "test" assert snapshot.name == "test"
response = await client.get(app.url_path_for("get_snapshots", project_id=project.id)) response = await client.get(app.url_path_for("get_snapshots", project_id=project.id))
@ -55,21 +57,21 @@ async def test_list_snapshots(app: FastAPI, client: AsyncClient, project: Projec
assert len(response.json()) == 1 assert len(response.json()) == 1
async def test_delete_snapshot(app: FastAPI, client: AsyncClient, project: Project, snapshot: Snapshot) -> None: async def test_delete_snapshot(self, app: FastAPI, client: AsyncClient, project: Project, snapshot: Snapshot) -> None:
response = await client.delete(app.url_path_for("delete_snapshot", project_id=project.id, snapshot_id=snapshot.id)) 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 response.status_code == status.HTTP_204_NO_CONTENT
assert not os.path.exists(snapshot.path) assert not os.path.exists(snapshot.path)
async def test_restore_snapshot(app: FastAPI, client: AsyncClient, project: Project, snapshot: Snapshot) -> None: async def test_restore_snapshot(self, app: FastAPI, client: AsyncClient, project: Project, snapshot: Snapshot) -> None:
response = await client.post(app.url_path_for("restore_snapshot", project_id=project.id, snapshot_id=snapshot.id)) 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.status_code == status.HTTP_201_CREATED
assert response.json()["name"] == project.name assert response.json()["name"] == project.name
async def test_create_snapshot(app: FastAPI, client: AsyncClient, project: Project) -> None: async def test_create_snapshot(self, app: FastAPI, client: AsyncClient, project: Project) -> None:
response = await client.post(app.url_path_for("create_snapshot", project_id=project.id), json={"name": "snap1"}) 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 response.status_code == status.HTTP_201_CREATED

8
tests/api/routes/controller/test_symbols.py
View File

@ -28,7 +28,9 @@ from gns3server.controller import Controller
pytestmark = pytest.mark.asyncio pytestmark = pytest.mark.asyncio
async def test_symbols(app: FastAPI, client: AsyncClient) -> None: class TestSymbolRoutes:
async def test_symbols(self, app: FastAPI, client: AsyncClient) -> None:
response = await client.get(app.url_path_for("get_symbols")) response = await client.get(app.url_path_for("get_symbols"))
@ -41,7 +43,7 @@ async def test_symbols(app: FastAPI, client: AsyncClient) -> None:
} in response.json() } in response.json()
async def test_get(app: FastAPI, client: AsyncClient, controller: Controller) -> None: async def test_get(self, app: FastAPI, client: AsyncClient, controller: Controller) -> None:
controller.symbols.theme = "Classic" controller.symbols.theme = "Classic"
url = app.url_path_for("get_symbol", symbol_id=urllib.parse.quote(':/symbols/classic/firewall.svg')) url = app.url_path_for("get_symbol", symbol_id=urllib.parse.quote(':/symbols/classic/firewall.svg'))
@ -56,7 +58,7 @@ async def test_get(app: FastAPI, client: AsyncClient, controller: Controller) ->
assert response.status_code == status.HTTP_200_OK assert response.status_code == status.HTTP_200_OK
async def test_upload(app: FastAPI, client: AsyncClient, symbols_dir: str) -> None: async def test_upload(self, app: FastAPI, client: AsyncClient, symbols_dir: str) -> None:
response = await client.post(app.url_path_for("upload_symbol", symbol_id="test2"), content=b"TEST") 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 assert response.status_code == status.HTTP_204_NO_CONTENT

44
tests/api/routes/controller/test_users.py
View File

@ -254,22 +254,6 @@ class TestUserLogin:
assert "token_type" in response.json() assert "token_type" in response.json()
assert response.json().get("token_type") == "bearer" assert response.json().get("token_type") == "bearer"
async def test_user_can_authenticate_using_json(
self,
app: FastAPI,
unauthorized_client: AsyncClient,
test_user: User,
config: Config
) -> None:
credentials = {
"username": test_user.username,
"password": "user1_password",
}
response = await unauthorized_client.post(app.url_path_for("authenticate"), json=credentials)
assert response.status_code == status.HTTP_200_OK
assert response.json().get("access_token")
@pytest.mark.parametrize( @pytest.mark.parametrize(
"username, password, status_code", "username, password, status_code",
( (
@ -299,7 +283,19 @@ class TestUserLogin:
assert response.status_code == status_code assert response.status_code == status_code
assert "access_token" not in response.json() assert "access_token" not in response.json()
async def test_user_can_use_token_as_url_param(
class TestUnauthorizedUser:
async def test_user_cannot_access_own_data_if_not_authenticated(
self, app: FastAPI,
unauthorized_client: AsyncClient,
test_user: User,
) -> None:
response = await unauthorized_client.get(app.url_path_for("get_logged_in_user"))
assert response.status_code == status.HTTP_401_UNAUTHORIZED
async def test_user_can_authenticate_using_json(
self, self,
app: FastAPI, app: FastAPI,
unauthorized_client: AsyncClient, unauthorized_client: AsyncClient,
@ -311,15 +307,14 @@ class TestUserLogin:
"username": test_user.username, "username": test_user.username,
"password": "user1_password", "password": "user1_password",
} }
response = await unauthorized_client.post(app.url_path_for("authenticate"), json=credentials) response = await unauthorized_client.post(app.url_path_for("authenticate"), json=credentials)
assert response.status_code == status.HTTP_200_OK assert response.status_code == status.HTTP_200_OK
token = response.json().get("access_token") assert response.json().get("access_token")
token = response.json().get("access_token")
response = await unauthorized_client.get(app.url_path_for("statistics"), params={"token": token}) response = await unauthorized_client.get(app.url_path_for("statistics"), params={"token": token})
assert response.status_code == status.HTTP_200_OK assert response.status_code == status.HTTP_200_OK
class TestUserMe: class TestUserMe:
async def test_authenticated_user_can_retrieve_own_data( async def test_authenticated_user_can_retrieve_own_data(
@ -336,15 +331,6 @@ class TestUserMe:
assert user.email == test_user.email assert user.email == test_user.email
assert user.user_id == test_user.user_id assert user.user_id == test_user.user_id
async def test_user_cannot_access_own_data_if_not_authenticated(
self, app: FastAPI,
unauthorized_client: AsyncClient,
test_user: User,
) -> None:
response = await unauthorized_client.get(app.url_path_for("get_logged_in_user"))
assert response.status_code == status.HTTP_401_UNAUTHORIZED
async def test_authenticated_user_can_update_own_data( async def test_authenticated_user_can_update_own_data(
self, self,
app: FastAPI, app: FastAPI,

13
tests/api/routes/controller/test_version.py
View File

@ -25,14 +25,17 @@ from gns3server.version import __version__
pytestmark = pytest.mark.asyncio pytestmark = pytest.mark.asyncio
async def test_version_output(app: FastAPI, client: AsyncClient) -> None: class TestVersionRoutes:
async def test_version_output(self, app: FastAPI, client: AsyncClient) -> None:
response = await client.get(app.url_path_for("get_version")) response = await client.get(app.url_path_for("get_version"))
assert response.status_code == status.HTTP_200_OK assert response.status_code == status.HTTP_200_OK
assert response.json() == {'controller_host': '127.0.0.1', 'local': False, 'version': __version__} assert response.json() == {'controller_host': '127.0.0.1', 'local': False, 'version': __version__}
async def test_version_input(app: FastAPI, client: AsyncClient) -> None: async def test_version_input(self, app: FastAPI, client: AsyncClient) -> None:
params = {'version': __version__} params = {'version': __version__}
response = await client.post(app.url_path_for("check_version"), json=params) response = await client.post(app.url_path_for("check_version"), json=params)
@ -40,7 +43,7 @@ async def test_version_input(app: FastAPI, client: AsyncClient) -> None:
assert response.json() == {'version': __version__} assert response.json() == {'version': __version__}
async def test_version_invalid_input(app: FastAPI, client: AsyncClient) -> None: async def test_version_invalid_input(self, app: FastAPI, client: AsyncClient) -> None:
params = {'version': "0.4.2"} params = {'version': "0.4.2"}
response = await client.post(app.url_path_for("check_version"), json=params) response = await client.post(app.url_path_for("check_version"), json=params)
@ -48,14 +51,14 @@ async def test_version_invalid_input(app: FastAPI, client: AsyncClient) -> None:
assert response.json() == {'message': 'Client version 0.4.2 is not the same as server version {}'.format(__version__)} assert response.json() == {'message': 'Client version 0.4.2 is not the same as server version {}'.format(__version__)}
async def test_version_invalid_input_schema(app: FastAPI, client: AsyncClient) -> None: async def test_version_invalid_input_schema(self, app: FastAPI, client: AsyncClient) -> None:
params = {'version': "0.4.2", "bla": "blu"} params = {'version': "0.4.2", "bla": "blu"}
response = await client.post(app.url_path_for("check_version"), json=params) response = await client.post(app.url_path_for("check_version"), json=params)
assert response.status_code == status.HTTP_409_CONFLICT assert response.status_code == status.HTTP_409_CONFLICT
async def test_version_invalid_json(app: FastAPI, client: AsyncClient) -> None: async def test_version_invalid_json(self, app: FastAPI, client: AsyncClient) -> None:
params = "BOUM" params = "BOUM"
response = await client.post(app.url_path_for("check_version"), json=params) response = await client.post(app.url_path_for("check_version"), json=params)

10
tests/api/routes/test_index.py
View File

@ -29,13 +29,15 @@ from gns3server.utils.get_resource import get_resource
pytestmark = pytest.mark.asyncio pytestmark = pytest.mark.asyncio
def get_static(filename): class TestIndexRoutes:
def get_static(self, filename):
current_dir = os.path.dirname(os.path.abspath(__file__)) current_dir = os.path.dirname(os.path.abspath(__file__))
return os.path.join(os.path.abspath(os.path.join(current_dir, '../..', '..', 'gns3server', 'static')), filename) return os.path.join(os.path.abspath(os.path.join(current_dir, '../..', '..', 'gns3server', 'static')), filename)
async def test_debug(app: FastAPI, client: AsyncClient) -> None: async def test_debug(self, app: FastAPI, client: AsyncClient) -> None:
response = await client.get(app.url_path_for("debug")) response = await client.get(app.url_path_for("debug"))
assert response.status_code == status.HTTP_200_OK assert response.status_code == status.HTTP_200_OK
@ -68,13 +70,13 @@ async def test_debug(app: FastAPI, client: AsyncClient) -> None:
# assert response.status_code == 200 # assert response.status_code == 200
async def test_web_ui(app: FastAPI, client: AsyncClient) -> None: async def test_web_ui(self, app: FastAPI, client: AsyncClient) -> None:
response = await client.get(app.url_path_for("web_ui", file_path="index.html")) response = await client.get(app.url_path_for("web_ui", file_path="index.html"))
assert response.status_code == status.HTTP_200_OK assert response.status_code == status.HTTP_200_OK
async def test_web_ui_not_found(app: FastAPI, client: AsyncClient, tmpdir: str) -> None: async def test_web_ui_not_found(self, app: FastAPI, client: AsyncClient, tmpdir: str) -> None:
with patch('gns3server.utils.get_resource.get_resource') as mock: with patch('gns3server.utils.get_resource.get_resource') as mock:
mock.return_value = str(tmpdir) mock.return_value = str(tmpdir)

17
tests/api/routes/test_routes.py
View File

@ -44,9 +44,14 @@ ALLOWED_CONTROLLER_ENDPOINTS = [
("/v3/symbols/default_symbols", "GET") ("/v3/symbols/default_symbols", "GET")
] ]
class TestRoutes:
# Controller endpoints have a OAuth2 bearer token authentication # Controller endpoints have a OAuth2 bearer token authentication
async def test_controller_endpoints_require_authentication(app: FastAPI, unauthorized_client: AsyncClient) -> None: async def test_controller_endpoints_require_authentication(
self,
app: FastAPI,
unauthorized_client: AsyncClient
) -> None:
for route in app.routes: for route in app.routes:
if isinstance(route, APIRoute): if isinstance(route, APIRoute):
@ -56,7 +61,7 @@ async def test_controller_endpoints_require_authentication(app: FastAPI, unautho
assert response.status_code == status.HTTP_401_UNAUTHORIZED assert response.status_code == status.HTTP_401_UNAUTHORIZED
elif isinstance(route, APIWebSocketRoute): elif isinstance(route, APIWebSocketRoute):
params = {"token": "wrong_token"} params = {"token": "wrong_token"}
async with AsyncClient(base_url="http://test-api", transport=ASGIWebSocketTransport(app)) as client: async with AsyncClient(base_url="http://test-api", transport=ASGIWebSocketTransport(app=app)) as client:
async with aconnect_ws(route.path, client, params=params) as ws: async with aconnect_ws(route.path, client, params=params) as ws:
json_notification = await ws.receive_json() json_notification = await ws.receive_json()
assert json_notification['event'] == { assert json_notification['event'] == {
@ -65,7 +70,11 @@ async def test_controller_endpoints_require_authentication(app: FastAPI, unautho
# Compute endpoints have a basic HTTP authentication # Compute endpoints have a basic HTTP authentication
async def test_compute_endpoints_require_authentication(app: FastAPI, unauthorized_client: AsyncClient) -> None: async def test_compute_endpoints_require_authentication(
self,
app: FastAPI,
unauthorized_client: AsyncClient
) -> None:
for route in app.routes: for route in app.routes:
if isinstance(route, Mount): if isinstance(route, Mount):
@ -75,7 +84,7 @@ async def test_compute_endpoints_require_authentication(app: FastAPI, unauthoriz
response = await getattr(unauthorized_client, method.lower())(route.path + compute_route.path) response = await getattr(unauthorized_client, method.lower())(route.path + compute_route.path)
assert response.status_code == status.HTTP_401_UNAUTHORIZED assert response.status_code == status.HTTP_401_UNAUTHORIZED
elif isinstance(compute_route, APIWebSocketRoute): elif isinstance(compute_route, APIWebSocketRoute):
async with AsyncClient(base_url="http://test-api", transport=ASGIWebSocketTransport(app)) as client: async with AsyncClient(base_url="http://test-api", transport=ASGIWebSocketTransport(app=app)) as client:
async with aconnect_ws(route.path + compute_route.path, client, auth=("wrong_user", "password123")) as ws: async with aconnect_ws(route.path + compute_route.path, client, auth=("wrong_user", "password123")) as ws:
json_notification = await ws.receive_json() json_notification = await ws.receive_json()
assert json_notification['event'] == { assert json_notification['event'] == {

8
tests/compute/builtin/nodes/test_cloud.py
View File

@ -25,6 +25,8 @@ from gns3server.compute.nios.nio_udp import NIOUDP
from tests.utils import asyncio_patch from tests.utils import asyncio_patch
pytestmark = pytest.mark.asyncio
@pytest.fixture @pytest.fixture
def nio(): def nio():
@ -39,7 +41,6 @@ async def manager():
return m return m
@pytest.mark.asyncio
async def test_json_with_ports(on_gns3vm, compute_project, manager): async def test_json_with_ports(on_gns3vm, compute_project, manager):
ports = [ ports = [
@ -78,7 +79,7 @@ async def test_json_with_ports(on_gns3vm, compute_project, manager):
} }
def test_json_without_ports(on_gns3vm, compute_project, manager): async def test_json_without_ports(on_gns3vm, compute_project, manager):
""" """
If no interface is provide the cloud is pre-fill with non special interfaces If no interface is provide the cloud is pre-fill with non special interfaces
""" """
@ -117,7 +118,6 @@ def test_json_without_ports(on_gns3vm, compute_project, manager):
} }
@pytest.mark.asyncio
async def test_update_port_mappings(on_gns3vm, compute_project): async def test_update_port_mappings(on_gns3vm, compute_project):
""" """
We don't allow an empty interface in the middle of port list We don't allow an empty interface in the middle of port list
@ -158,7 +158,6 @@ async def test_update_port_mappings(on_gns3vm, compute_project):
assert cloud.ports_mapping == ports1 assert cloud.ports_mapping == ports1
@pytest.mark.asyncio
async def test_linux_ethernet_raw_add_nio(linux_platform, compute_project, nio): async def test_linux_ethernet_raw_add_nio(linux_platform, compute_project, nio):
ports = [ ports = [
{ {
@ -186,7 +185,6 @@ async def test_linux_ethernet_raw_add_nio(linux_platform, compute_project, nio):
]) ])
@pytest.mark.asyncio
async def test_linux_ethernet_raw_add_nio_bridge(linux_platform, compute_project, nio): async def test_linux_ethernet_raw_add_nio_bridge(linux_platform, compute_project, nio):
""" """
Bridge can't be connected directly to a cloud we use a tap in the middle Bridge can't be connected directly to a cloud we use a tap in the middle

37
tests/conftest.py
View File

@ -1,5 +1,4 @@
import pytest import pytest
import asyncio
import pytest_asyncio import pytest_asyncio
import tempfile import tempfile
import shutil import shutil
@ -13,6 +12,7 @@ import stat
from fastapi import FastAPI from fastapi import FastAPI
from sqlalchemy.ext.asyncio import AsyncSession, create_async_engine from sqlalchemy.ext.asyncio import AsyncSession, create_async_engine
from httpx import AsyncClient from httpx import AsyncClient
from httpx_ws.transport import ASGIWebSocketTransport
from unittest.mock import MagicMock, patch from unittest.mock import MagicMock, patch
from pathlib import Path from pathlib import Path
@ -34,25 +34,14 @@ sys._called_from_test = True
sys.original_platform = sys.platform sys.original_platform = sys.platform
# https://github.com/pytest-dev/pytest-asyncio/issues/68 @pytest_asyncio.fixture(loop_scope="class", scope="class")
# this event_loop is used by pytest-asyncio, and redefining it
# is currently the only way of changing the scope of this fixture
@pytest.fixture(scope="class")
def event_loop(request):
loop = asyncio.get_event_loop_policy().new_event_loop()
yield loop
loop.close()
@pytest_asyncio.fixture(scope="class")
async def app() -> FastAPI: async def app() -> FastAPI:
from gns3server.api.server import app as gns3app from gns3server.api.server import app as gns3app
yield gns3app yield gns3app
@pytest_asyncio.fixture(scope="class") @pytest_asyncio.fixture(loop_scope="class", scope="class")
async def db_engine(): async def db_engine():
db_url = os.getenv("GNS3_TEST_DATABASE_URI", "sqlite+aiosqlite:///:memory:") # "sqlite:///./sql_test_app.db" db_url = os.getenv("GNS3_TEST_DATABASE_URI", "sqlite+aiosqlite:///:memory:") # "sqlite:///./sql_test_app.db"
@ -61,7 +50,7 @@ async def db_engine():
#await engine.sync_engine.dispose() #await engine.sync_engine.dispose()
@pytest_asyncio.fixture(scope="class") @pytest_asyncio.fixture(loop_scope="class", scope="class")
async def db_session(db_engine): async def db_session(db_engine):
# recreate database tables for each class # recreate database tables for each class
@ -82,7 +71,7 @@ async def db_session(db_engine):
await session.close() await session.close()
@pytest_asyncio.fixture @pytest_asyncio.fixture(loop_scope="class", scope="class")
async def base_client(app: FastAPI, db_session: AsyncSession) -> AsyncClient: async def base_client(app: FastAPI, db_session: AsyncSession) -> AsyncClient:
async def _get_test_db(): async def _get_test_db():
@ -94,14 +83,14 @@ async def base_client(app: FastAPI, db_session: AsyncSession) -> AsyncClient:
app.dependency_overrides[get_db_session] = _get_test_db app.dependency_overrides[get_db_session] = _get_test_db
async with AsyncClient( async with AsyncClient(
app=app,
base_url="http://test-api", base_url="http://test-api",
headers={"Content-Type": "application/json"} headers={"Content-Type": "application/json"},
transport=ASGIWebSocketTransport(app=app)
) as async_client: ) as async_client:
yield async_client yield async_client
@pytest_asyncio.fixture @pytest_asyncio.fixture(loop_scope="class", scope="class")
async def test_user(db_session: AsyncSession) -> User: async def test_user(db_session: AsyncSession) -> User:
new_user = schemas.UserCreate( new_user = schemas.UserCreate(
@ -121,7 +110,7 @@ async def test_user(db_session: AsyncSession) -> User:
return user return user
@pytest_asyncio.fixture @pytest_asyncio.fixture(loop_scope="class", scope="class")
async def test_compute(db_session: AsyncSession) -> Compute: async def test_compute(db_session: AsyncSession) -> Compute:
new_compute = schemas.ComputeCreate( new_compute = schemas.ComputeCreate(
@ -140,12 +129,12 @@ async def test_compute(db_session: AsyncSession) -> Compute:
return await compute_repo.create_compute(new_compute) return await compute_repo.create_compute(new_compute)
@pytest.fixture @pytest_asyncio.fixture(loop_scope="class", scope="class")
def unauthorized_client(base_client: AsyncClient, test_user: User) -> AsyncClient: def unauthorized_client(base_client: AsyncClient, test_user: User) -> AsyncClient:
return base_client return base_client
@pytest.fixture @pytest_asyncio.fixture(loop_scope="class", scope="class")
def authorized_client(base_client: AsyncClient, test_user: User) -> AsyncClient: def authorized_client(base_client: AsyncClient, test_user: User) -> AsyncClient:
access_token = auth_service.create_access_token(test_user.username) access_token = auth_service.create_access_token(test_user.username)
@ -156,7 +145,7 @@ def authorized_client(base_client: AsyncClient, test_user: User) -> AsyncClient:
return base_client return base_client
@pytest_asyncio.fixture @pytest_asyncio.fixture(loop_scope="class", scope="class")
async def client(base_client: AsyncClient) -> AsyncClient: async def client(base_client: AsyncClient) -> AsyncClient:
# The super admin is automatically created when the users table is created # The super admin is automatically created when the users table is created
@ -169,7 +158,7 @@ async def client(base_client: AsyncClient) -> AsyncClient:
return base_client return base_client
@pytest_asyncio.fixture @pytest_asyncio.fixture(loop_scope="class", scope="class")
async def compute_client(base_client: AsyncClient) -> AsyncClient: async def compute_client(base_client: AsyncClient) -> AsyncClient:
# default compute username is 'gns3' # default compute username is 'gns3'

2
tests/pytest.ini Normal file
View File

@ -0,0 +1,2 @@
[pytest]
asyncio_default_fixture_loop_scope=function