Checkpoint

Author: marcelldls

src/fastcs/backends/graphQL/graphQL.py

@@ -6,9 +6,9 @@
 import strawberry
 import uvicorn
 from fastapi import FastAPI
-from pydantic import create_model
 from strawberry.asgi import GraphQL
 from strawberry.tools import create_type
+from strawberry.types.field import StrawberryField
 
 from fastcs.attributes import AttrR, AttrRW, AttrW, T
 from fastcs.controller import BaseController
@@ -22,39 +22,30 @@ class GraphQLServerOptions:
     log_level: str = "info"
 
 
-@strawberry.type
-class User:
-    name: str
-    age: int
-
-
-@strawberry.type
-class Query:
-    @strawberry.field
-    def user(self) -> User:
-        return User(name="Patrick", age=100)
-
-
-schema = strawberry.Schema(query=Query)
-
-
 class GraphQLServer:
     def __init__(self, mapping: Mapping):
         self._mapping = mapping
+        self._field_dict: dict[str, list[StrawberryField]] = {
+            "Query": [],
+            "Mutation": [],
+        }
         self._app = self._create_app()
 
-    def _create_app(self):
-        Query = self._create_query(self._mapping)
-        Mutation = self._create_mutation()
-        # https://docs.github.com/en/graphql/guides/forming-calls-with-graphql
-        schema = strawberry.Schema(query=Query, mutation=Mutation)
-        graphql_app = GraphQL(schema)
+    def _create_app(self) -> FastAPI:
+        _add_dev_attributes(self._field_dict, self._mapping)
+        _add_dev_commands(self._field_dict, self._mapping)
+
+        schema_kwargs = {}
+        for key, value in self._field_dict.items():
+            if self._field_dict[key]:
+                # Strawberry types map to graphql object
+                schema_kwargs[key.lower()] = create_type(key, value)
+        schema = strawberry.Schema(**schema_kwargs)  # type: ignore
+        graphql_app: GraphQL = GraphQL(schema)
 
         app = FastAPI()
         app.add_route("/graphql", graphql_app)
         app.add_websocket_route("/graphql", graphql_app)
-        # _add_dev_attributes(app, self._mapping)
-        # _add_dev_commands(app, self._mapping)
 
         return app
 
@@ -70,106 +61,95 @@ def run(self, options: GraphQLServerOptions | None = None) -> None:
         )
 
 
