Better tests, proper methods

Author: marcelldls

src/fastcs/backends/rest/rest.py

@@ -54,7 +54,7 @@ def _wrap_attr_put(
     attribute: AttrW[T],
 ) -> Callable[[T], Coroutine[Any, Any, None]]:
     async def attr_set(request):
-        await attribute.process_without_display_update(request.value)
+        await attribute.process(request.value)
 
     # Fast api uses type annotations for validation, schema, conversions
     attr_set.__annotations__["request"] = _put_request_body(attribute)
@@ -124,7 +124,7 @@ def _wrap_command(
     method: Callable, controller: BaseController
 ) -> Callable[..., Awaitable[None]]:
     async def command() -> None:
-        await MethodType(method, controller)()
+        await method.__get__(controller)()
 
     return command
 

tests/backends/rest/test_rest.py

@@ -1,48 +1,79 @@
+import copy
+import re
+from typing import Any
+
+import pytest
+from fastapi.testclient import TestClient
+from pytest_mock import MockerFixture
+from tests.conftest import AssertableController
+
 from fastcs.attributes import AttrR
+from fastcs.backends.rest.backend import RestBackend
 from fastcs.datatypes import Bool, Float, Int
 
 
+def pascal_2_snake(input: list[str]) -> list[str]:
+    snake_list = copy.deepcopy(input)
+    snake_list[-1] = re.sub(r"(?<!^)(?=[A-Z])", "_", snake_list[-1]).lower()
+    return snake_list
+
+
 class TestRestServer:
-    def test_read_int(self, rest_client):
-        response = rest_client.get("/ReadInt")
-        assert response.status_code == 200
-        assert response.json() == {"value": AttrR(Int())._value}
+    @pytest.fixture(autouse=True)
+    def setup_tests(self, mocker: MockerFixture):
+        self.controller = AssertableController(mocker)
+        app = RestBackend(self.controller)._server._app
+        self.client = TestClient(app)
 
-    def test_read_write_int(self, rest_client):
-        response = rest_client.get("/ReadWriteInt")
+    def client_read(self, path: list[str], expected: Any):
+        route = "/" + "/".join(path)
+        with self.controller.assertPerformed(pascal_2_snake(path), "READ"):
+            response = self.client.get(route)
         assert response.status_code == 200
-        assert response.json() == {"value": AttrR(Int())._value}
-        response = rest_client.put("/ReadWriteInt", json={"value": AttrR(Int())._value})
+        assert response.json()["value"] == expected
+
+    def client_write(self, path: list[str], value: Any):
+        route = "/" + "/".join(path)
+        with self.controller.assertPerformed(pascal_2_snake(path), "WRITE"):
+            response = self.client.put(route, json={"value": value})
         assert response.status_code == 204
 
-    def test_read_write_float(self, rest_client):
-        response = rest_client.get("/ReadWriteFloat")
-        assert response.status_code == 200
-        assert response.json() == {"value": AttrR(Float())._value}
-        response = rest_client.put(
-            "/ReadWriteFloat", json={"value": AttrR(Float())._value}
-        )
+    def client_exec(self, path: list[str]):
+        route = "/" + "/".join(path)
+        with self.controller.assertPerformed(pascal_2_snake(path), "EXECUTE"):
+            response = self.client.put(route)
         assert response.status_code == 204
 
-    def test_read_bool(self, rest_client):
-        response = rest_client.get("/ReadBool")
-        assert response.status_code == 200
-        assert response.json() == {"value": AttrR(Bool())._value}
+    def test_read_int(self):
+        self.client_read(["ReadInt"], AttrR(Int())._value)
 
-    def test_write_bool(self, rest_client):
-        response = rest_client.put("/WriteBool", json={"value": AttrR(Bool())._value})
-        assert response.status_code == 204
+    def test_read_write_int(self):
+        self.client_read(["ReadWriteInt"], AttrR(Int())._value)
+        self.client_write(["ReadWriteInt"], AttrR(Int())._value)
+
+    def test_read_write_float(self):
+        self.client_read(["ReadWriteFloat"], AttrR(Float())._value)
+        self.client_write(["ReadWriteFloat"], AttrR(Float())._value)
+
+    def test_read_bool(self):
+        self.client_read(["ReadBool"], AttrR(Bool())._value)
+
+    def test_write_bool(self):
+        self.client_write(["WriteBool"], AttrR(Bool())._value)
 
     # # We need to discuss enums
     # def test_string_enum(self, rest_client):
 
