Secure controller to compute communication using HTTP basic authentication

tests/api/routes/compute/test_vmware_nodes.py

@@ -28,7 +28,7 @@ pytestmark = pytest.mark.asyncio
 
 
 @pytest.fixture(scope="function")
-async def vm(app: FastAPI, client: AsyncClient, compute_project: Project, vmx_path: str) -> dict:
+async def vm(app: FastAPI, compute_client: AsyncClient, compute_project: Project, vmx_path: str) -> dict:
 
     params = {
         "name": "VMTEST",
@@ -37,7 +37,7 @@ async def vm(app: FastAPI, client: AsyncClient, compute_project: Project, vmx_pa
     }
 
     with asyncio_patch("gns3server.compute.vmware.vmware_vm.VMwareVM.create", return_value=True) as mock:
-        response = await client.post(app.url_path_for("compute:create_vmware_node", project_id=compute_project.id),
+        response = await compute_client.post(app.url_path_for("compute:create_vmware_node", project_id=compute_project.id),
                                      json=params)
         assert mock.called
         assert response.status_code == status.HTTP_201_CREATED
@@ -56,7 +56,7 @@ def vmx_path(tmpdir: str) -> str:
     return path
 
 
-async def test_vmware_create(app: FastAPI, client: AsyncClient, compute_project: Project, vmx_path: str) -> None:
+async def test_vmware_create(app: FastAPI, compute_client: AsyncClient, compute_project: Project, vmx_path: str) -> None:
 
     params = {
         "name": "VM1",
@@ -65,72 +65,72 @@ async def test_vmware_create(app: FastAPI, client: AsyncClient, compute_project:
     }
 
     with asyncio_patch("gns3server.compute.vmware.vmware_vm.VMwareVM.create", return_value=True):
-        response = await client.post(app.url_path_for("compute:create_vmware_node", project_id=compute_project.id),
+        response = await compute_client.post(app.url_path_for("compute:create_vmware_node", project_id=compute_project.id),
                                      json=params)
         assert response.status_code == status.HTTP_201_CREATED
         assert response.json()["name"] == "VM1"
         assert response.json()["project_id"] == compute_project.id
 
 
-async def test_vmware_get(app: FastAPI, client: AsyncClient, compute_project: Project, vm: dict) -> None:
+async def test_vmware_get(app: FastAPI, compute_client: AsyncClient, compute_project: Project, vm: dict) -> None:
 
-    response = await client.get(app.url_path_for("compute:get_vmware_node", project_id=vm["project_id"], node_id=vm["node_id"]))
+    response = await compute_client.get(app.url_path_for("compute:get_vmware_node", project_id=vm["project_id"], node_id=vm["node_id"]))
     assert response.status_code == status.HTTP_200_OK
     assert response.json()["name"] == "VMTEST"
     assert response.json()["project_id"] == compute_project.id
 
 
-async def test_vmware_start(app: FastAPI, client: AsyncClient, vm: dict) -> None:
+async def test_vmware_start(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 client.post(app.url_path_for("compute:start_vmware_node",
+        response = await compute_client.post(app.url_path_for("compute:start_vmware_node",
                                                       project_id=vm["project_id"],
                                                       node_id=vm["node_id"]))
         assert mock.called
         assert response.status_code == status.HTTP_204_NO_CONTENT
 
 
-async def test_vmware_stop(app: FastAPI, client: AsyncClient, vm: dict) -> None:
+async def test_vmware_stop(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 client.post(app.url_path_for("compute:stop_vmware_node",
+        response = await compute_client.post(app.url_path_for("compute:stop_vmware_node",
                                                       project_id=vm["project_id"],
                                                       node_id=vm["node_id"]))
         assert mock.called
         assert response.status_code == status.HTTP_204_NO_CONTENT
 
 
-async def test_vmware_suspend(app: FastAPI, client: AsyncClient, vm: dict) -> None:
+async def test_vmware_suspend(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 client.post(app.url_path_for("compute:suspend_vmware_node",
+        response = await compute_client.post(app.url_path_for("compute:suspend_vmware_node",
                                                       project_id=vm["project_id"],
                                                       node_id=vm["node_id"]))
         assert mock.called
         assert response.status_code == status.HTTP_204_NO_CONTENT
 
 
-async def test_vmware_resume(app: FastAPI, client: AsyncClient, vm: dict) -> None:
+async def test_vmware_resume(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 client.post(app.url_path_for("compute:resume_vmware_node",
+        response = await compute_client.post(app.url_path_for("compute:resume_vmware_node",
                                                       project_id=vm["project_id"],
                                                       node_id=vm["node_id"]))
         assert mock.called
         assert response.status_code == status.HTTP_204_NO_CONTENT
 
 
-async def test_vmware_reload(app: FastAPI, client: AsyncClient, vm: dict) -> None:
+async def test_vmware_reload(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 client.post(app.url_path_for("compute:reload_vmware_node",
+        response = await compute_client.post(app.url_path_for("compute:reload_vmware_node",
                                                       project_id=vm["project_id"],
                                                       node_id=vm["node_id"]))
         assert mock.called
         assert response.status_code == status.HTTP_204_NO_CONTENT
 
 
-async def test_vmware_nio_create_udp(app: FastAPI, client: AsyncClient, vm: dict) -> None:
+async def test_vmware_nio_create_udp(app: FastAPI, compute_client: AsyncClient, vm: dict) -> None:
 
     params = {
         "type": "nio_udp",
@@ -146,7 +146,7 @@ async def test_vmware_nio_create_udp(app: FastAPI, client: AsyncClient, vm: dict
                            port_number="0")
 
     with asyncio_patch('gns3server.compute.vmware.vmware_vm.VMwareVM.adapter_add_nio_binding') as mock:
-        response = await client.post(url, json=params)
+        response = await compute_client.post(url, json=params)
         assert mock.called
         args, kwgars = mock.call_args
         assert args[0] == 0
@@ -156,7 +156,7 @@ async def test_vmware_nio_create_udp(app: FastAPI, client: AsyncClient, vm: dict
 
 
 # @pytest.mark.asyncio
-# async def test_vmware_nio_update_udp(app: FastAPI, client: AsyncClient, vm):
+# async def test_vmware_nio_update_udp(app: FastAPI, compute_client: AsyncClient, vm):
 #
 #     params = {
 #         "type": "nio_udp",
@@ -169,12 +169,12 @@ async def test_vmware_nio_create_udp(app: FastAPI, client: AsyncClient, vm: dict
 #     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 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)
+#                 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, client: AsyncClient, vm: dict) -> None:
+async def test_vmware_delete_nio(app: FastAPI, compute_client: AsyncClient, vm: dict) -> None:
 
     url = app.url_path_for("compute:delete_vmware_node_nio",
                            project_id=vm["project_id"],
@@ -183,7 +183,7 @@ async def test_vmware_delete_nio(app: FastAPI, client: AsyncClient, vm: dict) ->
                            port_number="0")
 
     with asyncio_patch('gns3server.compute.vmware.vmware_vm.VMwareVM.adapter_remove_nio_binding') as mock:
-        response = await client.delete(url)
+        response = await compute_client.delete(url)
         assert mock.called
         args, kwgars = mock.call_args
         assert args[0] == 0
@@ -191,14 +191,14 @@ async def test_vmware_delete_nio(app: FastAPI, client: AsyncClient, vm: dict) ->
     assert response.status_code == status.HTTP_204_NO_CONTENT
 
 
-async def test_vmware_update(app: FastAPI, client: AsyncClient, vm: dict, free_console_port: int) -> None:
+async def test_vmware_update(app: FastAPI, compute_client: AsyncClient, vm: dict, free_console_port: int) -> None:
 
     params = {
         "name": "test",
         "console": free_console_port
     }
 
-    response = await client.put(app.url_path_for("compute:update_vmware_node",
+    response = await compute_client.put(app.url_path_for("compute:update_vmware_node",
                                                  project_id=vm["project_id"],
                                                  node_id=vm["node_id"]), json=params)
     assert response.status_code == status.HTTP_200_OK
@@ -206,7 +206,7 @@ async def test_vmware_update(app: FastAPI, client: AsyncClient, vm: dict, free_c
     assert response.json()["console"] == free_console_port
 
 
-async def test_vmware_start_capture(app: FastAPI, client: AsyncClient, vm: dict) -> None:
+async def test_vmware_start_capture(app: FastAPI, compute_client: AsyncClient, vm: dict) -> None:
 
     params = {
         "capture_file_name": "test.pcap",
@@ -222,13 +222,13 @@ async def test_vmware_start_capture(app: FastAPI, client: AsyncClient, vm: dict)
     with patch("gns3server.compute.vmware.vmware_vm.VMwareVM.is_running", return_value=True):
         with asyncio_patch("gns3server.compute.vmware.vmware_vm.VMwareVM.start_capture") as mock:
 
-            response = await client.post(url, json=params)
+            response = await compute_client.post(url, json=params)
             assert response.status_code == status.HTTP_200_OK
             assert mock.called
             assert "test.pcap" in response.json()["pcap_file_path"]
 
 
-async def test_vmware_stop_capture(app: FastAPI, client: AsyncClient, vm: dict) -> None:
+async def test_vmware_stop_capture(app: FastAPI, compute_client: AsyncClient, vm: dict) -> None:
 
     url = app.url_path_for("compute:stop_vmware_node_capture",
                            project_id=vm["project_id"],
@@ -238,15 +238,15 @@ async def test_vmware_stop_capture(app: FastAPI, client: AsyncClient, vm: dict)
 
     with patch("gns3server.compute.vmware.vmware_vm.VMwareVM.is_running", return_value=True):
         with asyncio_patch("gns3server.compute.vmware.vmware_vm.VMwareVM.stop_capture") as mock:
-            response = await client.post(url)
+            response = await compute_client.post(url)
             assert response.status_code == status.HTTP_204_NO_CONTENT
             assert mock.called
 
 
 # @pytest.mark.asyncio
-# async def test_vmware_pcap(app: FastAPI, client: AsyncClient, vm, compute_project):
+# 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 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)
+#             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