Apply testing feedback from upstream

Author: marcelldls

tests/backends/rest/test_rest.py

@@ -1,91 +1,88 @@
-import copy
-from typing import Any
-
 import pytest
 from fastapi.testclient import TestClient
 
-from fastcs.attributes import AttrR
 from fastcs.backends.rest.backend import RestBackend
-from fastcs.datatypes import Bool, Float, Int
-
-
-def kebab_2_snake(input: list[str]) -> list[str]:
-    snake_list = copy.deepcopy(input)
-    snake_list[-1] = snake_list[-1].replace("-", "_")
-    return snake_list
 
 
 class TestRestServer:
-    @pytest.fixture(scope="class", autouse=True)
-    def setup_class(self, assertable_controller):
-        self.controller = assertable_controller
-
     @pytest.fixture(scope="class")
-    def client(self):
-        app = RestBackend(self.controller)._server._app
+    def client(self, assertable_controller):
+        app = RestBackend(assertable_controller)._server._app
         return TestClient(app)
 
-    @pytest.fixture(scope="class")
-    def client_read(self, client):
-        def _client_read(path: list[str], expected: Any):
-            route = "/" + "/".join(path)
-            with self.controller.assertPerformed(kebab_2_snake(path), "READ"):
-                response = client.get(route)
-            assert response.status_code == 200
-            assert response.json()["value"] == expected
-
-        return _client_read
-
-    @pytest.fixture(scope="class")
-    def client_write(self, client):
-        def _client_write(path: list[str], value: Any):
-            route = "/" + "/".join(path)
-            with self.controller.assertPerformed(kebab_2_snake(path), "WRITE"):
-                response = client.put(route, json={"value": value})
-            assert response.status_code == 204
-
-        return _client_write
-
-    @pytest.fixture(scope="class")
-    def client_exec(self, client):
-        def _client_exec(path: list[str]):
-            route = "/" + "/".join(path)
-            with self.controller.assertPerformed(kebab_2_snake(path), "EXECUTE"):
-                response = client.put(route)
+    def test_read_int(self, assertable_controller, client):
+        expect = 0
+        with assertable_controller.assert_read_here(["read_int"]):
+            response = client.get("/read-int")
+        assert response.status_code == 200
+        assert response.json()["value"] == expect
+
+    def test_read_write_int(self, assertable_controller, client):
+        expect = 0
+        with assertable_controller.assert_read_here(["read_write_int"]):
+            response = client.get("/read-write-int")
+        assert response.status_code == 200
+        assert response.json()["value"] == expect
+        new = 9
+        with assertable_controller.assert_write_here(["read_write_int"]):
+            response = client.put("/read-write-int", json={"value": new})
+        assert client.get("/read-write-int").json()["value"] == new
+
+    def test_read_write_float(self, assertable_controller, client):
+        expect = 0
+        with assertable_controller.assert_read_here(["read_write_float"]):
+            response = client.get("/read-write-float")
+        assert response.status_code == 200
+        assert response.json()["value"] == expect
+        new = 0.5
+        with assertable_controller.assert_write_here(["read_write_float"]):
+            response = client.put("/read-write-float", json={"value": new})
+        assert client.get("/read-write-float").json()["value"] == new
+
+    def test_read_bool(self, assertable_controller, client):
+        expect = False
+        with assertable_controller.assert_read_here(["read_bool"]):
+            response = client.get("/read-bool")
+        assert response.status_code == 200
+        assert response.json()["value"] == expect
+
+    def test_write_bool(self, assertable_controller, client):
+        with assertable_controller.assert_write_here(["write_bool"]):
+            client.put("/write-bool", json={"value": True})
+
+    def test_string_enum(self, assertable_controller, client):
+        expect = ""
+        with assertable_controller.assert_read_here(["string_enum"]):
+            response = client.get("/string-enum")
+        assert response.status_code == 200
+        assert response.json()["value"] == expect
+        new = "new"
+        with assertable_controller.assert_write_here(["string_enum"]):
+            response = client.put("/string-enum", json={"value": new})
+        assert client.get("/string-enum").json()["value"] == new
+
+    def test_big_enum(self, assertable_controller, client):
+        expect = 0
+        with assertable_controller.assert_read_here(["big_enum"]):
+            response = client.get("/big-enum")
+        assert response.status_code == 200
+        assert response.json()["value"] == expect
+
+    def test_go(self, assertable_controller, client):
+        with assertable_controller.assert_execute_here(["go"]):
+            response = client.put("/go")
             assert response.status_code == 204
 
-        return _client_exec
-
-    def test_read_int(self, client_read):
-        client_read(["read-int"], AttrR(Int())._value)
-
-    def test_read_write_int(self, client_read, client_write):
-        client_read(["read-write-int"], AttrR(Int())._value)
-        client_write(["read-write-int"], AttrR(Int())._value)
-
-    def test_read_write_float(self, client_read, client_write):
-        client_read(["read-write-float"], AttrR(Float())._value)
-        client_write(["read-write-float"], AttrR(Float())._value)
-
-    def test_read_bool(self, client_read):
-        client_read(["read-bool"], AttrR(Bool())._value)
-
-    def test_write_bool(self, client_write):
-        client_write(["write-bool"], AttrR(Bool())._value)
-
-    # # We need to discuss enums
-    # def test_string_enum(self, client_read, client_write):
-
-    def test_big_enum(self, client_read):
-        client_read(
-            ["big-enum"], AttrR(Int(), allowed_values=list(range(1, 18)))._value
-        )
-
-    def test_go(self, client_exec):
-        client_exec(["go"])
-
-    def test_read_child1(self, client_read):
-        client_read(["SubController01", "read-int"], AttrR(Int())._value)
-
-    def test_read_child2(self, client_read):
-        client_read(["SubController02", "read-int"], AttrR(Int())._value)
+    def test_read_child1(self, assertable_controller, client):
+        expect = 0
+        with assertable_controller.assert_read_here(["SubController01", "read_int"]):
+            response = client.get("/SubController01/read-int")
+        assert response.status_code == 200
+        assert response.json()["value"] == expect
+
+    def test_read_child2(self, assertable_controller, client):
+        expect = 0
+        with assertable_controller.assert_read_here(["SubController02", "read_int"]):
+            response = client.get("/SubController02/read-int")
+        assert response.status_code == 200
+        assert response.json()["value"] == expect

tests/conftest.py

@@ -102,17 +102,24 @@ def __init__(self, mocker: MockerFixture) -> None:
         self.mocker = mocker
 
     @contextmanager
-    def assertPerformed(
-        self, path: list[str], action: Literal["READ", "WRITE", "EXECUTE"]
-    ):
+    def assert_read_here(self, path: list[str]):
+        yield from self._assert_method(path, "get")
+
+    @contextmanager
+    def assert_write_here(self, path: list[str]):
+        yield from self._assert_method(path, "process")
+
+    @contextmanager
+    def assert_execute_here(self, path: list[str]):
+        yield from self._assert_method(path, "")
+
+    def _assert_method(self, path: list[str], method: Literal["get", "process", ""]):
+        """
+        This context manager can be used to confirm that a fastcs
+        controller's respective attribute or command methods are called
+        a single time within a context block
+        """
         queue = copy.deepcopy(path)
-        match action:
-            case "READ":
-                method = "get"
-            case "WRITE":
-                method = "process"
-            case "EXECUTE":
-                method = ""
 
         # Navigate to subcontroller
         controller = self