WIP service interface / impl tests

Author: dandavison

temporalio/workflow.py

@@ -5178,6 +5178,7 @@ def __init__(
         self._schedule_to_close_timeout = schedule_to_close_timeout
 
     # TODO(dan): overloads: no-input, operation name, ret type
+    # TODO(dan): should it be an error to use a reference to a mathod on a class other than that supplied?
     async def start_operation(
         self,
         operation: Union[

tests/worker/test_nexus.py

@@ -36,7 +36,8 @@
 # Service interface
 #
 class CallerReference(StrEnum):
-    IMPLEMENTATION = "implementation"
+    IMPLEMENTATION_WITHOUT_INTERFACE = "implementation-without-interface"
+    IMPLEMENTATION_OF_INTERFACE = "implementation-of-interface"
     INTERFACE = "interface"
 
 
@@ -189,7 +190,7 @@ def __init__(
     ) -> None:
         self.nexus_service = workflow.NexusClient(
             service={
-                CallerReference.IMPLEMENTATION: MyServiceImpl,
+                CallerReference.IMPLEMENTATION_OF_INTERFACE: MyServiceImpl,
                 CallerReference.INTERFACE: MyServiceInterface,
             }[input.caller_reference],
             endpoint=make_nexus_endpoint_name(task_queue),
@@ -237,7 +238,7 @@ def _get_operation(
             (
                 SyncResponse,
                 OpDefinitionType.SHORTHAND,
-                CallerReference.IMPLEMENTATION,
+                CallerReference.IMPLEMENTATION_OF_INTERFACE,
             ): MyServiceImpl.my_sync_operation,
             (
                 SyncResponse,
@@ -247,7 +248,7 @@ def _get_operation(
             (
                 SyncResponse,
                 OpDefinitionType.LONGHAND,
-                CallerReference.IMPLEMENTATION,
+                CallerReference.IMPLEMENTATION_OF_INTERFACE,
             ): MyServiceImpl.my_sync_or_async_operation,
             (
                 SyncResponse,
@@ -257,7 +258,7 @@ def _get_operation(
             (
                 AsyncResponse,
                 OpDefinitionType.SHORTHAND,
-                CallerReference.IMPLEMENTATION,
+                CallerReference.IMPLEMENTATION_OF_INTERFACE,
             ): MyServiceImpl.my_async_operation,
             (
                 AsyncResponse,
@@ -267,7 +268,7 @@ def _get_operation(
             (
                 AsyncResponse,
                 OpDefinitionType.LONGHAND,
-                CallerReference.IMPLEMENTATION,
+                CallerReference.IMPLEMENTATION_OF_INTERFACE,
             ): MyServiceImpl.my_sync_or_async_operation,
             (
                 AsyncResponse,
@@ -297,7 +298,8 @@ def _get_operation(
     "op_definition_type", [OpDefinitionType.SHORTHAND, OpDefinitionType.LONGHAND]
 )
 @pytest.mark.parametrize(
-    "caller_reference", [CallerReference.IMPLEMENTATION, CallerReference.INTERFACE]
+    "caller_reference",
+    [CallerReference.IMPLEMENTATION_OF_INTERFACE, CallerReference.INTERFACE],
 )
 async def test_sync_response(
     client: Client,
@@ -343,7 +345,8 @@ async def test_sync_response(
     "op_definition_type", [OpDefinitionType.SHORTHAND, OpDefinitionType.LONGHAND]
 )
 @pytest.mark.parametrize(
-    "caller_reference", [CallerReference.IMPLEMENTATION, CallerReference.INTERFACE]
+    "caller_reference",
+    [CallerReference.IMPLEMENTATION_OF_INTERFACE, CallerReference.INTERFACE],
 )
 async def test_async_response(
     client: Client,
@@ -469,13 +472,31 @@ class MyServiceInterfaceWithNameOverride:
     my_op: nexusrpc.interface.Operation[None, str]
 
 
+@nexusrpc.handler.service
+class MyServiceImplInterfaceWithNeitherInterfaceNorNameOverride:
+    @nexusrpc.handler.sync_operation
+    async def my_op(
+        self, input: None, options: nexusrpc.handler.StartOperationOptions
+    ) -> str:
+        return self.__class__.__name__
+
+
 @nexusrpc.handler.service(interface=MyServiceInterfaceWithoutNameOverride)
-class MyServiceImplWithoutNameOverride:
+class MyServiceImplInterfaceWithoutNameOverride:
+    @nexusrpc.handler.sync_operation
+    async def my_op(
+        self, input: None, options: nexusrpc.handler.StartOperationOptions
+    ) -> str:
+        return self.__class__.__name__
+
+
+@nexusrpc.handler.service(interface=MyServiceInterfaceWithNameOverride)
+class MyServiceImplInterfaceWithNameOverride:
     @nexusrpc.handler.sync_operation
     async def my_op(
         self, input: None, options: nexusrpc.handler.StartOperationOptions
     ) -> str:
-        return "from service impl with interface"
+        return self.__class__.__name__
 
 
 @nexusrpc.handler.service(name="my-service-impl-🌈")
@@ -484,7 +505,7 @@ class MyServiceImplWithNameOverride:
     async def my_op(
         self, input: None, options: nexusrpc.handler.StartOperationOptions
     ) -> str:
-        return "from service impl with name override"
+        return self.__class__.__name__
 
 
 class NameOverride(StrEnum):
@@ -511,13 +532,17 @@ async def run(
                 NameOverride.NO,
             ): MyServiceInterfaceWithoutNameOverride,
             (
-                CallerReference.IMPLEMENTATION,
+                CallerReference.IMPLEMENTATION_OF_INTERFACE,
                 NameOverride.YES,
             ): MyServiceImplWithNameOverride,
             (
-                CallerReference.IMPLEMENTATION,
+                CallerReference.IMPLEMENTATION_OF_INTERFACE,
                 NameOverride.NO,
-            ): MyServiceImplWithoutNameOverride,
+            ): MyServiceImplInterfaceWithoutNameOverride,
+            (
+                CallerReference.IMPLEMENTATION_WITHOUT_INTERFACE,
+                NameOverride.NO,
+            ): MyServiceImplInterfaceWithNeitherInterfaceNorNameOverride,
         }[caller_reference, name_override]
         nexus_client = workflow.NexusClient(
             service=service_cls,
@@ -532,12 +557,27 @@ async def run(
 
 
 async def test_service_interface_and_implementation_names(client: Client):
+    # Note that:
+    # - The caller can specify the service & operation via a reference to either the
+    #   interface or implementation class.
+    # - An interface class may optionally override its name.
+    # - An implementation class may either override its name or specify an interface that
+    #   it is implementing.
+    # - On registering a service implementation with a worker, the name by which the
+    #   service is addressed in requests is the interface name if the implementation
+    #   supplies one, or else the name override made by the impl class, or else the impl
+    #   class name.
+    #
+    # This test checks that the request is routed to the expected service under a variety
+    # of the possible scenarios arising from the above.
     task_queue = str(uuid.uuid4())
     async with Worker(
         client,
         nexus_services=[
-            MyServiceImplWithoutNameOverride(),
             MyServiceImplWithNameOverride(),
+            MyServiceImplInterfaceWithNameOverride(),
+            MyServiceImplInterfaceWithoutNameOverride(),
+            MyServiceImplInterfaceWithNeitherInterfaceNorNameOverride(),
         ],
         workflows=[MyServiceInterfaceAndImplCallerWorkflow],
         task_queue=task_queue,
@@ -551,7 +591,7 @@ async def test_service_interface_and_implementation_names(client: Client):
                 id=str(uuid.uuid4()),
                 task_queue=task_queue,
             )
-            == "from service interface with name override"
+            == "MyServiceImplInterfaceWithNameOverride"
         )
         assert (
             await client.execute_workflow(
@@ -560,25 +600,46 @@ async def test_service_interface_and_implementation_names(client: Client):
                 id=str(uuid.uuid4()),
                 task_queue=task_queue,
             )
-            == "from service interface without name override"
+            == "MyServiceImplInterfaceWithoutNameOverride"
+        )
+        assert (
+            await client.execute_workflow(
+                MyServiceInterfaceAndImplCallerWorkflow.run,
+                args=(
+                    CallerReference.IMPLEMENTATION_OF_INTERFACE,
+                    NameOverride.YES,
+                    task_queue,
+                ),
+                id=str(uuid.uuid4()),
+                task_queue=task_queue,
+            )
+            == "MyServiceImplWithNameOverride"
         )
         assert (
             await client.execute_workflow(
                 MyServiceInterfaceAndImplCallerWorkflow.run,
-                args=(CallerReference.IMPLEMENTATION, NameOverride.YES, task_queue),
+                args=(
+                    CallerReference.IMPLEMENTATION_OF_INTERFACE,
+                    NameOverride.NO,
+                    task_queue,
+                ),
                 id=str(uuid.uuid4()),
                 task_queue=task_queue,
             )
-            == "from service impl with interface and name override"
+            == "MyServiceImplInterfaceWithoutNameOverride"
         )
         assert (
             await client.execute_workflow(
                 MyServiceInterfaceAndImplCallerWorkflow.run,
-                args=(CallerReference.IMPLEMENTATION, NameOverride.NO, task_queue),
+                args=(
+                    CallerReference.IMPLEMENTATION_WITHOUT_INTERFACE,
+                    NameOverride.NO,
+                    task_queue,
+                ),
                 id=str(uuid.uuid4()),
                 task_queue=task_queue,
             )
-            == "from service impl with interface but without name override"
+            == "MyServiceImplInterfaceWithNeitherInterfaceNorNameOverride"
         )