mirror of
https://github.com/GNS3/gns3-server
synced 2025-03-13 07:26:19 +00:00
Refactor tests and upgrade dev package requirements
This commit is contained in:
grossmj
parent
f6725a37dd
commit
ba4e0c945d
@ -1,7 +1,7 @@
|
||||
pytest==8.3.3
|
||||
pytest==8.3.4
|
||||
flake8==7.1.1
|
||||
pytest-timeout==2.3.1
|
||||
pytest-asyncio==0.21.2
|
||||
pytest-asyncio==0.25.2
|
||||
requests==2.32.3
|
||||
httpx==0.27.2 # version 0.24.1 is required by httpx_ws
|
||||
httpx_ws==0.6.2
|
||||
httpx==0.28.1
|
||||
httpx_ws==0.7.1
|
||||
|
||||
@ -29,7 +29,9 @@ from gns3server.utils.path import get_default_project_directory
|
||||
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"))
|
||||
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"))
|
||||
assert response.status_code == status.HTTP_200_OK
|
||||
|
||||
@ -28,8 +28,10 @@ from gns3server.compute.project import Project
|
||||
pytestmark = pytest.mark.asyncio
|
||||
|
||||
|
||||
@pytest_asyncio.fixture(scope="function")
|
||||
async def vm(app: FastAPI, compute_client: AsyncClient, compute_project: Project, on_gns3vm) -> dict:
|
||||
class TestCloudNodesRoutes:
|
||||
|
||||
@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"):
|
||||
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()
|
||||
|
||||
|
||||
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"):
|
||||
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
|
||||
|
||||
|
||||
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"]))
|
||||
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"
|
||||
|
||||
|
||||
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",
|
||||
"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"
|
||||
|
||||
|
||||
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",
|
||||
"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"
|
||||
|
||||
|
||||
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",
|
||||
"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
|
||||
|
||||
|
||||
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"]))
|
||||
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"]),
|
||||
json={"name": "test"})
|
||||
@ -137,7 +172,11 @@ async def test_cloud_update(app: FastAPI, compute_client: AsyncClient, vm: dict)
|
||||
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 = {
|
||||
"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"]
|
||||
|
||||
|
||||
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:
|
||||
response = await compute_client.post(app.url_path_for("compute:stop_cloud_capture",
|
||||
@ -168,14 +207,14 @@ async def test_cloud_stop_capture(app: FastAPI, compute_client: AsyncClient, vm:
|
||||
assert mock.called
|
||||
|
||||
|
||||
# @pytest.mark.asyncio
|
||||
# async def test_cloud_pcap(compute_api, vm, compute_project):
|
||||
#
|
||||
# from itertools import repeat
|
||||
# stream = repeat(42, times=10)
|
||||
#
|
||||
# with asyncio_patch("gns3server.compute.builtin.nodes.cloud.Cloud.get_nio"):
|
||||
# with asyncio_patch("gns3server.compute.builtin.Builtin.stream_pcap_file", return_value=stream):
|
||||
# response = await compute_api.get("/projects/{project_id}/cloud/nodes/{node_id}/adapters/0/ports/0/pcap".format(project_id=compute_project.id, node_id=vm["node_id"]))
|
||||
# assert response.status_code == 200
|
||||
#
|
||||
# @pytest.mark.asyncio
|
||||
# async def test_cloud_pcap(self, compute_api, vm, compute_project):
|
||||
#
|
||||
# from itertools import repeat
|
||||
# stream = repeat(42, times=10)
|
||||
#
|
||||
# with asyncio_patch("gns3server.compute.builtin.nodes.cloud.Cloud.get_nio"):
|
||||
# with asyncio_patch("gns3server.compute.builtin.Builtin.stream_pcap_file", return_value=stream):
|
||||
# response = await compute_api.get("/projects/{project_id}/cloud/nodes/{node_id}/adapters/0/ports/0/pcap".format(project_id=compute_project.id, node_id=vm["node_id"]))
|
||||
# assert response.status_code == 200
|
||||
#
|
||||
|
||||
@ -26,41 +26,48 @@ from gns3server.compute.project import Project
|
||||
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={})
|
||||
assert response.status_code == status.HTTP_201_CREATED
|
||||
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"))
|
||||
assert response.status_code == status.HTTP_200_OK
|
||||
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"))
|
||||
assert response.status_code == status.HTTP_200_OK
|
||||
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"))
|
||||
assert response.status_code == status.HTTP_401_UNAUTHORIZED
|
||||
|
||||
|
||||
# @pytest.mark.asyncio
|
||||
# async def test_debug_output(compute_api):
|
||||
#
|
||||
# response = await compute_api.get('/debug')
|
||||
# assert response.status_code == 200
|
||||
# @pytest.mark.asyncio
|
||||
# async def test_debug_output(compute_api):
|
||||
#
|
||||
# response = await compute_api.get('/debug')
|
||||
# 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"))
|
||||
assert response.status_code == status.HTTP_200_OK
|
||||
|
||||
@ -25,11 +25,13 @@ from unittest.mock import patch
|
||||
|
||||
from gns3server.compute.project import Project
|
||||
|
||||
pytestmark = [pytest.mark.asyncio]
|
||||
pytestmark = pytest.mark.asyncio
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def base_params() -> dict:
|
||||
class TestDockerNodesRoutes:
|
||||
|
||||
@pytest.fixture
|
||||
def base_params(self) -> dict:
|
||||
"""Return standard parameters"""
|
||||
|
||||
params = {
|
||||
@ -45,18 +47,24 @@ def base_params() -> dict:
|
||||
return params
|
||||
|
||||
|
||||
# @pytest.yield_fixture(autouse=True)
|
||||
# def mock_connection():
|
||||
#
|
||||
# docker = Docker.instance()
|
||||
# docker._connected = True
|
||||
# docker._connector = MagicMock()
|
||||
# yield
|
||||
# Docker._instance = None
|
||||
# @pytest.yield_fixture(autouse=True)
|
||||
# def mock_connection():
|
||||
#
|
||||
# docker = Docker.instance()
|
||||
# docker._connected = True
|
||||
# docker._connector = MagicMock()
|
||||
# yield
|
||||
# Docker._instance = None
|
||||
|
||||
|
||||
@pytest_asyncio.fixture
|
||||
async def vm(app: FastAPI, compute_client: AsyncClient, compute_project: Project, base_params: dict) -> dict:
|
||||
@pytest_asyncio.fixture
|
||||
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.query", return_value={"Id": "8bd8153ea8f5"}):
|
||||
@ -67,7 +75,12 @@ async def vm(app: FastAPI, compute_client: AsyncClient, compute_project: Project
|
||||
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.query", return_value={"Id": "8bd8153ea8f5"}):
|
||||
@ -85,7 +98,7 @@ async def test_docker_create(app: FastAPI, compute_client: AsyncClient, compute_
|
||||
assert response.json()["extra_hosts"] == "test:127.0.0.1"
|
||||
|
||||
|
||||
@pytest.mark.parametrize(
|
||||
@pytest.mark.parametrize(
|
||||
"name, status_code",
|
||||
(
|
||||
("valid-name.com", status.HTTP_201_CREATED),
|
||||
@ -100,15 +113,16 @@ async def test_docker_create(app: FastAPI, compute_client: AsyncClient, compute_
|
||||
(("x" * 62 + ".") * 4, status.HTTP_201_CREATED),
|
||||
("xx" + ("x" * 62 + ".") * 4, status.HTTP_409_CONFLICT),
|
||||
),
|
||||
)
|
||||
async def test_docker_create_with_invalid_name(
|
||||
)
|
||||
async def test_docker_create_with_invalid_name(
|
||||
self,
|
||||
app: FastAPI,
|
||||
compute_client: AsyncClient,
|
||||
compute_project: Project,
|
||||
base_params: dict,
|
||||
name: str,
|
||||
status_code: int
|
||||
) -> None:
|
||||
) -> None:
|
||||
|
||||
base_params["name"] = name
|
||||
with asyncio_patch("gns3server.compute.docker.Docker.list_images", return_value=[{"image": "nginx"}]):
|
||||
@ -119,7 +133,7 @@ async def test_docker_create_with_invalid_name(
|
||||
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:
|
||||
|
||||
@ -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
|
||||
|
||||
|
||||
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:
|
||||
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
|
||||
|
||||
|
||||
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:
|
||||
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
|
||||
|
||||
|
||||
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:
|
||||
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
|
||||
|
||||
|
||||
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:
|
||||
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
|
||||
|
||||
|
||||
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:
|
||||
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
|
||||
|
||||
|
||||
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 = {
|
||||
"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"
|
||||
|
||||
|
||||
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 = {
|
||||
"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
|
||||
|
||||
|
||||
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",
|
||||
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
|
||||
|
||||
|
||||
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 = {
|
||||
"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"
|
||||
|
||||
|
||||
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",
|
||||
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"]
|
||||
|
||||
|
||||
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",
|
||||
project_id=vm["project_id"],
|
||||
@ -293,7 +307,7 @@ async def test_docker_stop_capture(app: FastAPI, compute_client: AsyncClient, vm
|
||||
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
|
||||
with asyncio_patch("gns3server.compute.docker.Docker.list_images", return_value=[{"image": "nginx"}]):
|
||||
|
||||
@ -26,122 +26,125 @@ from httpx import AsyncClient
|
||||
|
||||
pytestmark = pytest.mark.asyncio
|
||||
|
||||
# @pytest.yield_fixture(scope="module")
|
||||
# async def vm(compute_api, compute_project, fake_image):
|
||||
#
|
||||
# dynamips_path = "/fake/dynamips"
|
||||
# params = {
|
||||
# "name": "My router",
|
||||
# "platform": "c3745",
|
||||
# "image": fake_image,
|
||||
# "ram": 128
|
||||
# }
|
||||
# with asyncio_patch("gns3server.compute.dynamips.nodes.router.Router.create", return_value=True) as mock:
|
||||
# response = await compute_api.post("/projects/{project_id}/dynamips/nodes".format(project_id=compute_project.id), params)
|
||||
# assert mock.called
|
||||
# assert response.status == 201
|
||||
#
|
||||
# #with asyncio_patch("gns3server.compute.dynamips.Dynamips.find_dynamips", return_value=dynamips_path):
|
||||
# # yield response.json
|
||||
|
||||
class TestDynamipsNodesRoutes:
|
||||
|
||||
# @pytest.yield_fixture(scope="module")
|
||||
# async def vm(compute_api, compute_project, fake_image):
|
||||
#
|
||||
# dynamips_path = "/fake/dynamips"
|
||||
# params = {
|
||||
# "name": "My router",
|
||||
# "platform": "c3745",
|
||||
# "image": fake_image,
|
||||
# "ram": 128
|
||||
# }
|
||||
# with asyncio_patch("gns3server.compute.dynamips.nodes.router.Router.create", return_value=True) as mock:
|
||||
# response = await compute_api.post("/projects/{project_id}/dynamips/nodes".format(project_id=compute_project.id), params)
|
||||
# assert mock.called
|
||||
# assert response.status == 201
|
||||
#
|
||||
# #with asyncio_patch("gns3server.compute.dynamips.Dynamips.find_dynamips", return_value=dynamips_path):
|
||||
# # yield response.json
|
||||
|
||||
|
||||
# async def test_dynamips_vm_create(compute_api, compute_project, fake_image):
|
||||
#
|
||||
# params = {
|
||||
# "name": "My router",
|
||||
# "platform": "c3745",
|
||||
# "image": os.path.basename(fake_image),
|
||||
# "ram": 128
|
||||
# }
|
||||
#
|
||||
# print(fake_image)
|
||||
#
|
||||
# with asyncio_patch("gns3server.compute.dynamips.nodes.router.Router.create", return_value=True):
|
||||
# response = await compute_api.post("/projects/{project_id}/dynamips/nodes".format(project_id=compute_project.id), params)
|
||||
# assert response.status == 201
|
||||
# assert response.json["name"] == "My router"
|
||||
# assert response.json["project_id"] == compute_project.id
|
||||
# assert response.json["dynamips_id"]
|
||||
# async def test_dynamips_vm_create(compute_api, compute_project, fake_image):
|
||||
#
|
||||
# params = {
|
||||
# "name": "My router",
|
||||
# "platform": "c3745",
|
||||
# "image": os.path.basename(fake_image),
|
||||
# "ram": 128
|
||||
# }
|
||||
#
|
||||
# print(fake_image)
|
||||
#
|
||||
# with asyncio_patch("gns3server.compute.dynamips.nodes.router.Router.create", return_value=True):
|
||||
# response = await compute_api.post("/projects/{project_id}/dynamips/nodes".format(project_id=compute_project.id), params)
|
||||
# assert response.status == 201
|
||||
# assert response.json["name"] == "My router"
|
||||
# assert response.json["project_id"] == compute_project.id
|
||||
# assert response.json["dynamips_id"]
|
||||
|
||||
|
||||
# def test_dynamips_vm_get(compute_api, project, vm):
|
||||
# response = compute_api.get("/projects/{project_id}/dynamips/nodes/{node_id}".format(project_id=vm["project_id"], node_id=vm["node_id"]), example=True)
|
||||
# assert response.status == 200
|
||||
# assert response.route == "/projects/{project_id}/dynamips/nodes/{node_id}"
|
||||
# assert response.json["name"] == "My router"
|
||||
# assert response.json["project_id"] == project.id
|
||||
#
|
||||
#
|
||||
# def test_dynamips_vm_start(compute_api, vm):
|
||||
# with asyncio_patch("gns3server.compute.dynamips.nodes.router.Router.start", return_value=True) as mock:
|
||||
# response = compute_api.post("/projects/{project_id}/dynamips/nodes/{node_id}/start".format(project_id=vm["project_id"], node_id=vm["node_id"]))
|
||||
# assert mock.called
|
||||
# assert response.status == 204
|
||||
#
|
||||
#
|
||||
# def test_dynamips_vm_stop(compute_api, vm):
|
||||
# with asyncio_patch("gns3server.compute.dynamips.nodes.router.Router.stop", return_value=True) as mock:
|
||||
# response = compute_api.post("/projects/{project_id}/dynamips/nodes/{node_id}/stop".format(project_id=vm["project_id"], node_id=vm["node_id"]))
|
||||
# assert mock.called
|
||||
# assert response.status == 204
|
||||
#
|
||||
#
|
||||
# def test_dynamips_vm_suspend(compute_api, vm):
|
||||
# with asyncio_patch("gns3server.compute.dynamips.nodes.router.Router.suspend", return_value=True) as mock:
|
||||
# response = compute_api.post("/projects/{project_id}/dynamips/nodes/{node_id}/suspend".format(project_id=vm["project_id"], node_id=vm["node_id"]))
|
||||
# assert mock.called
|
||||
# assert response.status == 204
|
||||
#
|
||||
#
|
||||
# def test_dynamips_vm_resume(compute_api, vm):
|
||||
# with asyncio_patch("gns3server.compute.dynamips.nodes.router.Router.resume", return_value=True) as mock:
|
||||
# response = compute_api.post("/projects/{project_id}/dynamips/nodes/{node_id}/resume".format(project_id=vm["project_id"], node_id=vm["node_id"]))
|
||||
# assert mock.called
|
||||
# assert response.status == 204
|
||||
# def test_dynamips_vm_get(compute_api, project, vm):
|
||||
# response = compute_api.get("/projects/{project_id}/dynamips/nodes/{node_id}".format(project_id=vm["project_id"], node_id=vm["node_id"]), example=True)
|
||||
# assert response.status == 200
|
||||
# assert response.route == "/projects/{project_id}/dynamips/nodes/{node_id}"
|
||||
# assert response.json["name"] == "My router"
|
||||
# assert response.json["project_id"] == project.id
|
||||
#
|
||||
#
|
||||
# def test_dynamips_vm_start(compute_api, vm):
|
||||
# with asyncio_patch("gns3server.compute.dynamips.nodes.router.Router.start", return_value=True) as mock:
|
||||
# response = compute_api.post("/projects/{project_id}/dynamips/nodes/{node_id}/start".format(project_id=vm["project_id"], node_id=vm["node_id"]))
|
||||
# assert mock.called
|
||||
# assert response.status == 204
|
||||
#
|
||||
#
|
||||
# def test_dynamips_vm_stop(compute_api, vm):
|
||||
# with asyncio_patch("gns3server.compute.dynamips.nodes.router.Router.stop", return_value=True) as mock:
|
||||
# response = compute_api.post("/projects/{project_id}/dynamips/nodes/{node_id}/stop".format(project_id=vm["project_id"], node_id=vm["node_id"]))
|
||||
# assert mock.called
|
||||
# assert response.status == 204
|
||||
#
|
||||
#
|
||||
# def test_dynamips_vm_suspend(compute_api, vm):
|
||||
# with asyncio_patch("gns3server.compute.dynamips.nodes.router.Router.suspend", return_value=True) as mock:
|
||||
# response = compute_api.post("/projects/{project_id}/dynamips/nodes/{node_id}/suspend".format(project_id=vm["project_id"], node_id=vm["node_id"]))
|
||||
# assert mock.called
|
||||
# assert response.status == 204
|
||||
#
|
||||
#
|
||||
# def test_dynamips_vm_resume(compute_api, vm):
|
||||
# with asyncio_patch("gns3server.compute.dynamips.nodes.router.Router.resume", return_value=True) as mock:
|
||||
# response = compute_api.post("/projects/{project_id}/dynamips/nodes/{node_id}/resume".format(project_id=vm["project_id"], node_id=vm["node_id"]))
|
||||
# assert mock.called
|
||||
# assert response.status == 204
|
||||
|
||||
|
||||
# def test_vbox_nio_create_udp(compute_api, vm):
|
||||
#
|
||||
# with asyncio_patch('gns3server.compute.virtualbox.virtualbox_vm.VirtualBoxVM.adapter_add_nio_binding') as mock:
|
||||
# response = compute_api.post("/projects/{project_id}/virtualbox/nodes/{node_id}/adapters/0/nio".format(project_id=vm["project_id"],
|
||||
# node_id=vm["node_id"]), {"type": "nio_udp",
|
||||
# "lport": 4242,
|
||||
# "rport": 4343,
|
||||
# "rhost": "127.0.0.1"},
|
||||
# example=True)
|
||||
#
|
||||
# assert mock.called
|
||||
# args, kwgars = mock.call_args
|
||||
# assert args[0] == 0
|
||||
#
|
||||
# assert response.status == 201
|
||||
# assert response.route == "/projects/{project_id}/virtualbox/nodes/{node_id}/adapters/{adapter_id:\d+}/nio"
|
||||
# assert response.json["type"] == "nio_udp"
|
||||
#
|
||||
#
|
||||
# def test_vbox_delete_nio(compute_api, vm):
|
||||
#
|
||||
# with asyncio_patch('gns3server.compute.virtualbox.virtualbox_vm.VirtualBoxVM.adapter_remove_nio_binding') as mock:
|
||||
# response = compute_api.delete("/projects/{project_id}/virtualbox/nodes/{node_id}/adapters/0/nio".format(project_id=vm["project_id"], node_id=vm["node_id"]), example=True)
|
||||
#
|
||||
# assert mock.called
|
||||
# args, kwgars = mock.call_args
|
||||
# assert args[0] == 0
|
||||
#
|
||||
# assert response.status == 204
|
||||
# assert response.route == "/projects/{project_id}/virtualbox/nodes/{node_id}/adapters/{adapter_id:\d+}/nio"
|
||||
#
|
||||
#
|
||||
# def test_vbox_update(compute_api, vm, free_console_port):
|
||||
# response = compute_api.put("/projects/{project_id}/virtualbox/nodes/{node_id}".format(project_id=vm["project_id"], node_id=vm["node_id"]), {"name": "test",
|
||||
# "console": free_console_port})
|
||||
# assert response.status == 200
|
||||
# assert response.json["name"] == "test"
|
||||
# assert response.json["console"] == free_console_port
|
||||
# def test_vbox_nio_create_udp(compute_api, vm):
|
||||
#
|
||||
# with asyncio_patch('gns3server.compute.virtualbox.virtualbox_vm.VirtualBoxVM.adapter_add_nio_binding') as mock:
|
||||
# response = compute_api.post("/projects/{project_id}/virtualbox/nodes/{node_id}/adapters/0/nio".format(project_id=vm["project_id"],
|
||||
# node_id=vm["node_id"]), {"type": "nio_udp",
|
||||
# "lport": 4242,
|
||||
# "rport": 4343,
|
||||
# "rhost": "127.0.0.1"},
|
||||
# example=True)
|
||||
#
|
||||
# assert mock.called
|
||||
# args, kwgars = mock.call_args
|
||||
# assert args[0] == 0
|
||||
#
|
||||
# assert response.status == 201
|
||||
# assert response.route == "/projects/{project_id}/virtualbox/nodes/{node_id}/adapters/{adapter_id:\d+}/nio"
|
||||
# assert response.json["type"] == "nio_udp"
|
||||
#
|
||||
#
|
||||
# def test_vbox_delete_nio(compute_api, vm):
|
||||
#
|
||||
# with asyncio_patch('gns3server.compute.virtualbox.virtualbox_vm.VirtualBoxVM.adapter_remove_nio_binding') as mock:
|
||||
# response = compute_api.delete("/projects/{project_id}/virtualbox/nodes/{node_id}/adapters/0/nio".format(project_id=vm["project_id"], node_id=vm["node_id"]), example=True)
|
||||
#
|
||||
# assert mock.called
|
||||
# args, kwgars = mock.call_args
|
||||
# assert args[0] == 0
|
||||
#
|
||||
# assert response.status == 204
|
||||
# assert response.route == "/projects/{project_id}/virtualbox/nodes/{node_id}/adapters/{adapter_id:\d+}/nio"
|
||||
#
|
||||
#
|
||||
# def test_vbox_update(compute_api, vm, free_console_port):
|
||||
# response = compute_api.put("/projects/{project_id}/virtualbox/nodes/{node_id}".format(project_id=vm["project_id"], node_id=vm["node_id"]), {"name": "test",
|
||||
# "console": free_console_port})
|
||||
# assert response.status == 200
|
||||
# assert response.json["name"] == "test"
|
||||
# assert response.json["console"] == free_console_port
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def fake_image(tmpdir) -> str:
|
||||
@pytest.fixture
|
||||
def fake_image(self, tmpdir) -> str:
|
||||
"""Create a fake Dynamips image on disk"""
|
||||
|
||||
path = str(tmpdir / "7200.bin")
|
||||
@ -151,8 +154,8 @@ def fake_image(tmpdir) -> str:
|
||||
return path
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def fake_file(tmpdir) -> str:
|
||||
@pytest.fixture
|
||||
def fake_file(self, tmpdir) -> str:
|
||||
"""Create a fake file disk"""
|
||||
|
||||
path = str(tmpdir / "7200.txt")
|
||||
@ -162,7 +165,12 @@ def fake_file(tmpdir) -> str:
|
||||
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)):
|
||||
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"}]
|
||||
|
||||
|
||||
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")
|
||||
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"
|
||||
|
||||
|
||||
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"
|
||||
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
|
||||
|
||||
|
||||
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")
|
||||
assert response.status_code == status.HTTP_204_NO_CONTENT
|
||||
@ -202,15 +210,19 @@ async def test_download_image(app: FastAPI, compute_client: AsyncClient, images_
|
||||
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"
|
||||
response = await compute_client.get(app.url_path_for("compute:download_dynamips_image", filename=file_path))
|
||||
assert response.status_code == status.HTTP_403_FORBIDDEN
|
||||
|
||||
|
||||
@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:
|
||||
@pytest.mark.skipif(os.getuid() == 0, reason="Root can delete any image")
|
||||
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)
|
||||
with open(os.path.join(images_dir, "IOS", "test2.tmp"), "w+") as f:
|
||||
|
||||
@ -28,8 +28,10 @@ from gns3server.compute.project import Project
|
||||
pytestmark = pytest.mark.asyncio
|
||||
|
||||
|
||||
@pytest_asyncio.fixture
|
||||
async def ethernet_switch(app: FastAPI, compute_client: AsyncClient, compute_project: Project) -> dict:
|
||||
class TestEthernetSwitchNodesRoutes:
|
||||
|
||||
@pytest_asyncio.fixture
|
||||
async def ethernet_switch(self, app: FastAPI, compute_client: AsyncClient, compute_project: Project) -> dict:
|
||||
|
||||
params = {"name": "Ethernet Switch"}
|
||||
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
|
||||
|
||||
|
||||
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"}
|
||||
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
|
||||
|
||||
|
||||
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(
|
||||
app.url_path_for(
|
||||
@ -77,12 +88,13 @@ async def test_ethernet_switch_get(app: FastAPI, compute_client: AsyncClient, co
|
||||
assert response.json()["status"] == "started"
|
||||
|
||||
|
||||
async def test_ethernet_switch_duplicate(
|
||||
async def test_ethernet_switch_duplicate(
|
||||
self,
|
||||
app: FastAPI,
|
||||
compute_client: AsyncClient,
|
||||
compute_project: Project,
|
||||
ethernet_switch: dict
|
||||
) -> None:
|
||||
) -> None:
|
||||
|
||||
# create destination switch first
|
||||
params = {"name": "Ethernet Switch 2"}
|
||||
@ -106,12 +118,13 @@ async def test_ethernet_switch_duplicate(
|
||||
assert response.status_code == status.HTTP_201_CREATED
|
||||
|
||||
|
||||
async def test_ethernet_switch_update(
|
||||
async def test_ethernet_switch_update(
|
||||
self,
|
||||
app: FastAPI,
|
||||
compute_client: AsyncClient,
|
||||
compute_project: Project,
|
||||
ethernet_switch: dict
|
||||
) -> None:
|
||||
) -> None:
|
||||
|
||||
params = {
|
||||
"name": "test",
|
||||
@ -132,12 +145,13 @@ async def test_ethernet_switch_update(
|
||||
node._hypervisor.send.assert_called_with("ethsw rename \"Ethernet Switch\" \"test\"")
|
||||
|
||||
|
||||
async def test_ethernet_switch_update_ports(
|
||||
async def test_ethernet_switch_update_ports(
|
||||
self,
|
||||
app: FastAPI,
|
||||
compute_client: AsyncClient,
|
||||
compute_project: Project,
|
||||
ethernet_switch: dict
|
||||
) -> None:
|
||||
) -> None:
|
||||
|
||||
port_params = {
|
||||
"ports_mapping": [
|
||||
@ -210,7 +224,7 @@ async def test_ethernet_switch_update_ports(
|
||||
node._hypervisor.send.reset_mock()
|
||||
|
||||
|
||||
@pytest.mark.parametrize(
|
||||
@pytest.mark.parametrize(
|
||||
"ports_settings",
|
||||
(
|
||||
(
|
||||
@ -263,13 +277,14 @@ 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,
|
||||
compute_client: AsyncClient,
|
||||
ethernet_switch: dict,
|
||||
ports_settings: dict,
|
||||
) -> None:
|
||||
) -> None:
|
||||
|
||||
port_params = {
|
||||
"ports_mapping": [ports_settings]
|
||||
@ -285,7 +300,11 @@ async def test_ethernet_switch_update_ports_invalid(
|
||||
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(
|
||||
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
|
||||
|
||||
|
||||
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(
|
||||
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
|
||||
|
||||
|
||||
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(
|
||||
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
|
||||
|
||||
|
||||
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(
|
||||
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
|
||||
|
||||
|
||||
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(
|
||||
app.url_path_for(
|
||||
@ -341,12 +376,13 @@ async def test_ethernet_switch_reload(app: FastAPI, compute_client: AsyncClient,
|
||||
assert response.status_code == status.HTTP_204_NO_CONTENT
|
||||
|
||||
|
||||
async def test_ethernet_switch_create_udp(
|
||||
async def test_ethernet_switch_create_udp(
|
||||
self,
|
||||
app: FastAPI,
|
||||
compute_client: AsyncClient,
|
||||
compute_project: Project,
|
||||
ethernet_switch: dict
|
||||
) -> None:
|
||||
) -> None:
|
||||
|
||||
params = {
|
||||
"type": "nio_udp",
|
||||
@ -376,12 +412,13 @@ async def test_ethernet_switch_create_udp(
|
||||
node._hypervisor.send.assert_has_calls(calls)
|
||||
|
||||
|
||||
async def test_ethernet_switch_delete_nio(
|
||||
async def test_ethernet_switch_delete_nio(
|
||||
self,
|
||||
app: FastAPI,
|
||||
compute_client: AsyncClient,
|
||||
compute_project: Project,
|
||||
ethernet_switch: dict
|
||||
) -> None:
|
||||
) -> None:
|
||||
|
||||
params = {
|
||||
"type": "nio_udp",
|
||||
@ -420,7 +457,12 @@ async def test_ethernet_switch_delete_nio(
|
||||
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 = {
|
||||
"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"]
|
||||
|
||||
|
||||
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",
|
||||
project_id=ethernet_switch["project_id"],
|
||||
|
||||
@ -28,11 +28,13 @@ from unittest.mock import patch
|
||||
|
||||
from gns3server.compute.project import Project
|
||||
|
||||
pytestmark = [pytest.mark.asyncio]
|
||||
pytestmark = pytest.mark.asyncio
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def fake_iou_bin(images_dir) -> str:
|
||||
class TestIOUNodesRoutes:
|
||||
|
||||
@pytest.fixture
|
||||
def fake_iou_bin(self, images_dir) -> str:
|
||||
"""Create a fake IOU image on disk"""
|
||||
|
||||
path = os.path.join(images_dir, "IOU", "iou.bin")
|
||||
@ -42,29 +44,41 @@ def fake_iou_bin(images_dir) -> str:
|
||||
return path
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def base_params(tmpdir, fake_iou_bin) -> dict:
|
||||
@pytest.fixture
|
||||
def base_params(self, tmpdir, fake_iou_bin) -> dict:
|
||||
"""Return standard parameters"""
|
||||
|
||||
return {"application_id": 42, "name": "IOU-TEST-1", "path": "iou.bin"}
|
||||
|
||||
|
||||
@pytest_asyncio.fixture
|
||||
async def vm(app: FastAPI, compute_client: AsyncClient, compute_project: Project, base_params: dict) -> dict:
|
||||
@pytest_asyncio.fixture
|
||||
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)
|
||||
assert response.status_code == status.HTTP_201_CREATED
|
||||
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"])
|
||||
os.makedirs(directory, exist_ok=True)
|
||||
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)
|
||||
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
|
||||
|
||||
|
||||
async def test_iou_create_with_params(app: FastAPI,
|
||||
async def test_iou_create_with_params(
|
||||
self,
|
||||
app: FastAPI,
|
||||
compute_client: AsyncClient,
|
||||
compute_project: Project,
|
||||
base_params: dict) -> None:
|
||||
base_params: dict
|
||||
) -> None:
|
||||
|
||||
params = base_params
|
||||
params["ram"] = 1024
|
||||
@ -102,11 +119,11 @@ async def test_iou_create_with_params(app: FastAPI,
|
||||
assert response.json()["l1_keepalives"] is True
|
||||
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"
|
||||
|
||||
|
||||
@pytest.mark.parametrize(
|
||||
@pytest.mark.parametrize(
|
||||
"name, status_code",
|
||||
(
|
||||
("valid-name", status.HTTP_201_CREATED),
|
||||
@ -117,15 +134,16 @@ async def test_iou_create_with_params(app: FastAPI,
|
||||
("x" * 63, status.HTTP_201_CREATED),
|
||||
("x" * 64, status.HTTP_409_CONFLICT),
|
||||
),
|
||||
)
|
||||
async def test_iou_create_with_invalid_name(
|
||||
)
|
||||
async def test_iou_create_with_invalid_name(
|
||||
self,
|
||||
app: FastAPI,
|
||||
compute_client: AsyncClient,
|
||||
compute_project: Project,
|
||||
base_params: dict,
|
||||
name: str,
|
||||
status_code: int
|
||||
) -> None:
|
||||
) -> None:
|
||||
|
||||
base_params["name"] = name
|
||||
response = await compute_client.post(
|
||||
@ -134,7 +152,8 @@ async def test_iou_create_with_invalid_name(
|
||||
assert response.status_code == status_code
|
||||
|
||||
|
||||
async def test_iou_create_startup_config_already_exist(
|
||||
async def test_iou_create_startup_config_already_exist(
|
||||
self,
|
||||
app: FastAPI,
|
||||
compute_client: AsyncClient,
|
||||
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"""
|
||||
|
||||
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:
|
||||
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)
|
||||
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"
|
||||
|
||||
|
||||
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"]))
|
||||
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
|
||||
|
||||
|
||||
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:
|
||||
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
|
||||
|
||||
|
||||
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"}
|
||||
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
|
||||
|
||||
|
||||
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:
|
||||
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
|
||||
|
||||
|
||||
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:
|
||||
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
|
||||
|
||||
|
||||
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:
|
||||
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
|
||||
|
||||
|
||||
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 = {
|
||||
"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
|
||||
|
||||
|
||||
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",
|
||||
"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"
|
||||
|
||||
|
||||
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",
|
||||
"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"
|
||||
|
||||
|
||||
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 = {
|
||||
"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
|
||||
|
||||
|
||||
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,
|
||||
vm: dict,
|
||||
ethernet_device: str) -> None:
|
||||
ethernet_device: str
|
||||
) -> None:
|
||||
|
||||
params = {
|
||||
"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
|
||||
|
||||
|
||||
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 = {
|
||||
"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"
|
||||
|
||||
|
||||
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 = {
|
||||
"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
|
||||
|
||||
|
||||
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 = {
|
||||
"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"]
|
||||
|
||||
|
||||
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",
|
||||
project_id=vm["project_id"],
|
||||
@ -412,23 +462,23 @@ async def test_iou_stop_capture(app: FastAPI, compute_client: AsyncClient, vm: d
|
||||
assert mock.called
|
||||
|
||||
|
||||
# @pytest.mark.asyncio
|
||||
# async def test_iou_pcap(compute_api, vm, compute_project):
|
||||
#
|
||||
# with asyncio_patch("gns3server.compute.iou.iou_vm.IOUVM.get_nio"):
|
||||
# with asyncio_patch("gns3server.compute.iou.IOU.stream_pcap_file"):
|
||||
# response = await compute_client.get("/projects/{project_id}/iou/nodes/{node_id}/adapters/0/ports/0/pcap".format(project_id=compute_project.id, node_id=vm["node_id"]), raw=True)
|
||||
# assert response.status_code == status.HTTP_200_OK
|
||||
# @pytest.mark.asyncio
|
||||
# async def test_iou_pcap(compute_api, vm, compute_project):
|
||||
#
|
||||
# with asyncio_patch("gns3server.compute.iou.iou_vm.IOUVM.get_nio"):
|
||||
# with asyncio_patch("gns3server.compute.iou.IOU.stream_pcap_file"):
|
||||
# response = await compute_client.get("/projects/{project_id}/iou/nodes/{node_id}/adapters/0/ports/0/pcap".format(project_id=compute_project.id, node_id=vm["node_id"]), raw=True)
|
||||
# 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"))
|
||||
assert response.status_code == status.HTTP_200_OK
|
||||
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)):
|
||||
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"
|
||||
|
||||
|
||||
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"
|
||||
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
|
||||
|
||||
|
||||
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")
|
||||
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
|
||||
|
||||
|
||||
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"
|
||||
response = await compute_client.get(app.url_path_for("compute:download_iou_image", filename=file_path))
|
||||
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
|
||||
response = await compute_client.post(app.url_path_for("compute:create_iou_node", project_id=vm["project_id"]), json=base_params)
|
||||
|
||||
@ -27,8 +27,17 @@ from gns3server.compute.project import Project
|
||||
pytestmark = pytest.mark.asyncio
|
||||
|
||||
|
||||
@pytest_asyncio.fixture(scope="function")
|
||||
async def vm(app: FastAPI, compute_client: AsyncClient, compute_project: Project, ubridge_path: str, on_gns3vm) -> dict:
|
||||
class TestNATNodesRoutes:
|
||||
|
||||
@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"):
|
||||
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()
|
||||
|
||||
|
||||
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"):
|
||||
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
|
||||
|
||||
|
||||
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"]))
|
||||
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"
|
||||
|
||||
|
||||
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 = {
|
||||
"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"
|
||||
|
||||
|
||||
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 = {
|
||||
"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"
|
||||
|
||||
|
||||
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 = {
|
||||
"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
|
||||
|
||||
|
||||
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",
|
||||
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
|
||||
|
||||
|
||||
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",
|
||||
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"
|
||||
|
||||
|
||||
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 = {
|
||||
"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"]
|
||||
|
||||
|
||||
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",
|
||||
project_id=vm["project_id"],
|
||||
@ -184,10 +205,10 @@ async def test_nat_stop_capture(app: FastAPI, compute_client: AsyncClient, vm: d
|
||||
assert mock.called
|
||||
|
||||
|
||||
# @pytest.mark.asyncio
|
||||
# async def test_nat_pcap(compute_api, vm, compute_project):
|
||||
#
|
||||
# with asyncio_patch("gns3server.compute.builtin.nodes.nat.Nat.get_nio"):
|
||||
# with asyncio_patch("gns3server.compute.builtin.Builtin.stream_pcap_file"):
|
||||
# response = await compute_client.get("/projects/{project_id}/nat/nodes/{node_id}/adapters/0/ports/0/pcap".format(project_id=compute_project.id, node_id=vm["node_id"]), raw=True)
|
||||
# assert response.status_code == status.HTTP_200_OK
|
||||
# @pytest.mark.asyncio
|
||||
# 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.Builtin.stream_pcap_file"):
|
||||
# response = await compute_client.get("/projects/{project_id}/nat/nodes/{node_id}/adapters/0/ports/0/pcap".format(project_id=compute_project.id, node_id=vm["node_id"]), raw=True)
|
||||
# assert response.status_code == status.HTTP_200_OK
|
||||
|
||||
@ -30,8 +30,10 @@ from gns3server.compute.project import Project
|
||||
pytestmark = pytest.mark.asyncio
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def base_params(tmpdir) -> dict:
|
||||
class TestComputeProjectRoutes:
|
||||
|
||||
@pytest.fixture
|
||||
def base_params(self, tmpdir) -> dict:
|
||||
"""Return standard parameters"""
|
||||
|
||||
params = {
|
||||
@ -41,7 +43,12 @@ def base_params(tmpdir) -> dict:
|
||||
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)
|
||||
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"]
|
||||
|
||||
|
||||
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)
|
||||
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
|
||||
|
||||
|
||||
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",
|
||||
project_id="50010203-0405-0607-0809-0a0b0c0d0e42"))
|
||||
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 = {}
|
||||
|
||||
@ -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()]
|
||||
|
||||
|
||||
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:
|
||||
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
|
||||
|
||||
|
||||
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)
|
||||
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"}]
|
||||
|
||||
|
||||
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())))
|
||||
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:
|
||||
response = await compute_client.post(app.url_path_for("compute:close_compute_project", project_id=compute_project.id))
|
||||
@ -120,23 +132,23 @@ async def test_close_project(app: FastAPI, compute_client: AsyncClient, compute_
|
||||
assert mock.called
|
||||
|
||||
|
||||
# @pytest.mark.asyncio
|
||||
# async def test_close_project_two_client_connected(compute_api, compute_project):
|
||||
#
|
||||
# ProjectHandler._notifications_listening = {compute_project.id: 2}
|
||||
# with asyncio_patch("gns3server.compute.project.Project.close", return_value=True) as mock:
|
||||
# response = await compute_client.post("/projects/{project_id}/close".format(project_id=compute_project.id))
|
||||
# assert response.status_code == status.HTTP_204_NO_CONTENT
|
||||
# assert not mock.called
|
||||
# @pytest.mark.asyncio
|
||||
# async def test_close_project_two_client_connected(compute_api, compute_project):
|
||||
#
|
||||
# ProjectHandler._notifications_listening = {compute_project.id: 2}
|
||||
# with asyncio_patch("gns3server.compute.project.Project.close", return_value=True) as mock:
|
||||
# response = await compute_client.post("/projects/{project_id}/close".format(project_id=compute_project.id))
|
||||
# assert response.status_code == status.HTTP_204_NO_CONTENT
|
||||
# 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())))
|
||||
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")
|
||||
|
||||
@ -156,7 +168,13 @@ async def test_get_file(app: FastAPI, compute_client: AsyncClient) -> None:
|
||||
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)
|
||||
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
|
||||
|
||||
|
||||
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)
|
||||
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
|
||||
|
||||
|
||||
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)
|
||||
project = ProjectManager.instance().create_project(project_id="01010203-0405-0607-0809-0a0b0c0d0e0b")
|
||||
|
||||
@ -31,8 +31,10 @@ from gns3server.compute.project import Project
|
||||
pytestmark = pytest.mark.asyncio
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def fake_qemu_bin(monkeypatch, tmpdir) -> str:
|
||||
class TestQemuNodesRoutes:
|
||||
|
||||
@pytest.fixture
|
||||
def fake_qemu_bin(self, monkeypatch, tmpdir) -> str:
|
||||
|
||||
monkeypatch.setenv("PATH", str(tmpdir))
|
||||
bin_path = os.path.join(os.environ["PATH"], "qemu-system-x86_64")
|
||||
@ -42,8 +44,8 @@ def fake_qemu_bin(monkeypatch, tmpdir) -> str:
|
||||
return bin_path
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def fake_qemu_vm(images_dir) -> str:
|
||||
@pytest.fixture
|
||||
def fake_qemu_vm(self, images_dir) -> str:
|
||||
|
||||
img_dir = os.path.join(images_dir, "QEMU")
|
||||
bin_path = os.path.join(img_dir, "linux载.img")
|
||||
@ -53,8 +55,8 @@ def fake_qemu_vm(images_dir) -> str:
|
||||
return bin_path
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def fake_qemu_img_binary(tmpdir):
|
||||
@pytest.fixture
|
||||
def fake_qemu_img_binary(self, tmpdir):
|
||||
|
||||
bin_path = str(tmpdir / "qemu-img")
|
||||
with open(bin_path, "w+") as f:
|
||||
@ -63,15 +65,21 @@ def fake_qemu_img_binary(tmpdir):
|
||||
return bin_path
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def base_params(tmpdir, fake_qemu_bin) -> dict:
|
||||
@pytest.fixture
|
||||
def base_params(self, tmpdir, fake_qemu_bin) -> dict:
|
||||
"""Return standard parameters"""
|
||||
|
||||
return {"name": "QEMU-TEST-1", "qemu_path": fake_qemu_bin}
|
||||
|
||||
|
||||
@pytest_asyncio.fixture
|
||||
async def qemu_vm(app: FastAPI, compute_client: AsyncClient, compute_project: Project, base_params: dict) -> None:
|
||||
@pytest_asyncio.fixture
|
||||
async def qemu_vm(
|
||||
self,
|
||||
app: FastAPI,
|
||||
compute_client: AsyncClient,
|
||||
compute_project: Project,
|
||||
base_params: dict
|
||||
) -> None:
|
||||
|
||||
response = await compute_client.post(
|
||||
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()
|
||||
|
||||
|
||||
async def test_qemu_create(app: FastAPI,
|
||||
async def test_qemu_create(
|
||||
self,
|
||||
app: FastAPI,
|
||||
compute_client: AsyncClient,
|
||||
compute_project: Project,
|
||||
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)
|
||||
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"
|
||||
|
||||
|
||||
async def test_qemu_create_platform(app: FastAPI,
|
||||
async def test_qemu_create_platform(
|
||||
self,
|
||||
app: FastAPI,
|
||||
compute_client: AsyncClient,
|
||||
compute_project: Project,
|
||||
base_params: dict,
|
||||
fake_qemu_bin: str):
|
||||
fake_qemu_bin: str
|
||||
):
|
||||
|
||||
base_params["qemu_path"] = None
|
||||
base_params["platform"] = "x86_64"
|
||||
@ -111,12 +125,15 @@ async def test_qemu_create_platform(app: FastAPI,
|
||||
assert response.json()["platform"] == "x86_64"
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_qemu_create_with_params(app: FastAPI,
|
||||
@pytest.mark.asyncio
|
||||
async def test_qemu_create_with_params(
|
||||
self,
|
||||
app: FastAPI,
|
||||
compute_client: AsyncClient,
|
||||
compute_project: Project,
|
||||
base_params: dict,
|
||||
fake_qemu_vm: str):
|
||||
fake_qemu_vm: str
|
||||
):
|
||||
|
||||
params = base_params
|
||||
params["ram"] = 1024
|
||||
@ -130,7 +147,7 @@ async def test_qemu_create_with_params(app: FastAPI,
|
||||
assert response.json()["hda_disk_image_md5sum"] == "fcea920f7412b5da7be0cf42b8c93759"
|
||||
|
||||
|
||||
@pytest.mark.parametrize(
|
||||
@pytest.mark.parametrize(
|
||||
"name, status_code",
|
||||
(
|
||||
("valid-name.com", status.HTTP_201_CREATED),
|
||||
@ -145,15 +162,16 @@ async def test_qemu_create_with_params(app: FastAPI,
|
||||
(("x" * 62 + ".") * 4, status.HTTP_201_CREATED),
|
||||
("xx" + ("x" * 62 + ".") * 4, status.HTTP_409_CONFLICT),
|
||||
),
|
||||
)
|
||||
async def test_qemu_create_with_invalid_name(
|
||||
)
|
||||
async def test_qemu_create_with_invalid_name(
|
||||
self,
|
||||
app: FastAPI,
|
||||
compute_client: AsyncClient,
|
||||
compute_project: Project,
|
||||
base_params: dict,
|
||||
name: str,
|
||||
status_code: int
|
||||
) -> None:
|
||||
) -> None:
|
||||
|
||||
base_params["name"] = name
|
||||
response = await compute_client.post(
|
||||
@ -161,29 +179,35 @@ async def test_qemu_create_with_invalid_name(
|
||||
)
|
||||
assert response.status_code == status_code
|
||||
|
||||
# async def test_qemu_create_with_project_file(app: FastAPI,
|
||||
# compute_client: AsyncClient,
|
||||
# compute_project: Project,
|
||||
# base_params: dict,
|
||||
# fake_qemu_vm: str) -> None:
|
||||
#
|
||||
# response = await compute_client.post(
|
||||
# app.url_path_for("compute:write_compute_project_file", project_id=compute_project.id, file_path="hello.img"),
|
||||
# content=b"world"
|
||||
# )
|
||||
# assert response.status_code == status.HTTP_204_NO_CONTENT
|
||||
# params = base_params
|
||||
# params["hda_disk_image"] = "hello.img"
|
||||
# response = await compute_client.post(
|
||||
# app.url_path_for("compute:create_qemu_node", project_id=compute_project.id),
|
||||
# json=params
|
||||
# )
|
||||
# assert response.status_code == status.HTTP_201_CREATED
|
||||
# assert response.json()["hda_disk_image"] == "hello.img"
|
||||
# assert response.json()["hda_disk_image_md5sum"] == "7d793037a0760186574b0282f2f435e7"
|
||||
# async def test_qemu_create_with_project_file(self, app: FastAPI,
|
||||
# compute_client: AsyncClient,
|
||||
# compute_project: Project,
|
||||
# base_params: dict,
|
||||
# fake_qemu_vm: str) -> None:
|
||||
#
|
||||
# response = await compute_client.post(
|
||||
# app.url_path_for("compute:write_compute_project_file", project_id=compute_project.id, file_path="hello.img"),
|
||||
# content=b"world"
|
||||
# )
|
||||
# assert response.status_code == status.HTTP_204_NO_CONTENT
|
||||
# params = base_params
|
||||
# params["hda_disk_image"] = "hello.img"
|
||||
# response = await compute_client.post(
|
||||
# app.url_path_for("compute:create_qemu_node", project_id=compute_project.id),
|
||||
# json=params
|
||||
# )
|
||||
# assert response.status_code == status.HTTP_201_CREATED
|
||||
# assert response.json()["hda_disk_image"] == "hello.img"
|
||||
# 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(
|
||||
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:
|
||||
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
|
||||
|
||||
|
||||
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:
|
||||
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
|
||||
|
||||
|
||||
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:
|
||||
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
|
||||
|
||||
|
||||
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:
|
||||
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
|
||||
|
||||
|
||||
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:
|
||||
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
|
||||
|
||||
|
||||
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:
|
||||
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
|
||||
|
||||
|
||||
async def test_qemu_update(app: FastAPI,
|
||||
async def test_qemu_update(
|
||||
self,
|
||||
app: FastAPI,
|
||||
compute_client: AsyncClient,
|
||||
qemu_vm: dict,
|
||||
free_console_port: int,
|
||||
fake_qemu_vm: str) -> None:
|
||||
fake_qemu_vm: str
|
||||
) -> None:
|
||||
|
||||
params = {
|
||||
"name": "test",
|
||||
@ -283,7 +310,7 @@ async def test_qemu_update(app: FastAPI,
|
||||
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 = {
|
||||
"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"
|
||||
|
||||
|
||||
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 = {
|
||||
"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"
|
||||
|
||||
|
||||
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 = {
|
||||
"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
|
||||
|
||||
|
||||
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"))
|
||||
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()
|
||||
|
||||
|
||||
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)):
|
||||
|
||||
@ -407,7 +434,7 @@ async def test_upload_image(app: FastAPI, compute_client: AsyncClient, tmpdir: s
|
||||
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)):
|
||||
|
||||
@ -423,14 +450,18 @@ async def test_upload_image_ova(app: FastAPI, compute_client: AsyncClient, tmpdi
|
||||
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",
|
||||
filename="/qemu/images/../../test2"), content=b"TEST")
|
||||
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")
|
||||
assert response.status_code == status.HTTP_204_NO_CONTENT
|
||||
@ -439,15 +470,15 @@ async def test_download_image(app: FastAPI, compute_client: AsyncClient, images_
|
||||
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"
|
||||
response = await compute_client.get(app.url_path_for("compute:download_qemu_image", filename=file_path))
|
||||
assert response.status_code == status.HTTP_403_FORBIDDEN
|
||||
|
||||
|
||||
@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:
|
||||
@pytest.mark.skipif(os.getuid() == 0, reason="Root can delete any image")
|
||||
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:
|
||||
f.write("")
|
||||
@ -457,71 +488,74 @@ async def test_upload_image_permission_denied(app: FastAPI, compute_client: Asyn
|
||||
assert response.status_code == status.HTTP_409_CONFLICT
|
||||
|
||||
|
||||
# @pytest.mark.asyncio
|
||||
# async def test_create_img_relative(app: FastAPI, compute_client: AsyncClient):
|
||||
#
|
||||
# params = {
|
||||
# "qemu_img": "/tmp/qemu-img",
|
||||
# "path": "hda.qcow2",
|
||||
# "format": "qcow2",
|
||||
# "preallocation": "metadata",
|
||||
# "cluster_size": 64,
|
||||
# "refcount_bits": 12,
|
||||
# "lazy_refcounts": "off",
|
||||
# "size": 100
|
||||
# }
|
||||
# with asyncio_patch("gns3server.compute.Qemu.create_disk"):
|
||||
# response = await compute_client.post(app.url_path_for("compute:create_qemu_image"), json=params)
|
||||
# assert response.status_code == status.HTTP_204_NO_CONTENT
|
||||
#
|
||||
#
|
||||
# async def test_create_img_absolute_non_local(app: FastAPI, compute_client: AsyncClient, config) -> None:
|
||||
#
|
||||
# config.settings.Server.local = False
|
||||
# params = {
|
||||
# "qemu_img": "/tmp/qemu-img",
|
||||
# "path": "/tmp/hda.qcow2",
|
||||
# "format": "qcow2",
|
||||
# "preallocation": "metadata",
|
||||
# "cluster_size": 64,
|
||||
# "refcount_bits": 12,
|
||||
# "lazy_refcounts": "off",
|
||||
# "size": 100
|
||||
# }
|
||||
# with asyncio_patch("gns3server.compute.Qemu.create_disk"):
|
||||
# response = await compute_client.post(app.url_path_for("compute:create_qemu_image"), json=params)
|
||||
# assert response.status_code == 403
|
||||
#
|
||||
#
|
||||
# async def test_create_img_absolute_local(app: FastAPI, compute_client: AsyncClient, config) -> None:
|
||||
#
|
||||
# params = {
|
||||
# "qemu_img": "/tmp/qemu-img",
|
||||
# "path": "/tmp/hda.qcow2",
|
||||
# "format": "qcow2",
|
||||
# "preallocation": "metadata",
|
||||
# "cluster_size": 64,
|
||||
# "refcount_bits": 12,
|
||||
# "lazy_refcounts": "off",
|
||||
# "size": 100
|
||||
# }
|
||||
# with asyncio_patch("gns3server.compute.Qemu.create_disk"):
|
||||
# response = await compute_client.post(app.url_path_for("compute:create_qemu_image"), json=params)
|
||||
# assert response.status_code == status.HTTP_204_NO_CONTENT
|
||||
# @pytest.mark.asyncio
|
||||
# async def test_create_img_relative(self, app: FastAPI, compute_client: AsyncClient):
|
||||
#
|
||||
# params = {
|
||||
# "qemu_img": "/tmp/qemu-img",
|
||||
# "path": "hda.qcow2",
|
||||
# "format": "qcow2",
|
||||
# "preallocation": "metadata",
|
||||
# "cluster_size": 64,
|
||||
# "refcount_bits": 12,
|
||||
# "lazy_refcounts": "off",
|
||||
# "size": 100
|
||||
# }
|
||||
# with asyncio_patch("gns3server.compute.Qemu.create_disk"):
|
||||
# response = await compute_client.post(app.url_path_for("compute:create_qemu_image"), json=params)
|
||||
# assert response.status_code == status.HTTP_204_NO_CONTENT
|
||||
#
|
||||
#
|
||||
# async def test_create_img_absolute_non_local(self, app: FastAPI, compute_client: AsyncClient, config) -> None:
|
||||
#
|
||||
# config.settings.Server.local = False
|
||||
# params = {
|
||||
# "qemu_img": "/tmp/qemu-img",
|
||||
# "path": "/tmp/hda.qcow2",
|
||||
# "format": "qcow2",
|
||||
# "preallocation": "metadata",
|
||||
# "cluster_size": 64,
|
||||
# "refcount_bits": 12,
|
||||
# "lazy_refcounts": "off",
|
||||
# "size": 100
|
||||
# }
|
||||
# with asyncio_patch("gns3server.compute.Qemu.create_disk"):
|
||||
# response = await compute_client.post(app.url_path_for("compute:create_qemu_image"), json=params)
|
||||
# assert response.status_code == 403
|
||||
#
|
||||
#
|
||||
# async def test_create_img_absolute_local(self, app: FastAPI, compute_client: AsyncClient, config) -> None:
|
||||
#
|
||||
# params = {
|
||||
# "qemu_img": "/tmp/qemu-img",
|
||||
# "path": "/tmp/hda.qcow2",
|
||||
# "format": "qcow2",
|
||||
# "preallocation": "metadata",
|
||||
# "cluster_size": 64,
|
||||
# "refcount_bits": 12,
|
||||
# "lazy_refcounts": "off",
|
||||
# "size": 100
|
||||
# }
|
||||
# with asyncio_patch("gns3server.compute.Qemu.create_disk"):
|
||||
# response = await compute_client.post(app.url_path_for("compute:create_qemu_image"), json=params)
|
||||
# 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"]):
|
||||
response = await compute_client.get(app.url_path_for("compute:get_qemu_capabilities"))
|
||||
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_project: Project,
|
||||
qemu_vm: dict,
|
||||
base_params: dict) -> None:
|
||||
base_params: dict
|
||||
) -> None:
|
||||
|
||||
# create destination node first
|
||||
response = await compute_client.post(
|
||||
@ -538,13 +572,14 @@ async def test_qemu_duplicate(app: FastAPI,
|
||||
assert response.status_code == status.HTTP_201_CREATED
|
||||
|
||||
|
||||
async def test_qemu_create_disk_image(
|
||||
async def test_qemu_create_disk_image(
|
||||
self,
|
||||
app: FastAPI,
|
||||
compute_client: AsyncClient,
|
||||
compute_project: Project,
|
||||
fake_qemu_img_binary: str,
|
||||
qemu_vm: dict,
|
||||
):
|
||||
):
|
||||
|
||||
options = {
|
||||
"format": "qcow2",
|
||||
@ -586,13 +621,14 @@ 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,
|
||||
compute_client: AsyncClient,
|
||||
compute_project: Project,
|
||||
fake_qemu_img_binary: str,
|
||||
qemu_vm: dict,
|
||||
):
|
||||
):
|
||||
|
||||
node = compute_project.get_node(qemu_vm["node_id"])
|
||||
shutil.copy("tests/resources/empty8G.qcow2", os.path.join(node.working_dir, "disk.qcow2"))
|
||||
@ -614,42 +650,43 @@ async def test_qemu_create_disk_image_already_exists(
|
||||
assert response.status_code == status.HTTP_409_CONFLICT
|
||||
|
||||
|
||||
# async def test_qemu_create_disk_image_with_not_supported_characters_by_filesystem(
|
||||
# app: FastAPI,
|
||||
# compute_client: AsyncClient,
|
||||
# compute_project: Project,
|
||||
# fake_qemu_img_binary: str,
|
||||
# qemu_vm: dict,
|
||||
# ):
|
||||
#
|
||||
# node = compute_project.get_node(qemu_vm["node_id"])
|
||||
# shutil.copy("tests/resources/empty8G.qcow2", os.path.join(node.working_dir, "disk.qcow2"))
|
||||
#
|
||||
# options = {
|
||||
# "format": "qcow2",
|
||||
# "size": 100
|
||||
# }
|
||||
#
|
||||
# with patch("os.path.exists", side_effect=UnicodeEncodeError('error', u"", 1, 2, 'Emulated Unicode Err')):
|
||||
# response = await compute_client.post(
|
||||
# app.url_path_for(
|
||||
# "compute:create_qemu_disk_image",
|
||||
# project_id=qemu_vm["project_id"],
|
||||
# node_id=qemu_vm["node_id"],
|
||||
# disk_name=u"\u2019"
|
||||
# ),
|
||||
# json=options
|
||||
# )
|
||||
# assert response.status_code == status.HTTP_409_CONFLICT
|
||||
# async def test_qemu_create_disk_image_with_not_supported_characters_by_filesystem(
|
||||
# app: FastAPI,
|
||||
# compute_client: AsyncClient,
|
||||
# compute_project: Project,
|
||||
# fake_qemu_img_binary: str,
|
||||
# qemu_vm: dict,
|
||||
# ):
|
||||
#
|
||||
# node = compute_project.get_node(qemu_vm["node_id"])
|
||||
# shutil.copy("tests/resources/empty8G.qcow2", os.path.join(node.working_dir, "disk.qcow2"))
|
||||
#
|
||||
# options = {
|
||||
# "format": "qcow2",
|
||||
# "size": 100
|
||||
# }
|
||||
#
|
||||
# with patch("os.path.exists", side_effect=UnicodeEncodeError('error', u"", 1, 2, 'Emulated Unicode Err')):
|
||||
# response = await compute_client.post(
|
||||
# app.url_path_for(
|
||||
# "compute:create_qemu_disk_image",
|
||||
# project_id=qemu_vm["project_id"],
|
||||
# node_id=qemu_vm["node_id"],
|
||||
# disk_name=u"\u2019"
|
||||
# ),
|
||||
# json=options
|
||||
# )
|
||||
# assert response.status_code == status.HTTP_409_CONFLICT
|
||||
|
||||
|
||||
async def test_qemu_update_disk_image(
|
||||
async def test_qemu_update_disk_image(
|
||||
self,
|
||||
app: FastAPI,
|
||||
compute_client: AsyncClient,
|
||||
compute_project: Project,
|
||||
fake_qemu_img_binary: str,
|
||||
qemu_vm: dict,
|
||||
) -> None:
|
||||
) -> None:
|
||||
|
||||
node = compute_project.get_node(qemu_vm["node_id"])
|
||||
shutil.copy("tests/resources/empty8G.qcow2", os.path.join(node.working_dir, "disk.qcow2"))
|
||||
@ -676,12 +713,13 @@ async def test_qemu_update_disk_image(
|
||||
)
|
||||
|
||||
|
||||
async def test_qemu_delete_disk_image(
|
||||
async def test_qemu_delete_disk_image(
|
||||
self,
|
||||
app: FastAPI,
|
||||
compute_client: AsyncClient,
|
||||
compute_project: Project,
|
||||
qemu_vm: dict,
|
||||
) -> None:
|
||||
) -> None:
|
||||
|
||||
node = compute_project.get_node(qemu_vm["node_id"])
|
||||
shutil.copy("tests/resources/empty8G.qcow2", os.path.join(node.working_dir, "disk.qcow2"))
|
||||
@ -697,12 +735,13 @@ async def test_qemu_delete_disk_image(
|
||||
assert response.status_code == status.HTTP_204_NO_CONTENT
|
||||
|
||||
|
||||
async def test_qemu_delete_disk_image_missing_image(
|
||||
async def test_qemu_delete_disk_image_missing_image(
|
||||
self,
|
||||
app: FastAPI,
|
||||
compute_client: AsyncClient,
|
||||
compute_project: Project,
|
||||
qemu_vm: dict,
|
||||
) -> None:
|
||||
) -> None:
|
||||
|
||||
response = await compute_client.delete(
|
||||
app.url_path_for(
|
||||
@ -715,8 +754,8 @@ async def test_qemu_delete_disk_image_missing_image(
|
||||
assert response.status_code == status.HTTP_409_CONFLICT
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_qemu_start_capture(app: FastAPI, compute_client: AsyncClient, qemu_vm: dict):
|
||||
@pytest.mark.asyncio
|
||||
async def test_qemu_start_capture(self, app: FastAPI, compute_client: AsyncClient, qemu_vm: dict):
|
||||
|
||||
params = {
|
||||
"capture_file_name": "test.pcap",
|
||||
@ -739,8 +778,8 @@ async def test_qemu_start_capture(app: FastAPI, compute_client: AsyncClient, qem
|
||||
assert "test.pcap" in response.json()["pcap_file_path"]
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_qemu_stop_capture(app: FastAPI, compute_client: AsyncClient, qemu_vm: dict):
|
||||
@pytest.mark.asyncio
|
||||
async def test_qemu_stop_capture(self, app: FastAPI, compute_client: AsyncClient, qemu_vm: dict):
|
||||
|
||||
url = app.url_path_for(
|
||||
"compute:stop_qemu_node_capture",
|
||||
@ -757,10 +796,10 @@ async def test_qemu_stop_capture(app: FastAPI, compute_client: AsyncClient, qemu
|
||||
assert mock.called
|
||||
|
||||
|
||||
# @pytest.mark.asyncio
|
||||
# async def test_qemu_pcap(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.stream_pcap_file"):
|
||||
# response = await compute_client.get("/projects/{project_id}/qemu/nodes/{node_id}/adapters/0/ports/0/pcap".format(project_id=compute_project.id, node_id=vm["node_id"]), raw=True)
|
||||
# assert response.status_code == status.HTTP_200_OK
|
||||
# @pytest.mark.asyncio
|
||||
# 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.stream_pcap_file"):
|
||||
# response = await compute_client.get("/projects/{project_id}/qemu/nodes/{node_id}/adapters/0/ports/0/pcap".format(project_id=compute_project.id, node_id=vm["node_id"]), raw=True)
|
||||
# assert response.status_code == status.HTTP_200_OK
|
||||
|
||||
@ -28,8 +28,10 @@ from gns3server.compute.project import Project
|
||||
pytestmark = pytest.mark.asyncio
|
||||
|
||||
|
||||
@pytest_asyncio.fixture(scope="function")
|
||||
async def vm(app: FastAPI, compute_client: AsyncClient, compute_project: Project) -> None:
|
||||
class TestVirtualBoxNodesRoutes:
|
||||
|
||||
@pytest_asyncio.fixture
|
||||
async def vm(self, app: FastAPI, compute_client: AsyncClient, compute_project: Project) -> None:
|
||||
|
||||
vboxmanage_path = "/fake/VboxManage"
|
||||
params = {
|
||||
@ -48,7 +50,7 @@ async def vm(app: FastAPI, compute_client: AsyncClient, compute_project: Project
|
||||
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 = {
|
||||
"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
|
||||
|
||||
|
||||
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",
|
||||
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
|
||||
|
||||
|
||||
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:
|
||||
|
||||
@ -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
|
||||
|
||||
|
||||
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:
|
||||
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
|
||||
|
||||
|
||||
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:
|
||||
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
|
||||
|
||||
|
||||
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:
|
||||
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
|
||||
|
||||
|
||||
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:
|
||||
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
|
||||
|
||||
|
||||
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 = {
|
||||
"type": "nio_udp",
|
||||
@ -150,26 +152,26 @@ async def test_vbox_nio_create_udp(app: FastAPI, compute_client: AsyncClient, vm
|
||||
assert response.json()["type"] == "nio_udp"
|
||||
|
||||
|
||||
# @pytest.mark.asyncio
|
||||
# async def test_vbox_nio_update_udp(app: FastAPI, compute_client: AsyncClient, vm):
|
||||
#
|
||||
# params = {
|
||||
# "type": "nio_udp",
|
||||
# "lport": 4242,
|
||||
# "rport": 4343,
|
||||
# "rhost": "127.0.0.1",
|
||||
# "filters": {}
|
||||
# }
|
||||
#
|
||||
# with asyncio_patch('gns3server.compute.virtualbox.virtualbox_vm.VirtualBoxVM.ethernet_adapters'):
|
||||
# with asyncio_patch('gns3server.compute.virtualbox.virtualbox_vm.VirtualBoxVM.adapter_remove_nio_binding'):
|
||||
# response = await compute_client.put("/projects/{project_id}/virtualbox/nodes/{node_id}/adapters/0/ports/0/nio".format(project_id=vm["project_id"], node_id=vm["node_id"]), params)
|
||||
#
|
||||
# assert response.status_code == status.HTTP_201_CREATED
|
||||
# assert response.json()["type"] == "nio_udp"
|
||||
# @pytest.mark.asyncio
|
||||
# async def test_vbox_nio_update_udp(self, app: FastAPI, compute_client: AsyncClient, vm):
|
||||
#
|
||||
# params = {
|
||||
# "type": "nio_udp",
|
||||
# "lport": 4242,
|
||||
# "rport": 4343,
|
||||
# "rhost": "127.0.0.1",
|
||||
# "filters": {}
|
||||
# }
|
||||
#
|
||||
# with asyncio_patch('gns3server.compute.virtualbox.virtualbox_vm.VirtualBoxVM.ethernet_adapters'):
|
||||
# with asyncio_patch('gns3server.compute.virtualbox.virtualbox_vm.VirtualBoxVM.adapter_remove_nio_binding'):
|
||||
# response = await compute_client.put("/projects/{project_id}/virtualbox/nodes/{node_id}/adapters/0/ports/0/nio".format(project_id=vm["project_id"], node_id=vm["node_id"]), params)
|
||||
#
|
||||
# assert response.status_code == status.HTTP_201_CREATED
|
||||
# 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",
|
||||
project_id=vm["project_id"],
|
||||
@ -185,8 +187,8 @@ async def test_vbox_delete_nio(app: FastAPI, compute_client: AsyncClient, vm: di
|
||||
assert response.status_code == status.HTTP_204_NO_CONTENT
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_vbox_update(app: FastAPI, compute_client: AsyncClient, vm, free_console_port):
|
||||
@pytest.mark.asyncio
|
||||
async def test_vbox_update(self, app: FastAPI, compute_client: AsyncClient, vm, free_console_port):
|
||||
|
||||
params = {
|
||||
"name": "test",
|
||||
@ -201,8 +203,8 @@ async def test_vbox_update(app: FastAPI, compute_client: AsyncClient, vm, free_c
|
||||
assert response.json()["console"] == free_console_port
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_virtualbox_start_capture(app: FastAPI, compute_client: AsyncClient, vm):
|
||||
@pytest.mark.asyncio
|
||||
async def test_virtualbox_start_capture(self, app: FastAPI, compute_client: AsyncClient, vm):
|
||||
|
||||
params = {
|
||||
"capture_file_name": "test.pcap",
|
||||
@ -223,8 +225,8 @@ async def test_virtualbox_start_capture(app: FastAPI, compute_client: AsyncClien
|
||||
assert "test.pcap" in response.json()["pcap_file_path"]
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_virtualbox_stop_capture(app: FastAPI, compute_client: AsyncClient, vm):
|
||||
@pytest.mark.asyncio
|
||||
async def test_virtualbox_stop_capture(self, app: FastAPI, compute_client: AsyncClient, vm):
|
||||
|
||||
url = app.url_path_for("compute:stop_virtualbox_node_capture",
|
||||
project_id=vm["project_id"],
|
||||
@ -239,10 +241,10 @@ async def test_virtualbox_stop_capture(app: FastAPI, compute_client: AsyncClient
|
||||
assert mock.called
|
||||
|
||||
|
||||
# @pytest.mark.asyncio
|
||||
# async def test_virtualbox_pcap(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.stream_pcap_file"):
|
||||
# response = await compute_client.get("/projects/{project_id}/virtualbox/nodes/{node_id}/adapters/0/ports/0/pcap".format(project_id=compute_project.id, node_id=vm["node_id"]), raw=True)
|
||||
# assert response.status_code == status.HTTP_200_OK
|
||||
# @pytest.mark.asyncio
|
||||
# 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.stream_pcap_file"):
|
||||
# response = await compute_client.get("/projects/{project_id}/virtualbox/nodes/{node_id}/adapters/0/ports/0/pcap".format(project_id=compute_project.id, node_id=vm["node_id"]), raw=True)
|
||||
# assert response.status_code == status.HTTP_200_OK
|
||||
|
||||
@ -28,8 +28,10 @@ from gns3server.compute.project import Project
|
||||
pytestmark = pytest.mark.asyncio
|
||||
|
||||
|
||||
@pytest_asyncio.fixture(scope="function")
|
||||
async def vm(app: FastAPI, compute_client: AsyncClient, compute_project: Project, vmx_path: str) -> dict:
|
||||
class TestVMwareNodesRoutes:
|
||||
|
||||
@pytest_asyncio.fixture
|
||||
async def vm(self, app: FastAPI, compute_client: AsyncClient, compute_project: Project, vmx_path: str) -> dict:
|
||||
|
||||
params = {
|
||||
"name": "VMTEST",
|
||||
@ -45,8 +47,8 @@ async def vm(app: FastAPI, compute_client: AsyncClient, compute_project: Project
|
||||
return response.json()
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def vmx_path(tmpdir: str) -> str:
|
||||
@pytest.fixture
|
||||
def vmx_path(self, tmpdir: str) -> str:
|
||||
"""
|
||||
Return a fake VMX file
|
||||
"""
|
||||
@ -57,7 +59,13 @@ def vmx_path(tmpdir: str) -> str:
|
||||
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 = {
|
||||
"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
|
||||
|
||||
|
||||
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"]))
|
||||
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
|
||||
|
||||
|
||||
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:
|
||||
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
|
||||
|
||||
|
||||
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:
|
||||
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
|
||||
|
||||
|
||||
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:
|
||||
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
|
||||
|
||||
|
||||
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:
|
||||
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
|
||||
|
||||
|
||||
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:
|
||||
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
|
||||
|
||||
|
||||
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 = {
|
||||
"type": "nio_udp",
|
||||
@ -156,26 +170,26 @@ async def test_vmware_nio_create_udp(app: FastAPI, compute_client: AsyncClient,
|
||||
assert response.json()["type"] == "nio_udp"
|
||||
|
||||
|
||||
# @pytest.mark.asyncio
|
||||
# async def test_vmware_nio_update_udp(app: FastAPI, compute_client: AsyncClient, vm):
|
||||
#
|
||||
# params = {
|
||||
# "type": "nio_udp",
|
||||
# "lport": 4242,
|
||||
# "rport": 4343,
|
||||
# "rhost": "127.0.0.1",
|
||||
# "filters": {}
|
||||
# }
|
||||
#
|
||||
# with asyncio_patch('gns3server.compute.vmware.vmware_vm.VMwareVM._ubridge_send'):
|
||||
# with asyncio_patch('gns3server.compute.vmware.vmware_vm.VMwareVM.ethernet_adapters'):
|
||||
# with patch('gns3server.compute.vmware.vmware_vm.VMwareVM._get_vnet') as mock:
|
||||
# response = await compute_client.put("/projects/{project_id}/vmware/nodes/{node_id}/adapters/0/ports/0/nio".format(project_id=vm["project_id"], node_id=vm["node_id"]), params)
|
||||
# assert response.status_code == status.HTTP_201_CREATED
|
||||
# assert response.json()["type"] == "nio_udp"
|
||||
# @pytest.mark.asyncio
|
||||
# async def test_vmware_nio_update_udp(self, app: FastAPI, compute_client: AsyncClient, vm):
|
||||
#
|
||||
# params = {
|
||||
# "type": "nio_udp",
|
||||
# "lport": 4242,
|
||||
# "rport": 4343,
|
||||
# "rhost": "127.0.0.1",
|
||||
# "filters": {}
|
||||
# }
|
||||
#
|
||||
# with asyncio_patch('gns3server.compute.vmware.vmware_vm.VMwareVM._ubridge_send'):
|
||||
# with asyncio_patch('gns3server.compute.vmware.vmware_vm.VMwareVM.ethernet_adapters'):
|
||||
# with patch('gns3server.compute.vmware.vmware_vm.VMwareVM._get_vnet') as mock:
|
||||
# response = await compute_client.put("/projects/{project_id}/vmware/nodes/{node_id}/adapters/0/ports/0/nio".format(project_id=vm["project_id"], node_id=vm["node_id"]), params)
|
||||
# assert response.status_code == status.HTTP_201_CREATED
|
||||
# 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",
|
||||
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
|
||||
|
||||
|
||||
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 = {
|
||||
"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
|
||||
|
||||
|
||||
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 = {
|
||||
"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"]
|
||||
|
||||
|
||||
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",
|
||||
project_id=vm["project_id"],
|
||||
@ -244,10 +264,10 @@ async def test_vmware_stop_capture(app: FastAPI, compute_client: AsyncClient, vm
|
||||
assert mock.called
|
||||
|
||||
|
||||
# @pytest.mark.asyncio
|
||||
# async def test_vmware_pcap(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.stream_pcap_file"):
|
||||
# response = await compute_client.get("/projects/{project_id}/vmware/nodes/{node_id}/adapters/0/ports/0/pcap".format(project_id=compute_project.id, node_id=vm["node_id"]), raw=True)
|
||||
# assert response.status_code == status.HTTP_200_OK
|
||||
# @pytest.mark.asyncio
|
||||
# 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.stream_pcap_file"):
|
||||
# response = await compute_client.get("/projects/{project_id}/vmware/nodes/{node_id}/adapters/0/ports/0/pcap".format(project_id=compute_project.id, node_id=vm["node_id"]), raw=True)
|
||||
# assert response.status_code == status.HTTP_200_OK
|
||||
|
||||
@ -28,8 +28,10 @@ from gns3server.compute.project import Project
|
||||
pytestmark = pytest.mark.asyncio
|
||||
|
||||
|
||||
@pytest_asyncio.fixture
|
||||
async def vm(app: FastAPI, compute_client: AsyncClient, compute_project: Project) -> None:
|
||||
class TestVPCSNodesRoutes:
|
||||
|
||||
@pytest_asyncio.fixture
|
||||
async def vm(self, app: FastAPI, compute_client: AsyncClient, compute_project: Project) -> None:
|
||||
|
||||
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)
|
||||
@ -37,7 +39,7 @@ async def vm(app: FastAPI, compute_client: AsyncClient, compute_project: Project
|
||||
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"}
|
||||
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
|
||||
|
||||
|
||||
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"]))
|
||||
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"
|
||||
|
||||
|
||||
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 = {
|
||||
"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
|
||||
|
||||
|
||||
async def test_vpcs_create_port(app: FastAPI,
|
||||
async def test_vpcs_create_port(
|
||||
self,
|
||||
app: FastAPI,
|
||||
compute_client: AsyncClient,
|
||||
compute_project: Project,
|
||||
free_console_port: int) -> None:
|
||||
free_console_port: int
|
||||
) -> None:
|
||||
|
||||
params = {
|
||||
"name": "PC TEST 1",
|
||||
@ -85,7 +101,7 @@ async def test_vpcs_create_port(app: FastAPI,
|
||||
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 = {
|
||||
"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"
|
||||
|
||||
|
||||
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 = {
|
||||
"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"
|
||||
|
||||
|
||||
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 = {
|
||||
"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
|
||||
|
||||
|
||||
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:
|
||||
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
|
||||
|
||||
|
||||
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:
|
||||
|
||||
@ -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
|
||||
|
||||
|
||||
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:
|
||||
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
|
||||
|
||||
|
||||
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:
|
||||
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
|
||||
|
||||
|
||||
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
|
||||
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
|
||||
|
||||
|
||||
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
|
||||
params = {
|
||||
@ -233,7 +261,7 @@ async def test_vpcs_update(app: FastAPI, compute_client: AsyncClient, vm: dict,
|
||||
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 = {
|
||||
"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"]
|
||||
|
||||
|
||||
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",
|
||||
project_id=vm["project_id"],
|
||||
@ -269,10 +297,10 @@ async def test_vpcs_stop_capture(app: FastAPI, compute_client: AsyncClient, vm:
|
||||
assert mock.called
|
||||
|
||||
|
||||
# @pytest.mark.asyncio
|
||||
# async def test_vpcs_pcap(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.stream_pcap_file"):
|
||||
# response = await compute_client.get("/projects/{project_id}/vpcs/nodes/{node_id}/adapters/0/ports/0/pcap".format(project_id=compute_project.id, node_id=vm["node_id"]), raw=True)
|
||||
# assert response.status_code == status.HTTP_200_OK
|
||||
# @pytest.mark.asyncio
|
||||
# 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.stream_pcap_file"):
|
||||
# response = await compute_client.get("/projects/{project_id}/vpcs/nodes/{node_id}/adapters/0/ports/0/pcap".format(project_id=compute_project.id, node_id=vm["node_id"]), raw=True)
|
||||
# assert response.status_code == status.HTTP_200_OK
|
||||
|
||||
@ -27,7 +27,9 @@ from gns3server.config import Config
|
||||
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()
|
||||
config.settings.Server.local = True
|
||||
@ -36,34 +38,34 @@ async def test_shutdown_local(app: FastAPI, client: AsyncClient, config: Config)
|
||||
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"))
|
||||
assert response.status_code == status.HTTP_403_FORBIDDEN
|
||||
|
||||
|
||||
# @pytest.mark.asyncio
|
||||
# async def test_debug(controller_api, config, tmpdir):
|
||||
#
|
||||
# config._main_config_file = str(tmpdir / "test.conf")
|
||||
# config.set("Server", "local", True)
|
||||
# response = await controller_api.post('/debug')
|
||||
# assert response.status_code == 201
|
||||
# debug_dir = os.path.join(config.config_dir, "debug")
|
||||
# assert os.path.exists(debug_dir)
|
||||
# assert os.path.exists(os.path.join(debug_dir, "controller.txt"))
|
||||
#
|
||||
#
|
||||
# @pytest.mark.asyncio
|
||||
# async def test_debug_non_local(controller_api, config, tmpdir):
|
||||
#
|
||||
# config._main_config_file = str(tmpdir / "test.conf")
|
||||
# config.set("Server", "local", False)
|
||||
# response = await controller_api.post('/debug')
|
||||
# assert response.status_code == 403
|
||||
# @pytest.mark.asyncio
|
||||
# async def test_debug(controller_api, config, tmpdir):
|
||||
#
|
||||
# config._main_config_file = str(tmpdir / "test.conf")
|
||||
# config.set("Server", "local", True)
|
||||
# response = await controller_api.post('/debug')
|
||||
# assert response.status_code == 201
|
||||
# debug_dir = os.path.join(config.config_dir, "debug")
|
||||
# assert os.path.exists(debug_dir)
|
||||
# assert os.path.exists(os.path.join(debug_dir, "controller.txt"))
|
||||
#
|
||||
#
|
||||
# @pytest.mark.asyncio
|
||||
# async def test_debug_non_local(controller_api, config, tmpdir):
|
||||
#
|
||||
# config._main_config_file = str(tmpdir / "test.conf")
|
||||
# config.set("Server", "local", False)
|
||||
# response = await controller_api.post('/debug')
|
||||
# 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"))
|
||||
assert response.status_code == status.HTTP_200_OK
|
||||
|
||||
@ -26,7 +26,9 @@ from gns3server.controller.project import Project
|
||||
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 = {
|
||||
"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
|
||||
|
||||
|
||||
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 = {
|
||||
"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
|
||||
|
||||
|
||||
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 = {
|
||||
"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
|
||||
|
||||
|
||||
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 = {
|
||||
"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
|
||||
|
||||
|
||||
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)
|
||||
project._drawings = {drawing.id: drawing}
|
||||
|
||||
@ -24,7 +24,9 @@ from tests.utils import asyncio_patch
|
||||
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"}]):
|
||||
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"))
|
||||
assert response.status_code == status.HTTP_200_OK
|
||||
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"})
|
||||
assert response.status_code == status.HTTP_200_OK
|
||||
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"))
|
||||
assert response.status_code == status.HTTP_200_OK
|
||||
|
||||
@ -35,8 +35,10 @@ from gns3server.controller.udp_link import UDPLink
|
||||
pytestmark = pytest.mark.asyncio
|
||||
|
||||
|
||||
@pytest_asyncio.fixture
|
||||
async def nodes(compute: Compute, project: Project) -> Tuple[Node, Node]:
|
||||
class TestLinkRoutes:
|
||||
|
||||
@pytest_asyncio.fixture
|
||||
async def nodes(self, compute: Compute, project: Project) -> Tuple[Node, Node]:
|
||||
|
||||
response = MagicMock()
|
||||
response.json = {"console": 2048}
|
||||
@ -49,7 +51,13 @@ async def nodes(compute: Compute, project: Project) -> Tuple[Node, Node]:
|
||||
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
|
||||
|
||||
@ -89,7 +97,13 @@ async def test_create_link(app: FastAPI, client: AsyncClient, project: Project,
|
||||
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.
|
||||
|
||||
@ -127,7 +141,13 @@ async def test_create_link_failure(app: FastAPI, client: AsyncClient, compute: C
|
||||
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
|
||||
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
|
||||
|
||||
|
||||
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
|
||||
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"] == {}
|
||||
|
||||
|
||||
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 = {
|
||||
"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
|
||||
|
||||
|
||||
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 = {
|
||||
"latency": [10],
|
||||
@ -313,7 +351,7 @@ async def test_list_link(app: FastAPI, client: AsyncClient, project: Project, no
|
||||
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)
|
||||
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
|
||||
|
||||
|
||||
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)
|
||||
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
|
||||
|
||||
|
||||
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)
|
||||
project._links = {link.id: link}
|
||||
@ -345,28 +383,28 @@ async def test_stop_capture(app: FastAPI, client: AsyncClient, project: Project)
|
||||
assert response.status_code == status.HTTP_204_NO_CONTENT
|
||||
|
||||
|
||||
# async def test_pcap(controller_api, http_client, project):
|
||||
#
|
||||
# async def pcap_capture():
|
||||
# async with http_client.get(controller_api.get_url("/projects/{}/links/{}/pcap".format(project.id, link.id))) as response:
|
||||
# response.body = await response.content.read(5)
|
||||
# print("READ", response.body)
|
||||
# return response
|
||||
#
|
||||
# with asyncio_patch("gns3server.controller.link.Link.capture_node") as mock:
|
||||
# link = Link(project)
|
||||
# link._capture_file_name = "test"
|
||||
# link._capturing = True
|
||||
# with open(link.capture_file_path, "w+") as f:
|
||||
# f.write("hello")
|
||||
# project._links = {link.id: link}
|
||||
# response = await pcap_capture()
|
||||
# assert mock.called
|
||||
# assert response.status_code == 200
|
||||
# assert b'hello' == response.body
|
||||
# async def test_pcap(controller_api, http_client, project):
|
||||
#
|
||||
# async def pcap_capture():
|
||||
# async with http_client.get(controller_api.get_url("/projects/{}/links/{}/pcap".format(project.id, link.id))) as response:
|
||||
# response.body = await response.content.read(5)
|
||||
# print("READ", response.body)
|
||||
# return response
|
||||
#
|
||||
# with asyncio_patch("gns3server.controller.link.Link.capture_node") as mock:
|
||||
# link = Link(project)
|
||||
# link._capture_file_name = "test"
|
||||
# link._capturing = True
|
||||
# with open(link.capture_file_path, "w+") as f:
|
||||
# f.write("hello")
|
||||
# project._links = {link.id: link}
|
||||
# response = await pcap_capture()
|
||||
# assert mock.called
|
||||
# assert response.status_code == 200
|
||||
# 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)
|
||||
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
|
||||
|
||||
|
||||
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)
|
||||
project._links = {link.id: link}
|
||||
|
||||
@ -31,15 +31,18 @@ from gns3server.controller.compute import Compute
|
||||
pytestmark = pytest.mark.asyncio
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def node(project: Project, compute: Compute) -> Node:
|
||||
class TestNodeRoutes:
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def node(self, project: Project, compute: Compute) -> Node:
|
||||
|
||||
node = Node(project, compute, "test", node_type="vpcs")
|
||||
project._nodes[node.id] = 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.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"]
|
||||
|
||||
|
||||
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.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"
|
||||
|
||||
|
||||
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.json = {"console": 2048}
|
||||
@ -105,7 +114,14 @@ async def test_get_node(app: FastAPI, client: AsyncClient, project: Project, com
|
||||
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.json = {"console": 2048}
|
||||
@ -125,88 +141,162 @@ async def test_update_node(app: FastAPI, client: AsyncClient, project: Project,
|
||||
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()
|
||||
response = await client.post(app.url_path_for("start_all_nodes", project_id=project.id))
|
||||
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()
|
||||
response = await client.post(app.url_path_for("stop_all_nodes", project_id=project.id))
|
||||
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()
|
||||
response = await client.post(app.url_path_for("suspend_all_nodes", project_id=project.id))
|
||||
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()
|
||||
response = await client.post(app.url_path_for("reload_all_nodes", project_id=project.id))
|
||||
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()
|
||||
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
|
||||
|
||||
|
||||
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()
|
||||
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
|
||||
|
||||
|
||||
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()
|
||||
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
|
||||
|
||||
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()
|
||||
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
|
||||
|
||||
|
||||
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()
|
||||
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
|
||||
|
||||
|
||||
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()
|
||||
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
|
||||
|
||||
|
||||
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()
|
||||
response = await client.post(app.url_path_for("unisolate_node", project_id=project.id, node_id=node.id))
|
||||
assert response.status_code == status.HTTP_204_NO_CONTENT
|
||||
|
||||
|
||||
async def test_duplicate_node(
|
||||
async def test_duplicate_node(
|
||||
self,
|
||||
app: FastAPI,
|
||||
client: AsyncClient,
|
||||
project: Project,
|
||||
compute: Compute,
|
||||
node: Node) -> None:
|
||||
node: Node
|
||||
) -> None:
|
||||
|
||||
response = MagicMock()
|
||||
response.json({"console": 2035})
|
||||
@ -217,20 +307,28 @@ async def test_duplicate_node(
|
||||
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()
|
||||
response = await client.delete(app.url_path_for("delete_node", project_id=project.id, node_id=node.id))
|
||||
assert response.status_code == status.HTTP_204_NO_CONTENT
|
||||
|
||||
|
||||
async def test_dynamips_idle_pc(
|
||||
async def test_dynamips_idle_pc(
|
||||
self,
|
||||
app: FastAPI,
|
||||
client: AsyncClient,
|
||||
project: Project,
|
||||
compute: Compute,
|
||||
node: Node
|
||||
) -> None:
|
||||
) -> None:
|
||||
|
||||
response = MagicMock()
|
||||
response.json = {"idlepc": "0x60606f54"}
|
||||
@ -242,25 +340,27 @@ async def test_dynamips_idle_pc(
|
||||
assert response.json()["idlepc"] == "0x60606f54"
|
||||
|
||||
|
||||
async def test_dynamips_idle_pc_wrong_node_type(
|
||||
async def test_dynamips_idle_pc_wrong_node_type(
|
||||
self,
|
||||
app: FastAPI,
|
||||
client: AsyncClient,
|
||||
project: Project,
|
||||
compute: Compute,
|
||||
node: Node
|
||||
) -> None:
|
||||
) -> None:
|
||||
|
||||
response = await client.get(app.url_path_for("auto_idlepc", project_id=project.id, node_id=node.id))
|
||||
assert response.status_code == status.HTTP_400_BAD_REQUEST
|
||||
|
||||
|
||||
async def test_dynamips_idlepc_proposals(
|
||||
async def test_dynamips_idlepc_proposals(
|
||||
self,
|
||||
app: FastAPI,
|
||||
client: AsyncClient,
|
||||
project: Project,
|
||||
compute: Compute,
|
||||
node: Node
|
||||
) -> None:
|
||||
) -> None:
|
||||
|
||||
response = MagicMock()
|
||||
response.json = ["0x60606f54", "0x33805a22"]
|
||||
@ -272,25 +372,27 @@ async def test_dynamips_idlepc_proposals(
|
||||
assert response.json() == ["0x60606f54", "0x33805a22"]
|
||||
|
||||
|
||||
async def test_dynamips_idlepc_proposals_wrong_node_type(
|
||||
async def test_dynamips_idlepc_proposals_wrong_node_type(
|
||||
self,
|
||||
app: FastAPI,
|
||||
client: AsyncClient,
|
||||
project: Project,
|
||||
compute: Compute,
|
||||
node: Node
|
||||
) -> None:
|
||||
) -> None:
|
||||
|
||||
response = await client.get(app.url_path_for("idlepc_proposals", project_id=project.id, node_id=node.id))
|
||||
assert response.status_code == status.HTTP_400_BAD_REQUEST
|
||||
|
||||
|
||||
async def test_qemu_disk_image_create(
|
||||
async def test_qemu_disk_image_create(
|
||||
self,
|
||||
app: FastAPI,
|
||||
client: AsyncClient,
|
||||
project: Project,
|
||||
compute: Compute,
|
||||
node: Node
|
||||
) -> None:
|
||||
) -> None:
|
||||
|
||||
response = MagicMock()
|
||||
compute.post = AsyncioMagicMock(return_value=response)
|
||||
@ -303,13 +405,14 @@ async def test_qemu_disk_image_create(
|
||||
assert response.status_code == status.HTTP_204_NO_CONTENT
|
||||
|
||||
|
||||
async def test_qemu_disk_image_create_wrong_node_type(
|
||||
async def test_qemu_disk_image_create_wrong_node_type(
|
||||
self,
|
||||
app: FastAPI,
|
||||
client: AsyncClient,
|
||||
project: Project,
|
||||
compute: Compute,
|
||||
node: Node
|
||||
) -> None:
|
||||
) -> None:
|
||||
|
||||
response = await client.post(
|
||||
app.url_path_for("create_disk_image", project_id=project.id, node_id=node.id, disk_name="hda_disk.qcow2"),
|
||||
@ -318,13 +421,14 @@ async def test_qemu_disk_image_create_wrong_node_type(
|
||||
assert response.status_code == status.HTTP_400_BAD_REQUEST
|
||||
|
||||
|
||||
async def test_qemu_disk_image_update(
|
||||
async def test_qemu_disk_image_update(
|
||||
self,
|
||||
app: FastAPI,
|
||||
client: AsyncClient,
|
||||
project: Project,
|
||||
compute: Compute,
|
||||
node: Node
|
||||
) -> None:
|
||||
) -> None:
|
||||
|
||||
response = MagicMock()
|
||||
compute.put = AsyncioMagicMock(return_value=response)
|
||||
@ -337,13 +441,14 @@ async def test_qemu_disk_image_update(
|
||||
assert response.status_code == status.HTTP_204_NO_CONTENT
|
||||
|
||||
|
||||
async def test_qemu_disk_image_update_wrong_node_type(
|
||||
async def test_qemu_disk_image_update_wrong_node_type(
|
||||
self,
|
||||
app: FastAPI,
|
||||
client: AsyncClient,
|
||||
project: Project,
|
||||
compute: Compute,
|
||||
node: Node
|
||||
) -> None:
|
||||
) -> None:
|
||||
|
||||
response = await client.put(
|
||||
app.url_path_for("update_disk_image", project_id=project.id, node_id=node.id, disk_name="hda_disk.qcow2"),
|
||||
@ -352,13 +457,14 @@ async def test_qemu_disk_image_update_wrong_node_type(
|
||||
assert response.status_code == status.HTTP_400_BAD_REQUEST
|
||||
|
||||
|
||||
async def test_qemu_disk_image_delete(
|
||||
async def test_qemu_disk_image_delete(
|
||||
self,
|
||||
app: FastAPI,
|
||||
client: AsyncClient,
|
||||
project: Project,
|
||||
compute: Compute,
|
||||
node: Node
|
||||
) -> None:
|
||||
) -> None:
|
||||
|
||||
response = MagicMock()
|
||||
compute.delete = AsyncioMagicMock(return_value=response)
|
||||
@ -370,13 +476,14 @@ async def test_qemu_disk_image_delete(
|
||||
assert response.status_code == status.HTTP_204_NO_CONTENT
|
||||
|
||||
|
||||
async def test_qemu_disk_image_delete_wrong_node_type(
|
||||
async def test_qemu_disk_image_delete_wrong_node_type(
|
||||
self,
|
||||
app: FastAPI,
|
||||
client: AsyncClient,
|
||||
project: Project,
|
||||
compute: Compute,
|
||||
node: Node
|
||||
) -> None:
|
||||
) -> None:
|
||||
|
||||
response = await client.delete(
|
||||
app.url_path_for("delete_disk_image", project_id=project.id, node_id=node.id, disk_name="hda_disk.qcow2")
|
||||
@ -384,7 +491,14 @@ async def test_qemu_disk_image_delete_wrong_node_type(
|
||||
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.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
|
||||
|
||||
|
||||
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()
|
||||
response = await client.post(app.url_path_for(
|
||||
@ -427,20 +548,20 @@ async def test_post_file(app: FastAPI, client: AsyncClient, project: Project, co
|
||||
assert response.status_code == status.HTTP_404_NOT_FOUND
|
||||
|
||||
|
||||
# @pytest.mark.asyncio
|
||||
# async def test_get_and_post_with_nested_paths_normalization(controller_api, project, node, compute):
|
||||
#
|
||||
# response = MagicMock()
|
||||
# response.body = b"world"
|
||||
# compute.http_query = AsyncioMagicMock(return_value=response)
|
||||
# response = await controller_api.get("/projects/{project_id}/nodes/{node_id}/files/hello\\nested".format(project_id=project.id, node_id=node.id))
|
||||
# assert response.status_code == 200
|
||||
# assert response.content == b'world'
|
||||
#
|
||||
# compute.http_query.assert_called_with("GET", "/projects/{project_id}/files/project-files/vpcs/{node_id}/hello/nested".format(project_id=project.id, node_id=node.id), timeout=None, raw=True)
|
||||
#
|
||||
# compute.http_query = AsyncioMagicMock()
|
||||
# response = await controller_api.post("/projects/{project_id}/nodes/{node_id}/files/hello\\nested".format(project_id=project.id, node_id=node.id), body=b"hello", raw=True)
|
||||
# assert response.status_code == 201
|
||||
#
|
||||
# compute.http_query.assert_called_with("POST", "/projects/{project_id}/files/project-files/vpcs/{node_id}/hello/nested".format(project_id=project.id, node_id=node.id), data=b'hello', timeout=None, raw=True)
|
||||
# @pytest.mark.asyncio
|
||||
# async def test_get_and_post_with_nested_paths_normalization(controller_api, project, node, compute):
|
||||
#
|
||||
# response = MagicMock()
|
||||
# response.body = b"world"
|
||||
# compute.http_query = AsyncioMagicMock(return_value=response)
|
||||
# response = await controller_api.get("/projects/{project_id}/nodes/{node_id}/files/hello\\nested".format(project_id=project.id, node_id=node.id))
|
||||
# assert response.status_code == 200
|
||||
# assert response.content == b'world'
|
||||
#
|
||||
# compute.http_query.assert_called_with("GET", "/projects/{project_id}/files/project-files/vpcs/{node_id}/hello/nested".format(project_id=project.id, node_id=node.id), timeout=None, raw=True)
|
||||
#
|
||||
# compute.http_query = AsyncioMagicMock()
|
||||
# response = await controller_api.post("/projects/{project_id}/nodes/{node_id}/files/hello\\nested".format(project_id=project.id, node_id=node.id), body=b"hello", raw=True)
|
||||
# assert response.status_code == 201
|
||||
#
|
||||
# compute.http_query.assert_called_with("POST", "/projects/{project_id}/files/project-files/vpcs/{node_id}/hello/nested".format(project_id=project.id, node_id=node.id), data=b'hello', timeout=None, raw=True)
|
||||
|
||||
@ -34,8 +34,10 @@ from gns3server.controller.compute import Compute
|
||||
pytestmark = pytest.mark.asyncio
|
||||
|
||||
|
||||
@pytest_asyncio.fixture
|
||||
async def project(app: FastAPI, client: AsyncClient, controller: Controller) -> Project:
|
||||
class TestControllerProjectRoutes:
|
||||
|
||||
@pytest_asyncio.fixture
|
||||
async def project(self, app: FastAPI, client: AsyncClient, controller: Controller) -> Project:
|
||||
|
||||
project_id = str(uuid.uuid4())
|
||||
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)
|
||||
|
||||
|
||||
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"}
|
||||
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"
|
||||
|
||||
|
||||
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"}
|
||||
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"
|
||||
|
||||
|
||||
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"}
|
||||
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"
|
||||
|
||||
|
||||
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 = [
|
||||
{"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 = {
|
||||
'logo': 'logo.png',
|
||||
@ -98,7 +126,7 @@ async def test_create_project_with_supplier(app: FastAPI, client: AsyncClient, c
|
||||
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"}
|
||||
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"
|
||||
|
||||
|
||||
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 = [
|
||||
{"name": "TEST1"},
|
||||
@ -130,7 +163,7 @@ async def test_update_project_with_variables(app: FastAPI, client: AsyncClient,
|
||||
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"}
|
||||
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"
|
||||
|
||||
|
||||
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))
|
||||
assert response.status_code == status.HTTP_200_OK
|
||||
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:
|
||||
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
|
||||
|
||||
|
||||
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())))
|
||||
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:
|
||||
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
|
||||
|
||||
|
||||
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:
|
||||
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
|
||||
|
||||
|
||||
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:
|
||||
response = await client.post(app.url_path_for("load_project"), json={"path": "/tmp/test.gns3"})
|
||||
@ -187,47 +226,53 @@ async def test_load_project(app: FastAPI, client: AsyncClient, project: Project,
|
||||
assert response.json()["project_id"] == project.id
|
||||
|
||||
|
||||
# @pytest.mark.asyncio
|
||||
# async def test_notification(controller_api, http_client, project, controller):
|
||||
#
|
||||
# async with http_client.get(controller_api.get_url("/projects/{project_id}/notifications".format(project_id=project.id))) as response:
|
||||
# response.body = await response.content.read(200)
|
||||
# controller.notification.project_emit("node.created", {"a": "b"})
|
||||
# response.body += await response.content.readany()
|
||||
# assert response.status_code == 200
|
||||
# assert b'"action": "ping"' in response.body
|
||||
# assert b'"cpu_usage_percent"' in response.body
|
||||
# assert b'{"action": "node.created", "event": {"a": "b"}}\n' in response.body
|
||||
# assert project.status_code == "opened"
|
||||
#
|
||||
#
|
||||
# @pytest.mark.asyncio
|
||||
# async def test_notification_invalid_id(controller_api):
|
||||
#
|
||||
# response = await controller_api.get("/projects/{project_id}/notifications".format(project_id=uuid.uuid4()))
|
||||
# assert response.status_code == 404
|
||||
# @pytest.mark.asyncio
|
||||
# async def test_notification(controller_api, http_client, project, controller):
|
||||
#
|
||||
# async with http_client.get(controller_api.get_url("/projects/{project_id}/notifications".format(project_id=project.id))) as response:
|
||||
# response.body = await response.content.read(200)
|
||||
# controller.notification.project_emit("node.created", {"a": "b"})
|
||||
# response.body += await response.content.readany()
|
||||
# assert response.status_code == 200
|
||||
# assert b'"action": "ping"' in response.body
|
||||
# assert b'"cpu_usage_percent"' in response.body
|
||||
# assert b'{"action": "node.created", "event": {"a": "b"}}\n' in response.body
|
||||
# assert project.status_code == "opened"
|
||||
#
|
||||
#
|
||||
# @pytest.mark.asyncio
|
||||
# async def test_notification_invalid_id(controller_api):
|
||||
#
|
||||
# response = await controller_api.get("/projects/{project_id}/notifications".format(project_id=uuid.uuid4()))
|
||||
# assert response.status_code == 404
|
||||
|
||||
|
||||
# @pytest.mark.asyncio
|
||||
# async def test_notification_ws(controller_api, http_client, controller, project):
|
||||
#
|
||||
# ws = await http_client.ws_connect(controller_api.get_url("/projects/{project_id}/notifications/ws".format(project_id=project.id)))
|
||||
# answer = await ws.receive()
|
||||
# answer = json.loads(answer.data)
|
||||
# assert answer["action"] == "ping"
|
||||
#
|
||||
# controller.notification.project_emit("test", {})
|
||||
# answer = await ws.receive()
|
||||
# answer = json.loads(answer.data)
|
||||
# assert answer["action"] == "test"
|
||||
#
|
||||
# if not ws.closed:
|
||||
# await ws.close()
|
||||
#
|
||||
# assert project.status_code == "opened"
|
||||
# @pytest.mark.asyncio
|
||||
# async def test_notification_ws(controller_api, http_client, controller, project):
|
||||
#
|
||||
# ws = await http_client.ws_connect(controller_api.get_url("/projects/{project_id}/notifications/ws".format(project_id=project.id)))
|
||||
# answer = await ws.receive()
|
||||
# answer = json.loads(answer.data)
|
||||
# assert answer["action"] == "ping"
|
||||
#
|
||||
# controller.notification.project_emit("test", {})
|
||||
# answer = await ws.receive()
|
||||
# answer = json.loads(answer.data)
|
||||
# assert answer["action"] == "test"
|
||||
#
|
||||
# if not ws.closed:
|
||||
# await ws.close()
|
||||
#
|
||||
# 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()
|
||||
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")
|
||||
|
||||
|
||||
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()
|
||||
os.makedirs(project.path, exist_ok=True)
|
||||
@ -315,7 +360,7 @@ async def test_export_without_images(app: FastAPI, client: AsyncClient, tmpdir,
|
||||
myzip.getinfo("images/IOS/test.image")
|
||||
|
||||
|
||||
@pytest.mark.parametrize(
|
||||
@pytest.mark.parametrize(
|
||||
"compression, compression_level, status_code",
|
||||
(
|
||||
("none", None, status.HTTP_200_OK),
|
||||
@ -332,8 +377,9 @@ async def test_export_without_images(app: FastAPI, client: AsyncClient, tmpdir,
|
||||
("zstd", 12, status.HTTP_200_OK),
|
||||
("zstd", 23, status.HTTP_400_BAD_REQUEST),
|
||||
)
|
||||
)
|
||||
async def test_export_compression(
|
||||
)
|
||||
async def test_export_compression(
|
||||
self,
|
||||
app: FastAPI,
|
||||
client: AsyncClient,
|
||||
tmpdir,
|
||||
@ -341,7 +387,7 @@ async def test_export_compression(
|
||||
compression: str,
|
||||
compression_level: int,
|
||||
status_code: int
|
||||
) -> None:
|
||||
) -> None:
|
||||
|
||||
project.dump = MagicMock()
|
||||
os.makedirs(project.path, exist_ok=True)
|
||||
@ -376,7 +422,7 @@ async def test_export_compression(
|
||||
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)
|
||||
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
|
||||
|
||||
|
||||
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"
|
||||
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
|
||||
|
||||
|
||||
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"),
|
||||
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
|
||||
|
||||
|
||||
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"
|
||||
response = await client.post(app.url_path_for("write_file", project_id=project.id, file_path=file_path),
|
||||
@ -421,7 +467,8 @@ async def test_write_file_forbidden_location(app: FastAPI, client: AsyncClient,
|
||||
assert response.status_code == status.HTTP_403_FORBIDDEN
|
||||
|
||||
|
||||
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,
|
||||
client: AsyncClient,
|
||||
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
|
||||
|
||||
|
||||
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:
|
||||
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"
|
||||
|
||||
|
||||
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:
|
||||
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"
|
||||
|
||||
|
||||
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"})
|
||||
assert response.status_code == status.HTTP_201_CREATED
|
||||
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
|
||||
params = {
|
||||
|
||||
@ -30,24 +30,26 @@ from gns3server.controller.snapshot import Snapshot
|
||||
pytestmark = pytest.mark.asyncio
|
||||
|
||||
|
||||
@pytest_asyncio.fixture
|
||||
async def project(app: FastAPI, client: AsyncClient, controller: Controller) -> Project:
|
||||
class TestSnapshotRoutes:
|
||||
|
||||
@pytest_asyncio.fixture
|
||||
async def project(self, app: FastAPI, client: AsyncClient, controller: Controller) -> Project:
|
||||
|
||||
u = str(uuid.uuid4())
|
||||
params = {"name": "test", "project_id": u}
|
||||
await client.post(app.url_path_for("create_project"), json=params)
|
||||
project = controller.get_project(u)
|
||||
return project
|
||||
controller_project = controller.get_project(u)
|
||||
return controller_project
|
||||
|
||||
|
||||
@pytest_asyncio.fixture
|
||||
async def snapshot(project: Project):
|
||||
@pytest_asyncio.fixture
|
||||
async def snapshot(self, project: Project):
|
||||
|
||||
snapshot = await project.snapshot("test")
|
||||
return snapshot
|
||||
controller_snapshot = await project.snapshot("test")
|
||||
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"
|
||||
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
|
||||
|
||||
|
||||
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))
|
||||
assert response.status_code == status.HTTP_204_NO_CONTENT
|
||||
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))
|
||||
assert response.status_code == status.HTTP_201_CREATED
|
||||
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"})
|
||||
assert response.status_code == status.HTTP_201_CREATED
|
||||
|
||||
@ -28,7 +28,9 @@ from gns3server.controller import Controller
|
||||
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"))
|
||||
|
||||
@ -41,7 +43,7 @@ async def test_symbols(app: FastAPI, client: AsyncClient) -> None:
|
||||
} 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"
|
||||
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
|
||||
|
||||
|
||||
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")
|
||||
assert response.status_code == status.HTTP_204_NO_CONTENT
|
||||
|
||||
@ -254,22 +254,6 @@ class TestUserLogin:
|
||||
assert "token_type" in response.json()
|
||||
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(
|
||||
"username, password, status_code",
|
||||
(
|
||||
@ -299,7 +283,19 @@ class TestUserLogin:
|
||||
assert response.status_code == status_code
|
||||
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,
|
||||
app: FastAPI,
|
||||
unauthorized_client: AsyncClient,
|
||||
@ -311,15 +307,14 @@ class TestUserLogin:
|
||||
"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
|
||||
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})
|
||||
assert response.status_code == status.HTTP_200_OK
|
||||
|
||||
|
||||
class TestUserMe:
|
||||
|
||||
async def test_authenticated_user_can_retrieve_own_data(
|
||||
@ -336,15 +331,6 @@ class TestUserMe:
|
||||
assert user.email == test_user.email
|
||||
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(
|
||||
self,
|
||||
app: FastAPI,
|
||||
|
||||
@ -25,14 +25,17 @@ from gns3server.version import __version__
|
||||
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"))
|
||||
assert response.status_code == status.HTTP_200_OK
|
||||
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__}
|
||||
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__}
|
||||
|
||||
|
||||
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"}
|
||||
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__)}
|
||||
|
||||
|
||||
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"}
|
||||
response = await client.post(app.url_path_for("check_version"), json=params)
|
||||
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"
|
||||
response = await client.post(app.url_path_for("check_version"), json=params)
|
||||
|
||||
@ -29,13 +29,15 @@ from gns3server.utils.get_resource import get_resource
|
||||
pytestmark = pytest.mark.asyncio
|
||||
|
||||
|
||||
def get_static(filename):
|
||||
class TestIndexRoutes:
|
||||
|
||||
def get_static(self, filename):
|
||||
|
||||
current_dir = os.path.dirname(os.path.abspath(__file__))
|
||||
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"))
|
||||
assert response.status_code == status.HTTP_200_OK
|
||||
@ -44,37 +46,37 @@ async def test_debug(app: FastAPI, client: AsyncClient) -> None:
|
||||
assert __version__ in html
|
||||
|
||||
|
||||
# @pytest.mark.asyncio
|
||||
# async def test_controller(http_client, controller):
|
||||
#
|
||||
# await controller.add_project(name="test")
|
||||
# response = await http_client.get('/controller')
|
||||
# assert "test" in await response.text()
|
||||
# assert response.status_code == 200
|
||||
#
|
||||
#
|
||||
# @pytest.mark.asyncio
|
||||
# async def test_compute(http_client):
|
||||
#
|
||||
# response = await http_client.get('/compute')
|
||||
# assert response.status_code == 200
|
||||
# @pytest.mark.asyncio
|
||||
# async def test_controller(http_client, controller):
|
||||
#
|
||||
# await controller.add_project(name="test")
|
||||
# response = await http_client.get('/controller')
|
||||
# assert "test" in await response.text()
|
||||
# assert response.status_code == 200
|
||||
#
|
||||
#
|
||||
# @pytest.mark.asyncio
|
||||
# async def test_compute(http_client):
|
||||
#
|
||||
# response = await http_client.get('/compute')
|
||||
# assert response.status_code == 200
|
||||
|
||||
|
||||
# @pytest.mark.asyncio
|
||||
# async def test_project(http_client, controller):
|
||||
#
|
||||
# project = await controller.add_project(name="test")
|
||||
# response = await http_client.get('/projects/{}'.format(project.id))
|
||||
# assert response.status_code == 200
|
||||
# @pytest.mark.asyncio
|
||||
# async def test_project(http_client, controller):
|
||||
#
|
||||
# project = await controller.add_project(name="test")
|
||||
# response = await http_client.get('/projects/{}'.format(project.id))
|
||||
# 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"))
|
||||
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:
|
||||
mock.return_value = str(tmpdir)
|
||||
|
||||
@ -44,9 +44,14 @@ ALLOWED_CONTROLLER_ENDPOINTS = [
|
||||
("/v3/symbols/default_symbols", "GET")
|
||||
]
|
||||
|
||||
class TestRoutes:
|
||||
|
||||
# Controller endpoints have a OAuth2 bearer token authentication
|
||||
async def test_controller_endpoints_require_authentication(app: FastAPI, unauthorized_client: AsyncClient) -> None:
|
||||
# Controller endpoints have a OAuth2 bearer token authentication
|
||||
async def test_controller_endpoints_require_authentication(
|
||||
self,
|
||||
app: FastAPI,
|
||||
unauthorized_client: AsyncClient
|
||||
) -> None:
|
||||
|
||||
for route in app.routes:
|
||||
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
|
||||
elif isinstance(route, APIWebSocketRoute):
|
||||
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:
|
||||
json_notification = await ws.receive_json()
|
||||
assert json_notification['event'] == {
|
||||
@ -64,8 +69,12 @@ async def test_controller_endpoints_require_authentication(app: FastAPI, unautho
|
||||
}
|
||||
|
||||
|
||||
# Compute endpoints have a basic HTTP authentication
|
||||
async def test_compute_endpoints_require_authentication(app: FastAPI, unauthorized_client: AsyncClient) -> None:
|
||||
# Compute endpoints have a basic HTTP authentication
|
||||
async def test_compute_endpoints_require_authentication(
|
||||
self,
|
||||
app: FastAPI,
|
||||
unauthorized_client: AsyncClient
|
||||
) -> None:
|
||||
|
||||
for route in app.routes:
|
||||
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)
|
||||
assert response.status_code == status.HTTP_401_UNAUTHORIZED
|
||||
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:
|
||||
json_notification = await ws.receive_json()
|
||||
assert json_notification['event'] == {
|
||||
|
||||
@ -25,6 +25,8 @@ from gns3server.compute.nios.nio_udp import NIOUDP
|
||||
from tests.utils import asyncio_patch
|
||||
|
||||
|
||||
pytestmark = pytest.mark.asyncio
|
||||
|
||||
@pytest.fixture
|
||||
def nio():
|
||||
|
||||
@ -39,7 +41,6 @@ async def manager():
|
||||
return m
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_json_with_ports(on_gns3vm, compute_project, manager):
|
||||
|
||||
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
|
||||
"""
|
||||
@ -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):
|
||||
"""
|
||||
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
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_linux_ethernet_raw_add_nio(linux_platform, compute_project, nio):
|
||||
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):
|
||||
"""
|
||||
Bridge can't be connected directly to a cloud we use a tap in the middle
|
||||
|
||||
@ -1,5 +1,4 @@
|
||||
import pytest
|
||||
import asyncio
|
||||
import pytest_asyncio
|
||||
import tempfile
|
||||
import shutil
|
||||
@ -13,6 +12,7 @@ import stat
|
||||
from fastapi import FastAPI
|
||||
from sqlalchemy.ext.asyncio import AsyncSession, create_async_engine
|
||||
from httpx import AsyncClient
|
||||
from httpx_ws.transport import ASGIWebSocketTransport
|
||||
from unittest.mock import MagicMock, patch
|
||||
from pathlib import Path
|
||||
|
||||
@ -34,25 +34,14 @@ sys._called_from_test = True
|
||||
sys.original_platform = sys.platform
|
||||
|
||||
|
||||
# https://github.com/pytest-dev/pytest-asyncio/issues/68
|
||||
# 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")
|
||||
@pytest_asyncio.fixture(loop_scope="class", scope="class")
|
||||
async def app() -> FastAPI:
|
||||
|
||||
from gns3server.api.server import app as gns3app
|
||||
yield gns3app
|
||||
|
||||
|
||||
@pytest_asyncio.fixture(scope="class")
|
||||
@pytest_asyncio.fixture(loop_scope="class", scope="class")
|
||||
async def db_engine():
|
||||
|
||||
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()
|
||||
|
||||
|
||||
@pytest_asyncio.fixture(scope="class")
|
||||
@pytest_asyncio.fixture(loop_scope="class", scope="class")
|
||||
async def db_session(db_engine):
|
||||
|
||||
# recreate database tables for each class
|
||||
@ -82,7 +71,7 @@ async def db_session(db_engine):
|
||||
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 _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
|
||||
|
||||
async with AsyncClient(
|
||||
app=app,
|
||||
base_url="http://test-api",
|
||||
headers={"Content-Type": "application/json"}
|
||||
headers={"Content-Type": "application/json"},
|
||||
transport=ASGIWebSocketTransport(app=app)
|
||||
) as async_client:
|
||||
yield async_client
|
||||
|
||||
|
||||
@pytest_asyncio.fixture
|
||||
@pytest_asyncio.fixture(loop_scope="class", scope="class")
|
||||
async def test_user(db_session: AsyncSession) -> User:
|
||||
|
||||
new_user = schemas.UserCreate(
|
||||
@ -121,7 +110,7 @@ async def test_user(db_session: AsyncSession) -> User:
|
||||
return user
|
||||
|
||||
|
||||
@pytest_asyncio.fixture
|
||||
@pytest_asyncio.fixture(loop_scope="class", scope="class")
|
||||
async def test_compute(db_session: AsyncSession) -> Compute:
|
||||
|
||||
new_compute = schemas.ComputeCreate(
|
||||
@ -140,12 +129,12 @@ async def test_compute(db_session: AsyncSession) -> 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:
|
||||
return base_client
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
@pytest_asyncio.fixture(loop_scope="class", scope="class")
|
||||
def authorized_client(base_client: AsyncClient, test_user: User) -> AsyncClient:
|
||||
|
||||
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
|
||||
|
||||
|
||||
@pytest_asyncio.fixture
|
||||
@pytest_asyncio.fixture(loop_scope="class", scope="class")
|
||||
async def client(base_client: AsyncClient) -> AsyncClient:
|
||||
|
||||
# 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
|
||||
|
||||
|
||||
@pytest_asyncio.fixture
|
||||
@pytest_asyncio.fixture(loop_scope="class", scope="class")
|
||||
async def compute_client(base_client: AsyncClient) -> AsyncClient:
|
||||
|
||||
# default compute username is 'gns3'
|
||||
|
||||
2
tests/pytest.ini
Normal file
2
tests/pytest.ini
Normal file
@ -0,0 +1,2 @@
|
||||
[pytest]
|
||||
asyncio_default_fixture_loop_scope=function
|
||||
Loading…
Reference in New Issue
Block a user