-    def test_big_enum(self, rest_client):
-        response = rest_client.get("/BigEnum")
-        assert response.status_code == 200
-        assert response.json() == {
-            "value": AttrR(Int(), allowed_values=list(range(1, 18)))._value
-        }
+    def test_big_enum(self):
+        self.client_read(
+            ["BigEnum"], AttrR(Int(), allowed_values=list(range(1, 18)))._value
+        )
 
-    def test_go(self, rest_client):
-        response = rest_client.put("/Go")
-        assert response.status_code == 204
+    def test_go(self):
+        self.client_exec(["Go"])
+
+    def test_read_child1(self):
+        self.client_read(["SubController01", "ReadInt"], AttrR(Int())._value)
+
+    def test_read_child2(self):
+        self.client_read(["SubController02", "ReadInt"], AttrR(Int())._value)

tests/conftest.py

@@ -1,18 +1,19 @@
+import copy
 import os
 import random
 import string
 import subprocess
 import time
+from contextlib import contextmanager
 from pathlib import Path
-from typing import Any
+from typing import Any, Literal
 
 import pytest
 from aioca import purge_channel_caches
-from fastapi.testclient import TestClient
+from pytest_mock import MockerFixture
 
 from fastcs.attributes import AttrR, AttrRW, AttrW, Handler, Sender, Updater
-from fastcs.backends.rest.backend import RestBackend
-from fastcs.controller import Controller
+from fastcs.controller import Controller, SubController
 from fastcs.datatypes import Bool, Float, Int, String
 from fastcs.mapping import Mapping
 from fastcs.wrappers import command, scan
@@ -51,7 +52,20 @@ class TestHandler(Handler, TestUpdater, TestSender):
     pass
 
 
+class TestSubController(SubController):
+    read_int: AttrR = AttrR(Int(), handler=TestUpdater())
+
+
 class TestController(Controller):
+    def __init__(self) -> None:
+        super().__init__()
+
+        self._sub_controllers: list[TestSubController] = []
+        for index in range(1, 3):
+            controller = TestSubController()
+            self._sub_controllers.append(controller)
+            self.register_sub_controller(f"SubController{index:02d}", controller)
+
     read_int: AttrR = AttrR(Int(), handler=TestUpdater())
     read_write_int: AttrRW = AttrRW(Int(), handler=TestHandler())
     read_write_float: AttrRW = AttrRW(Float())
@@ -82,6 +96,48 @@ async def counter(self):
         self.count += 1
 
 
+class AssertableController(TestController):
+    def __init__(self, mocker: MockerFixture) -> None:
+        super().__init__()
+        self.mocker = mocker
+
+    @contextmanager
+    def assertPerformed(
+        self, path: list[str], action: Literal["READ", "WRITE", "EXECUTE"]
+    ):
+        queue = copy.deepcopy(path)
+        match action:
+            case "READ":
+                method = "get"
+            case "WRITE":
+                method = "process"
+            case "EXECUTE":
+                method = ""
+
+        # Navigate to subcontroller
+        controller = self
+        item_name = queue.pop(-1)
+        for item in queue:
+            controllers = controller.get_sub_controllers()
+            controller = controllers[item]
+
+        # create probe
+        if method:
+            attr = getattr(controller, item_name)
+            spy = self.mocker.spy(attr, method)
+        else:
+            spy = self.mocker.spy(controller, item_name)
+        initial = spy.call_count
+        try:
+            yield  # Enter context
+        finally:  # Exit context
+            final = spy.call_count
+            assert final == initial + 1, (
+                f"Expected {'.'.join(path + [method] if method else path)} "
+                f"to be called once, but it was called {final - initial} times."
+            )
+
+
 @pytest.fixture
 def controller():
     return TestController()
@@ -122,10 +178,3 @@ def ioc():
     except ValueError:
         # Someone else already called communicate
         pass
-
-
-@pytest.fixture(scope="class")
-def rest_client():
-    app = RestBackend(TestController())._server._app
-    client = TestClient(app)
-    return client