mirror of
https://github.com/GNS3/gns3-server.git
synced 2026-11-19 20:55:14 +02:00
A deletion the user must confirm belongs in the response of the delete request, not in a notification sent after the fact. The controller now refuses with a 409 (code image_referenced_by_templates, the template names in details) while any Docker template references the image, before the compute is touched. force=true confirms the deletion. The docker.image.deleted notification stays as a change signal so clients can refresh their image lists.
601 lines
28 KiB
Python
601 lines
28 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.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_refused_while_referenced_by_templates(
|
|
self, app: FastAPI, client: AsyncClient, test_compute: Compute
|
|
) -> None:
|
|
"""
|
|
A deletion is refused while a template references the image, matched
|
|
through the image reference spelling, and the compute is not touched.
|
|
"""
|
|
|
|
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(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="alpine:3")
|
|
)
|
|
assert response.status_code == status.HTTP_409_CONFLICT
|
|
body = response.json()
|
|
assert body["code"] == "image_referenced_by_templates"
|
|
assert body["details"]["referenced_by_templates"] == ["Alpine conflict test"]
|
|
assert "referenced by template(s): Alpine conflict test" in body["message"]
|
|
compute.http_query.assert_not_called()
|
|
|
|
async def test_compute_delete_docker_image_force_overrides_template_reference(
|
|
self, app: FastAPI, client: AsyncClient, test_compute: Compute
|
|
) -> None:
|
|
"""
|
|
force=true deletes an image referenced by templates and the deletion
|
|
notification reports them.
|
|
"""
|
|
|
|
new_template = {
|
|
"name": "Alpine force test",
|
|
"compute_id": "local",
|
|
# an image no other test in this class references: the assertions
|
|
# below are exact and the class shares one database
|
|
"image": "gns3/force-delete-test:2",
|
|
"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/force-delete-test:2"
|
|
),
|
|
params={"force": True},
|
|
)
|
|
assert response.status_code == status.HTTP_204_NO_CONTENT
|
|
compute.http_query.assert_called_once_with(
|
|
"DELETE", "/docker/images/gns3/force-delete-test:2", params={"force": "true"}
|
|
)
|
|
controller.return_value.notification.controller_emit.assert_called_once_with(
|
|
"docker.image.deleted",
|
|
{
|
|
"compute_id": str(test_compute.compute_id),
|
|
"image": "gns3/force-delete-test:2",
|
|
"referenced_by_templates": ["Alpine force test"],
|
|
},
|
|
)
|
|
|
|
async def test_compute_delete_docker_image_notifies_without_templates(
|
|
self, app: FastAPI, client: AsyncClient, test_compute: Compute
|
|
) -> None:
|
|
"""
|
|
A deletion nothing references still emits a docker.image.deleted
|
|
notification, so clients can refresh their image lists.
|
|
"""
|
|
|
|
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": [],
|
|
},
|
|
)
|
|
|
|
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
|