Test service interface/impl with/without name

Author: dandavison

temporalio/workflow.py

@@ -5159,23 +5159,26 @@ def __init__(
         endpoint: str,
         schedule_to_close_timeout: Optional[timedelta] = None,
     ) -> None:
-        # TODO(dan): getattr here is a temporary hack. We need to be able to attach
-        # metadata (such as the service name) to service interfaces (perhaps setting a
-        # __metadata__ attribute?), as well as service implementations (they have a
-        # decorator that sets NexusServiceDefinition), and ensure all semantics are
-        # completely clear and consistent when using e.g. a service impl without an
-        # interface, or impl and interface with clashing names, or one without an
-        # explicitly-set name and the other with, etc.
+        # If service is not a str, then it must be a service interface or implementation
+        # class.
         if isinstance(service, str):
             self._service_name = service
         elif hasattr(service, "__nexus_service__"):
             self._service_name = service.__nexus_service__.name
+        elif hasattr(service, "__nexus_service_metadata__"):
+            self._service_name = service.__nexus_service_metadata__.name
         else:
-            self._service_name = service.__name__
+            raise ValueError(
+                f"`service` may be a name (str), or a class decorated with either "
+                f"@nexusrpc.handler.service or @nexusrpc.interface.service. "
+                f"Invalid service type: {type(service)}"
+            )
+        print(f"🌈 NexusClient using service name: {self._service_name}")
         self._endpoint = endpoint
         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,
@@ -459,6 +462,193 @@ async def _start_wf_and_nexus_op(
     return caller_wf_handle, handler_wf_handle
 
 
+@nexusrpc.interface.service
+class MyServiceInterfaceWithoutNameOverride:
+    my_op: nexusrpc.interface.Operation[None, str]
+
+
+@nexusrpc.interface.service(name="my-service-interface-🌈")
+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 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 self.__class__.__name__
+
+
+@nexusrpc.handler.service(name="my-service-impl-🌈")
+class MyServiceImplWithNameOverride:
+    @nexusrpc.handler.sync_operation
+    async def my_op(
+        self, input: None, options: nexusrpc.handler.StartOperationOptions
+    ) -> str:
+        return self.__class__.__name__
+
+
+class NameOverride(StrEnum):
+    YES = "yes"
+    NO = "no"
+
+
+@workflow.defn
+class MyServiceInterfaceAndImplCallerWorkflow:
+    @workflow.run
+    async def run(
+        self,
+        caller_reference: CallerReference,
+        name_override: NameOverride,
+        task_queue: str,
+    ) -> str:
+        service_cls = {
+            (
+                CallerReference.INTERFACE,
+                NameOverride.YES,
+            ): MyServiceInterfaceWithNameOverride,
+            (
+                CallerReference.INTERFACE,
+                NameOverride.NO,
+            ): MyServiceInterfaceWithoutNameOverride,
+            (
+                CallerReference.IMPLEMENTATION_OF_INTERFACE,
+                NameOverride.YES,
+            ): MyServiceImplWithNameOverride,
+            (
+                CallerReference.IMPLEMENTATION_OF_INTERFACE,
+                NameOverride.NO,
+            ): MyServiceImplInterfaceWithoutNameOverride,
+            (
+                CallerReference.IMPLEMENTATION_WITHOUT_INTERFACE,
+                NameOverride.NO,
+            ): MyServiceImplInterfaceWithNeitherInterfaceNorNameOverride,
+        }[caller_reference, name_override]
+        nexus_client = workflow.NexusClient(
+            service=service_cls,
+            endpoint=make_nexus_endpoint_name(task_queue),
+        )
+        return await nexus_client.execute_operation(service_cls.my_op, None)
+
+
+# TODO(dan): make it possible to refer to an impl that doesn't itself refer to an interface in its decorator
+# TODO(dan): allow decorator to be used without calling it
+# TODO(dan): check missing decorator behavior
+
+
+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 scenarios related to the above considerations.
+    task_queue = str(uuid.uuid4())
+    async with Worker(
+        client,
+        nexus_services=[
+            MyServiceImplWithNameOverride(),
+            MyServiceImplInterfaceWithNameOverride(),
+            MyServiceImplInterfaceWithoutNameOverride(),
+            MyServiceImplInterfaceWithNeitherInterfaceNorNameOverride(),
+        ],
+        workflows=[MyServiceInterfaceAndImplCallerWorkflow],
+        task_queue=task_queue,
+        workflow_runner=UnsandboxedWorkflowRunner(),
+    ):
+        await create_nexus_endpoint(task_queue, client)
+        assert (
+            await client.execute_workflow(
+                MyServiceInterfaceAndImplCallerWorkflow.run,
+                args=(CallerReference.INTERFACE, NameOverride.YES, task_queue),
+                id=str(uuid.uuid4()),
+                task_queue=task_queue,
+            )
+            == "MyServiceImplInterfaceWithNameOverride"
+        )
+        assert (
+            await client.execute_workflow(
+                MyServiceInterfaceAndImplCallerWorkflow.run,
+                args=(CallerReference.INTERFACE, NameOverride.NO, task_queue),
+                id=str(uuid.uuid4()),
+                task_queue=task_queue,
+            )
+            == "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_OF_INTERFACE,
+                    NameOverride.NO,
+                    task_queue,
+                ),
+                id=str(uuid.uuid4()),
+                task_queue=task_queue,
+            )
+            == "MyServiceImplInterfaceWithoutNameOverride"
+        )
+        assert (
+            await client.execute_workflow(
+                MyServiceInterfaceAndImplCallerWorkflow.run,
+                args=(
+                    CallerReference.IMPLEMENTATION_WITHOUT_INTERFACE,
+                    NameOverride.NO,
+                    task_queue,
+                ),
+                id=str(uuid.uuid4()),
+                task_queue=task_queue,
+            )
+            == "MyServiceImplInterfaceWithNeitherInterfaceNorNameOverride"
+        )
+
+
+# TODO(dan): test invalid service interface implementations
+# TODO(dan): test service impls and interfaces with and without names, conflicting names, etc.
+# TODO(dan): test impl used without interface
+# TODO(dan): test empty service impl/interface names
+
+
 def make_nexus_endpoint_name(task_queue: str) -> str:
     # Create endpoints for different task queues without name collisions.
     return f"nexus-endpoint-{task_queue}"