mirror of
https://github.com/GNS3/gns3-server.git
synced 2026-11-19 20:55:14 +02:00
The compute translates the container ids in a daemon delete conflict into the GNS3 node and project behind each container. Leftover containers from closed projects and containers created outside GNS3 are named as such. The controller lists the templates referencing the image in the conflict error, matched through the canonical image name. After a successful deletion it emits a docker.image.deleted notification with those templates: their nodes can no longer start.
577 lines
27 KiB
Python
577 lines
27 KiB
Python
#!/usr/bin/env python
|
|
#
|
|
# Copyright (C) 2020 GNS3 Technologies Inc.
|
|
#
|
|
# This program is free software: you can redistribute it and/or modify
|
|
# it under the terms of the GNU General Public License as published by
|
|
# the Free Software Foundation, either version 3 of the License, or
|
|
# (at your option) any later version.
|
|
#
|
|
# This program is distributed in the hope that it will be useful,
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
# GNU General Public License for more details.
|
|
#
|
|
# You should have received a copy of the GNU General Public License
|
|
# along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
import asyncio
|
|
import uuid
|
|
from unittest.mock import MagicMock, patch
|
|
|
|
import pytest
|
|
from fastapi import FastAPI, status
|
|
from httpx import AsyncClient
|
|
|
|
from gns3server.controller import Controller
|
|
from gns3server.controller.controller_error import ComputeConflictError
|
|
from gns3server.schemas.controller.computes import Compute
|
|
|
|
pytestmark = pytest.mark.asyncio
|
|
|
|
from tests.utils import AsyncioMagicMock, asyncio_patch
|
|
|
|
|
|
class TestComputeRoutes:
|
|
async def test_compute_create(self, app: FastAPI, client: AsyncClient) -> None:
|
|
|
|
params = {"protocol": "http", "host": "localhost", "port": 84, "user": "julien", "password": "secure"}
|
|
|
|
response = await client.post(app.url_path_for("create_compute"), json=params)
|
|
assert response.status_code == status.HTTP_201_CREATED
|
|
assert response.json()["compute_id"] is not None
|
|
|
|
del params["password"]
|
|
for param, value in params.items():
|
|
assert response.json()[param] == value
|
|
|
|
async def test_compute_create_with_id(self, app: FastAPI, client: AsyncClient) -> None:
|
|
|
|
compute_id = str(uuid.uuid4())
|
|
params = {
|
|
"compute_id": compute_id,
|
|
"protocol": "http",
|
|
"host": "127.0.0.1",
|
|
"port": 84,
|
|
"user": "julien",
|
|
"password": "secure",
|
|
}
|
|
|
|
response = await client.post(app.url_path_for("create_compute"), json=params)
|
|
assert response.status_code == status.HTTP_201_CREATED
|
|
assert response.json()["compute_id"] == compute_id
|
|
|
|
del params["password"]
|
|
for param, value in params.items():
|
|
assert response.json()[param] == value
|
|
|
|
async def test_compute_list(self, app: FastAPI, client: AsyncClient, test_compute: Compute) -> None:
|
|
|
|
response = await client.get(app.url_path_for("get_computes"))
|
|
assert response.status_code == status.HTTP_200_OK
|
|
assert len(response.json()) > 0
|
|
|
|
async def test_compute_list_filter_by_name(self, app: FastAPI, client: AsyncClient) -> None:
|
|
|
|
for name, port in (("compute-a", 85), ("compute-b", 86)):
|
|
params = {
|
|
"name": name,
|
|
"protocol": "http",
|
|
"host": "localhost",
|
|
"port": port,
|
|
"user": "julien",
|
|
"password": "secure",
|
|
}
|
|
response = await client.post(app.url_path_for("create_compute"), json=params)
|
|
assert response.status_code == status.HTTP_201_CREATED
|
|
|
|
response = await client.get(app.url_path_for("get_computes"), params={"name": "compute-a"})
|
|
assert response.status_code == status.HTTP_200_OK
|
|
assert [c["name"] for c in response.json()] == ["compute-a"]
|
|
|
|
response = await client.get(app.url_path_for("get_computes"), params={"name": "COMPUTE-A"})
|
|
assert response.status_code == status.HTTP_200_OK
|
|
assert response.json() == []
|
|
|
|
response = await client.get(app.url_path_for("get_computes"))
|
|
assert len(response.json()) >= 2
|
|
|
|
async def test_compute_get(self, app: FastAPI, client: AsyncClient, test_compute: Compute) -> None:
|
|
|
|
response = await client.get(app.url_path_for("get_compute", compute_id=test_compute.compute_id))
|
|
assert response.status_code == status.HTTP_200_OK
|
|
assert response.json()["compute_id"] == str(test_compute.compute_id)
|
|
|
|
async def test_compute_get_reports_every_capability(self, app: FastAPI, client: AsyncClient, controller) -> None:
|
|
"""
|
|
The capabilities payload the compute reports must survive the
|
|
response model intact. The local compute is the interesting one: it
|
|
is the controller object serialized straight through, and a second,
|
|
private Capabilities definition in the response schema silently
|
|
stripped the kernel-datapath fields (ubridge_tap, ubridge_iol_tap)
|
|
there — links were then built on a datapath clients could not see.
|
|
"""
|
|
|
|
await controller.add_compute(
|
|
compute_id="local", name="local", host="127.0.0.1", port=3080, force=True, connect=False
|
|
)
|
|
controller.get_compute("local")._capabilities.update(
|
|
{
|
|
"version": "3.1.0",
|
|
"node_types": ["docker"],
|
|
"platform": "linux",
|
|
"cpus": 4,
|
|
"memory": 1024,
|
|
"disk_size": 2048,
|
|
"ubridge_tc": {"netem": ["delay"], "ebpf": True, "ebpf_modes": ["nth"], "cbpf": True},
|
|
"ubridge_tap": True,
|
|
"ubridge_iol_tap": False,
|
|
}
|
|
)
|
|
|
|
response = await client.get(app.url_path_for("get_compute", compute_id="local"))
|
|
assert response.status_code == status.HTTP_200_OK
|
|
capabilities = response.json()["capabilities"]
|
|
assert capabilities["ubridge_tap"] is True
|
|
assert capabilities["ubridge_iol_tap"] is False
|
|
assert capabilities["ubridge_tc"]["netem"] == ["delay"]
|
|
|
|
async def test_compute_get_local(self, app: FastAPI, client: AsyncClient, controller) -> None:
|
|
|
|
await controller.add_compute(
|
|
compute_id="local", name="local", host="127.0.0.1", port=3080, force=True, connect=False
|
|
)
|
|
|
|
response = await client.get(app.url_path_for("get_compute", compute_id="local"))
|
|
assert response.status_code == status.HTTP_200_OK
|
|
assert response.json()["compute_id"] == "local"
|
|
assert response.json()["name"] == "local"
|
|
|
|
async def test_compute_update(self, app: FastAPI, client: AsyncClient, test_compute: Compute) -> None:
|
|
|
|
params = {"protocol": "http", "host": "localhost", "port": 42, "user": "julien", "password": "secure"}
|
|
|
|
response = await client.post(app.url_path_for("create_compute"), json=params)
|
|
assert response.status_code == status.HTTP_201_CREATED
|
|
compute_id = response.json()["compute_id"]
|
|
|
|
params["protocol"] = "https"
|
|
response = await client.put(app.url_path_for("update_compute", compute_id=compute_id), json=params)
|
|
assert response.status_code == status.HTTP_200_OK
|
|
|
|
del params["password"]
|
|
for param, value in params.items():
|
|
assert response.json()[param] == value
|
|
|
|
async def test_compute_delete(self, app: FastAPI, client: AsyncClient, test_compute: Compute) -> None:
|
|
|
|
response = await client.delete(app.url_path_for("delete_compute", compute_id=test_compute.compute_id))
|
|
assert response.status_code == status.HTTP_204_NO_CONTENT
|
|
|
|
|
|
class TestComputeFeatures:
|
|
async def test_compute_list_docker_images(self, app: FastAPI, client: AsyncClient) -> None:
|
|
|
|
params = {"protocol": "http", "host": "localhost", "port": 84, "user": "julien", "password": "secure"}
|
|
|
|
response = await client.post(app.url_path_for("create_compute"), json=params)
|
|
assert response.status_code == status.HTTP_201_CREATED
|
|
compute_id = response.json()["compute_id"]
|
|
|
|
with asyncio_patch(
|
|
"gns3server.controller.compute.Compute.forward", return_value=[{"image": "docker1"}, {"image": "docker2"}]
|
|
) as mock:
|
|
response = await client.get(app.url_path_for("docker_get_images", compute_id=compute_id))
|
|
mock.assert_called_with("GET", "docker", "images")
|
|
assert response.json() == [
|
|
{"image": "docker1", "id": None, "size": None, "created": None},
|
|
{"image": "docker2", "id": None, "size": None, "created": None},
|
|
]
|
|
|
|
async def test_compute_pull_docker_image(self, app: FastAPI, client: AsyncClient, test_compute: Compute) -> None:
|
|
|
|
compute = MagicMock()
|
|
compute.forward = AsyncioMagicMock(return_value={})
|
|
with patch("gns3server.api.routes.controller.computes.Controller.instance") as controller:
|
|
controller.return_value.get_compute.return_value = compute
|
|
response = await client.post(
|
|
app.url_path_for("docker_pull_image", compute_id=test_compute.compute_id),
|
|
json={"image": "nginx:latest"},
|
|
)
|
|
compute.forward.assert_called_with(
|
|
"POST", "docker", "images/pull", data={"image": "nginx:latest"}, params=None
|
|
)
|
|
assert response.status_code == status.HTTP_204_NO_CONTENT
|
|
|
|
async def test_compute_pull_docker_image_progress_id(
|
|
self, app: FastAPI, client: AsyncClient, test_compute: Compute
|
|
) -> None:
|
|
|
|
compute = MagicMock()
|
|
compute.forward = AsyncioMagicMock(return_value={})
|
|
with patch("gns3server.api.routes.controller.computes.Controller.instance") as controller:
|
|
controller.return_value.get_compute.return_value = compute
|
|
response = await client.post(
|
|
app.url_path_for("docker_pull_image", compute_id=test_compute.compute_id),
|
|
json={"image": "nginx:latest"},
|
|
params={"progress_id": "abc123"},
|
|
)
|
|
compute.forward.assert_called_with(
|
|
"POST",
|
|
"docker",
|
|
"images/pull",
|
|
data={"image": "nginx:latest"},
|
|
params={"progress_id": "abc123"},
|
|
)
|
|
assert response.status_code == status.HTTP_204_NO_CONTENT
|
|
|
|
async def test_compute_delete_docker_image(self, app: FastAPI, client: AsyncClient, test_compute: Compute) -> None:
|
|
|
|
compute = MagicMock()
|
|
compute.http_query = AsyncioMagicMock(return_value={})
|
|
with patch("gns3server.api.routes.controller.computes.Controller.instance") as controller:
|
|
controller.return_value.get_compute.return_value = compute
|
|
response = await client.delete(
|
|
app.url_path_for(
|
|
"docker_delete_image",
|
|
compute_id=test_compute.compute_id,
|
|
image="ios-xr/xrd-control-plane:24.4.1",
|
|
),
|
|
params={"force": True},
|
|
)
|
|
compute.http_query.assert_called_once_with(
|
|
"DELETE",
|
|
"/docker/images/ios-xr/xrd-control-plane:24.4.1",
|
|
params={"force": "true"},
|
|
)
|
|
assert response.status_code == status.HTTP_204_NO_CONTENT
|
|
|
|
async def test_compute_delete_docker_image_rejects_path_traversal(
|
|
self, app: FastAPI, client: AsyncClient, test_compute: Compute
|
|
) -> None:
|
|
# percent encoded so the client does not normalize the ".." segments
|
|
# away before the request reaches the server
|
|
compute = MagicMock()
|
|
compute.http_query = AsyncioMagicMock(return_value={})
|
|
with patch("gns3server.api.routes.controller.computes.Controller.instance") as controller:
|
|
controller.return_value.get_compute.return_value = compute
|
|
response = await client.delete(
|
|
f"/v3/computes/{test_compute.compute_id}/docker/images/a%2F..%2F..%2Fversion"
|
|
)
|
|
compute.http_query.assert_not_called()
|
|
assert response.status_code == status.HTTP_422_UNPROCESSABLE_CONTENT
|
|
|
|
async def test_compute_delete_docker_image_conflict_names_referencing_templates(
|
|
self, app: FastAPI, client: AsyncClient, test_compute: Compute
|
|
) -> None:
|
|
"""
|
|
Templates do not block the deletion but are named in the conflict
|
|
error, matched through their image reference spelling.
|
|
"""
|
|
|
|
new_template = {
|
|
"name": "Alpine conflict test",
|
|
"compute_id": "local",
|
|
# a different spelling of the deleted 'alpine:3'
|
|
"image": "docker.io/library/alpine:3",
|
|
"template_type": "docker",
|
|
}
|
|
response = await client.post(app.url_path_for("create_template"), json=new_template)
|
|
assert response.status_code == status.HTTP_201_CREATED
|
|
|
|
compute = MagicMock()
|
|
compute.http_query = AsyncioMagicMock(
|
|
side_effect=ComputeConflictError(
|
|
"http://localhost:3080/docker/images/alpine:3",
|
|
{
|
|
"message": "Cannot delete image 'alpine:3': it is still used by node 'alpine-1' "
|
|
"in project 'lab' (running). Delete the node or container first, or repeat with force=true."
|
|
},
|
|
)
|
|
)
|
|
with patch("gns3server.api.routes.controller.computes.Controller.instance") as controller:
|
|
controller.return_value.get_compute.return_value = compute
|
|
response = await client.delete(
|
|
app.url_path_for("docker_delete_image", compute_id=test_compute.compute_id, image="alpine:3")
|
|
)
|
|
assert response.status_code == status.HTTP_409_CONFLICT
|
|
message = response.json()["message"]
|
|
assert "node 'alpine-1' in project 'lab'" in message
|
|
assert "referenced by template(s): Alpine conflict test" in message
|
|
|
|
async def test_compute_delete_docker_image_notifies_referencing_templates(
|
|
self, app: FastAPI, client: AsyncClient, test_compute: Compute
|
|
) -> None:
|
|
"""
|
|
A successful deletion emits a docker.image.deleted notification with
|
|
the templates referencing the deleted image.
|
|
"""
|
|
|
|
new_template = {
|
|
"name": "Alpine delete test",
|
|
"compute_id": "local",
|
|
# an image no other test in this class references: the assertion
|
|
# below is exact and the class shares one database
|
|
"image": "gns3/delete-event-test:1",
|
|
"template_type": "docker",
|
|
}
|
|
response = await client.post(app.url_path_for("create_template"), json=new_template)
|
|
assert response.status_code == status.HTTP_201_CREATED
|
|
|
|
compute = MagicMock()
|
|
compute.http_query = AsyncioMagicMock(return_value={})
|
|
with patch("gns3server.api.routes.controller.computes.Controller.instance") as controller:
|
|
controller.return_value.get_compute.return_value = compute
|
|
response = await client.delete(
|
|
app.url_path_for(
|
|
"docker_delete_image", compute_id=test_compute.compute_id, image="gns3/delete-event-test:1"
|
|
)
|
|
)
|
|
assert response.status_code == status.HTTP_204_NO_CONTENT
|
|
controller.return_value.notification.controller_emit.assert_called_once_with(
|
|
"docker.image.deleted",
|
|
{
|
|
"compute_id": str(test_compute.compute_id),
|
|
"image": "gns3/delete-event-test:1",
|
|
"referenced_by_templates": ["Alpine delete test"],
|
|
},
|
|
)
|
|
|
|
async def test_compute_load_docker_image(self, app: FastAPI, client: AsyncClient, test_compute: Compute) -> None:
|
|
|
|
compute = MagicMock()
|
|
compute.http_query = AsyncioMagicMock(return_value={})
|
|
with patch("gns3server.api.routes.controller.computes.Controller.instance") as controller:
|
|
controller.return_value.get_compute.return_value = compute
|
|
response = await client.post(
|
|
app.url_path_for("docker_load_image", compute_id=test_compute.compute_id),
|
|
content=b"docker save tar data",
|
|
headers={"Content-Type": "application/octet-stream"},
|
|
)
|
|
compute.http_query.assert_called_once()
|
|
args, kwargs = compute.http_query.call_args
|
|
assert args[0] == "POST"
|
|
assert args[1] == "/docker/images/load"
|
|
assert kwargs["timeout"] is None
|
|
# the request body must be streamed, not buffered
|
|
assert hasattr(kwargs["data"], "__aiter__")
|
|
assert response.status_code == status.HTTP_204_NO_CONTENT
|
|
|
|
async def test_compute_list_virtualbox_vms(self, app: FastAPI, client: AsyncClient) -> None:
|
|
|
|
params = {"protocol": "http", "host": "localhost", "port": 4242, "user": "julien", "password": "secure"}
|
|
response = await client.post(app.url_path_for("get_computes"), json=params)
|
|
assert response.status_code == status.HTTP_201_CREATED
|
|
compute_id = response.json()["compute_id"]
|
|
|
|
with asyncio_patch("gns3server.controller.compute.Compute.forward", return_value=[]) as mock:
|
|
response = await client.get(app.url_path_for("virtualbox_vms", compute_id=compute_id))
|
|
mock.assert_called_with("GET", "virtualbox", "vms")
|
|
assert response.json() == []
|
|
|
|
async def test_compute_list_vmware_vms(self, app: FastAPI, client: AsyncClient) -> None:
|
|
|
|
params = {"protocol": "http", "host": "localhost", "port": 4243, "user": "julien", "password": "secure"}
|
|
response = await client.post(app.url_path_for("get_computes"), json=params)
|
|
assert response.status_code == status.HTTP_201_CREATED
|
|
compute_id = response.json()["compute_id"]
|
|
|
|
with asyncio_patch("gns3server.controller.compute.Compute.forward", return_value=[]) as mock:
|
|
response = await client.get(app.url_path_for("vmware_vms", compute_id=compute_id))
|
|
mock.assert_called_with("GET", "vmware", "vms")
|
|
assert response.json() == []
|
|
|
|
# async def test_compute_create_img(self, app: FastAPI, client: AsyncClient) -> None:
|
|
#
|
|
# params = {
|
|
# "protocol": "http",
|
|
# "host": "localhost",
|
|
# "port": 4284,
|
|
# "user": "julien",
|
|
# "password": "secure"
|
|
# }
|
|
#
|
|
# response = await client.post(app.url_path_for("get_computes"), json=params)
|
|
# assert response.status_code == status.HTTP_201_CREATED
|
|
# compute_id = response.json()["compute_id"]
|
|
#
|
|
# params = {"path": "/test"}
|
|
# with asyncio_patch("gns3server.controller.compute.Compute.forward", return_value=[]) as mock:
|
|
# response = await client.post(app.url_path_for("get_compute", compute_id=compute_id) + "/qemu/img", json=params)
|
|
# assert response.json() == []
|
|
# mock.assert_called_with("POST", "qemu", "img", data=unittest.mock.ANY)
|
|
|
|
# async def test_compute_autoidlepc(self, app: FastAPI, client: AsyncClient) -> None:
|
|
#
|
|
# params = {
|
|
# "protocol": "http",
|
|
# "host": "localhost",
|
|
# "port": 84,
|
|
# "user": "julien",
|
|
# "password": "secure"
|
|
# }
|
|
#
|
|
# response = await client.post(app.url_path_for("get_computes"), json=params)
|
|
# assert response.status_code == status.HTTP_201_CREATED
|
|
# compute_id = response.json()["compute_id"]
|
|
#
|
|
# params = {
|
|
# "platform": "c7200",
|
|
# "image": "test.bin",
|
|
# "ram": 512
|
|
# }
|
|
#
|
|
# with asyncio_patch("gns3server.controller.Controller.autoidlepc", return_value={"idlepc": "0x606de20c"}) as mock:
|
|
# response = await client.post(app.url_path_for("autoidlepc", compute_id=compute_id) + "/auto_idlepc", json=params)
|
|
# assert mock.called
|
|
# assert response.status_code == status.HTTP_200_OK
|
|
|
|
|
|
class TestComputeAutoConnect:
|
|
async def test_compute_create_with_auto_connect(self, app: FastAPI, client: AsyncClient) -> None:
|
|
|
|
params = {
|
|
"protocol": "http",
|
|
"host": "localhost",
|
|
"port": 84,
|
|
"user": "julien",
|
|
"password": "secure",
|
|
"auto_connect": True,
|
|
}
|
|
|
|
with patch("gns3server.controller.compute.Compute.connect", new_callable=AsyncioMagicMock) as connect_mock:
|
|
response = await client.post(app.url_path_for("create_compute"), json=params)
|
|
assert response.status_code == status.HTTP_201_CREATED
|
|
assert response.json()["auto_connect"] is True
|
|
# the create request returns immediately, the connection happens
|
|
# in the background
|
|
await asyncio.sleep(0)
|
|
assert connect_mock.call_count == 1
|
|
|
|
# persisted, not just echoed back
|
|
compute_id = response.json()["compute_id"]
|
|
response = await client.get(app.url_path_for("get_compute", compute_id=compute_id))
|
|
assert response.status_code == status.HTTP_200_OK
|
|
assert response.json()["auto_connect"] is True
|
|
|
|
async def test_compute_create_auto_connect_defaults_to_false(self, app: FastAPI, client: AsyncClient) -> None:
|
|
|
|
params = {"protocol": "http", "host": "localhost", "port": 85, "user": "julien", "password": "secure"}
|
|
|
|
response = await client.post(app.url_path_for("create_compute"), json=params)
|
|
assert response.status_code == status.HTTP_201_CREATED
|
|
assert response.json()["auto_connect"] is False
|
|
|
|
async def test_compute_update_enable_auto_connect_connects(self, app: FastAPI, client: AsyncClient) -> None:
|
|
|
|
params = {"protocol": "http", "host": "localhost", "port": 86, "name": "auto-connect-target"}
|
|
response = await client.post(app.url_path_for("create_compute"), json=params)
|
|
assert response.status_code == status.HTTP_201_CREATED
|
|
compute_id = response.json()["compute_id"]
|
|
|
|
with patch("gns3server.controller.compute.Compute.connect", new_callable=AsyncioMagicMock) as connect_mock:
|
|
response = await client.put(
|
|
app.url_path_for("update_compute", compute_id=compute_id), json={"auto_connect": True}
|
|
)
|
|
assert response.status_code == status.HTTP_200_OK
|
|
assert response.json()["auto_connect"] is True
|
|
await asyncio.sleep(0) # give the background connection task a tick
|
|
assert connect_mock.call_count == 1
|
|
|
|
# saving the same value again must not reconnect: a manual
|
|
# disconnect has to survive an unrelated edit of the compute
|
|
response = await client.put(
|
|
app.url_path_for("update_compute", compute_id=compute_id), json={"auto_connect": True}
|
|
)
|
|
assert response.status_code == status.HTTP_200_OK
|
|
await asyncio.sleep(0)
|
|
assert connect_mock.call_count == 1
|
|
|
|
async def test_compute_update_preserves_auto_connect(self, app: FastAPI, client: AsyncClient) -> None:
|
|
|
|
params = {
|
|
"protocol": "http",
|
|
"host": "localhost",
|
|
"port": 87,
|
|
"user": "julien",
|
|
"password": "secure",
|
|
"auto_connect": True,
|
|
}
|
|
response = await client.post(app.url_path_for("create_compute"), json=params)
|
|
assert response.status_code == status.HTTP_201_CREATED
|
|
compute_id = response.json()["compute_id"]
|
|
|
|
response = await client.put(app.url_path_for("update_compute", compute_id=compute_id), json={"name": "renamed"})
|
|
assert response.status_code == status.HTTP_200_OK
|
|
assert response.json()["name"] == "renamed"
|
|
|
|
response = await client.get(app.url_path_for("get_compute", compute_id=compute_id))
|
|
assert response.status_code == status.HTTP_200_OK
|
|
assert response.json()["auto_connect"] is True
|
|
|
|
|
|
class TestComputeDisconnect:
|
|
async def test_compute_disconnect(self, app: FastAPI, client: AsyncClient) -> None:
|
|
|
|
params = {"protocol": "http", "host": "localhost", "port": 88, "user": "julien", "password": "secure"}
|
|
response = await client.post(app.url_path_for("create_compute"), json=params)
|
|
assert response.status_code == status.HTTP_201_CREATED
|
|
compute_id = response.json()["compute_id"]
|
|
|
|
compute = Controller.instance().get_compute(compute_id)
|
|
compute._connected = True
|
|
|
|
response = await client.post(app.url_path_for("disconnect_compute", compute_id=compute_id))
|
|
assert response.status_code == status.HTTP_204_NO_CONTENT
|
|
assert compute._manual_disconnect is True
|
|
assert compute.connected is False
|
|
|
|
async def test_compute_disconnect_in_use_rejected(self, app: FastAPI, client: AsyncClient) -> None:
|
|
|
|
params = {"protocol": "http", "host": "localhost", "port": 89, "user": "julien", "password": "secure"}
|
|
response = await client.post(app.url_path_for("create_compute"), json=params)
|
|
assert response.status_code == status.HTTP_201_CREATED
|
|
compute_id = response.json()["compute_id"]
|
|
|
|
compute = Controller.instance().get_compute(compute_id)
|
|
compute._connected = True
|
|
|
|
open_project = MagicMock()
|
|
open_project.name = "project-using-the-compute"
|
|
with patch("gns3server.controller.Controller.get_compute_open_projects", return_value=[open_project]):
|
|
response = await client.post(app.url_path_for("disconnect_compute", compute_id=compute_id))
|
|
assert response.status_code == status.HTTP_409_CONFLICT
|
|
# the offending project names are reported to the client
|
|
assert "project-using-the-compute" in response.json()["message"]
|
|
# the compute is left untouched
|
|
assert compute._manual_disconnect is False
|
|
assert compute.connected is True
|
|
|
|
async def test_compute_disconnect_in_use_forced(self, app: FastAPI, client: AsyncClient) -> None:
|
|
|
|
params = {"protocol": "http", "host": "localhost", "port": 90, "user": "julien", "password": "secure"}
|
|
response = await client.post(app.url_path_for("create_compute"), json=params)
|
|
assert response.status_code == status.HTTP_201_CREATED
|
|
compute_id = response.json()["compute_id"]
|
|
|
|
compute = Controller.instance().get_compute(compute_id)
|
|
compute._connected = True
|
|
|
|
with patch("gns3server.controller.Controller.get_compute_open_projects", return_value=[MagicMock()]):
|
|
response = await client.post(
|
|
app.url_path_for("disconnect_compute", compute_id=compute_id), params={"force": True}
|
|
)
|
|
assert response.status_code == status.HTTP_204_NO_CONTENT
|
|
assert compute._manual_disconnect is True
|
|
assert compute.connected is False
|
|
|
|
async def test_compute_disconnect_local_rejected(self, app: FastAPI, client: AsyncClient) -> None:
|
|
|
|
response = await client.post(app.url_path_for("disconnect_compute", compute_id="local"))
|
|
assert response.status_code == status.HTTP_400_BAD_REQUEST
|
|
|
|
async def test_compute_disconnect_unknown(self, app: FastAPI, client: AsyncClient) -> None:
|
|
|
|
response = await client.post(app.url_path_for("disconnect_compute", compute_id=str(uuid.uuid4())))
|
|
assert response.status_code == status.HTTP_404_NOT_FOUND
|