-def _put_request_body(attribute: AttrW[T]):
-    return create_model(
-        f"Put{str(attribute.datatype.dtype)}Value",
-        **{"value": (attribute.datatype.dtype, ...)},  # type: ignore
-    )
-
-
-def _wrap_attr_put(
+def _wrap_attr_set(
+    d_attr_name: str,
     attribute: AttrW[T],
 ) -> Callable[[T], Coroutine[Any, Any, None]]:
-    async def attr_set(request):
-        await attribute.process_without_display_update(request.value)
+    async def _dynamic_f(value):
+        await attribute.process_without_display_update(value)
+        return value
 
-    # Fast api uses type annotations for validation, schema, conversions
-    attr_set.__annotations__["request"] = _put_request_body(attribute)
+    # Add type annotations for validation, schema, conversions
+    _dynamic_f.__name__ = d_attr_name
+    _dynamic_f.__annotations__["value"] = attribute.datatype.dtype
+    _dynamic_f.__annotations__["return"] = attribute.datatype.dtype
 
-    return attr_set
-
-
-def _get_response_body(attribute: AttrR[T]):
-    return create_model(
-        f"Get{str(attribute.datatype.dtype)}Value",
-        **{"value": (attribute.datatype.dtype, ...)},  # type: ignore
-    )
+    return _dynamic_f
 
 
 def _wrap_attr_get(
+    d_attr_name: str,
     attribute: AttrR[T],
 ) -> Callable[[], Coroutine[Any, Any, Any]]:
-    async def attr_get() -> Any:  # Must be any as response_model is set
-        value = attribute.get()  # type: ignore
-        return {"value": value}
+    async def _dynamic_f() -> Any:
+        return attribute.get()
 
-    return attr_get
+    _dynamic_f.__name__ = d_attr_name
+    _dynamic_f.__annotations__["return"] = attribute.datatype.dtype
 
+    return _dynamic_f
 
-def _add_dev_attributes(app: FastAPI, mapping: Mapping) -> None:
+
+def _add_dev_attributes(
+    field_dict: dict[str, list[StrawberryField]], mapping: Mapping
+) -> None:
+    pass
     for single_mapping in mapping.get_controller_mappings():
         path = single_mapping.controller.path
+        # nest for each controller
+        # if path:
 
         for attr_name, attribute in single_mapping.attributes.items():
             attr_name = attr_name.title().replace("_", "")
             d_attr_name = f"{'/'.join(path)}/{attr_name}" if path else attr_name
 
             match attribute:
-                # https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods
                 case AttrRW():
-                    strawberry.type
-                    app.add_api_route(
-                        f"/{d_attr_name}",
-                        _wrap_attr_get(attribute),
-                        methods=["GET"],  # Idemponent and safe data retrieval,
-                        status_code=200,  # https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/GET
-                        response_model=_get_response_body(attribute),
-                    )
-                    app.add_api_route(
-                        f"/{d_attr_name}",
-                        _wrap_attr_put(attribute),
-                        methods=["PUT"],  # Idempotent state change
-                        status_code=204,  # https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/PUT
+                    field_dict["Query"].append(
+                        strawberry.field(_wrap_attr_get(d_attr_name, attribute))
                     )
+                    field_dict["Mutation"].append(
+                        strawberry.mutation(_wrap_attr_set(d_attr_name, attribute))
+                    )  # mutation for server changes https://graphql.org/learn/queries/
+
                 case AttrR():
-                    app.add_api_route(
-                        f"/{d_attr_name}",
-                        _wrap_attr_get(attribute),
-                        methods=["GET"],
-                        status_code=200,
-                        response_model=_get_response_body(attribute),
+                    field_dict["Query"].append(
+                        strawberry.field(_wrap_attr_get(d_attr_name, attribute))
                     )
+
                 case AttrW():
-                    app.add_api_route(
-                        f"/{d_attr_name}",
-                        _wrap_attr_put(attribute),
-                        methods=["PUT"],
-                        status_code=204,
+                    field_dict["Mutation"].append(
+                        strawberry.mutation(_wrap_attr_set(d_attr_name, attribute))
                     )
 
 
 def _wrap_command(
-    method: Callable, controller: BaseController
-) -> Callable[..., Awaitable[None]]:
-    async def command() -> None:
+    method_name: str, method: Callable, controller: BaseController
+) -> Callable[..., Awaitable[bool]]:
+    async def _dynamic_f() -> bool:
         await MethodType(method, controller)()
+        return True
 
-    return command
+    _dynamic_f.__name__ = method_name
 
+    return _dynamic_f
 
-def _add_dev_commands(app: FastAPI, mapping: Mapping) -> None:
+
+def _add_dev_commands(
+    field_dict: dict[str, list[StrawberryField]], mapping: Mapping
+) -> None:
     for single_mapping in mapping.get_controller_mappings():
         path = single_mapping.controller.path
 
         for name, method in single_mapping.command_methods.items():
             cmd_name = name.title().replace("_", "")
             d_cmd_name = f"{'/'.join(path)}/{cmd_name}" if path else cmd_name
-            app.add_api_route(
-                f"/{d_cmd_name}",
-                _wrap_command(
-                    method.fn,
-                    single_mapping.controller,
-                ),
-                methods=["PUT"],
-                status_code=204,
+            field_dict["Mutation"].append(
+                strawberry.mutation(
+                    _wrap_command(
+                        d_cmd_name,
+                        method.fn,
+                        single_mapping.controller,
+                    )
+                )
             )

tests/backends/graphQL/test_graphQL.py

@@ -0,0 +1,57 @@
+import json
+
+import pytest
+
+from fastcs.attributes import AttrR
+from fastcs.datatypes import Bool, Float, Int
+
+
+class TestGraphQLServer:
+    @pytest.fixture(autouse=True)
+    def _server_client(self, graphQL_client):
+        self._client = graphQL_client
+
+    def client_read(self, field: str, value):
+        query = f"query {{{field}}}"
+        response = self._client.post("/graphql", json={"query": query})
+        assert response.status_code == 200
+        assert response.json()["data"] == {field: value}
+
+    def client_write(self, field: str, value):
+        mutation = f"mutation {{{field}(value: {json.dumps(value)})}}"
+        response = self._client.post("/graphql", json={"query": mutation})
+        assert response.status_code == 200
+        assert response.json()["data"] == {field: value}
+
+    def client_exec(self, field: str):
+        mutation = f"mutation {{{field}}}"
+        response = self._client.post("/graphql", json={"query": mutation})
+        assert response.status_code == 200
+
+    def test_read_int(self):
+        self.client_read("ReadInt", AttrR(Int())._value)
+
+    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):
+
+    def test_big_enum(self):
+        self.client_read(
+            "BigEnum", AttrR(Int(), allowed_values=list(range(1, 18)))._value
+        )
+
+    def test_go(self):
+        self.client_exec("Go")

tests/conftest.py

@@ -8,8 +8,10 @@
 
 import pytest
 from aioca import purge_channel_caches
+from fastapi.testclient import TestClient
 
 from fastcs.attributes import AttrR, AttrRW, AttrW, Handler, Sender, Updater
+from fastcs.backends.graphQL.backend import GraphQLBackend
 from fastcs.controller import Controller
 from fastcs.datatypes import Bool, Float, Int, String
 from fastcs.mapping import Mapping
@@ -120,3 +122,10 @@ def ioc():
     except ValueError:
         # Someone else already called communicate
         pass
+
+
+@pytest.fixture(scope="class")
+def graphQL_client():
+    app = GraphQLBackend(TestController())._server._app
+    client = TestClient(app)
+    return client