Test service interface/impl with/without name

Author: dandavison

temporalio/workflow.py

@@ -5159,19 +5159,21 @@ 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
 

tests/worker/test_nexus.py

@@ -459,6 +459,135 @@ 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(interface=MyServiceInterfaceWithoutNameOverride)
+class MyServiceImplWithoutNameOverride:
+    @nexusrpc.handler.sync_operation
+    async def my_op(
+        self, input: None, options: nexusrpc.handler.StartOperationOptions
+    ) -> str:
+        return "from service impl with interface"
+
+
+@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 "from service impl with name override"
+
+
+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,
+                NameOverride.YES,
+            ): MyServiceImplWithNameOverride,
+            (
+                CallerReference.IMPLEMENTATION,
+                NameOverride.NO,
+            ): MyServiceImplWithoutNameOverride,
+        }[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):
+    task_queue = str(uuid.uuid4())
+    async with Worker(
+        client,
+        nexus_services=[
+            MyServiceImplWithoutNameOverride(),
+            MyServiceImplWithNameOverride(),
+        ],
+        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,
+            )
+            == "from service interface with name override"
+        )
+        assert (
+            await client.execute_workflow(
+                MyServiceInterfaceAndImplCallerWorkflow.run,
+                args=(CallerReference.INTERFACE, NameOverride.NO, task_queue),
+                id=str(uuid.uuid4()),
+                task_queue=task_queue,
+            )
+            == "from service interface without name override"
+        )
+        assert (
+            await client.execute_workflow(
+                MyServiceInterfaceAndImplCallerWorkflow.run,
+                args=(CallerReference.IMPLEMENTATION, NameOverride.YES, task_queue),
+                id=str(uuid.uuid4()),
+                task_queue=task_queue,
+            )
+            == "from service impl with interface and name override"
+        )
+        assert (
+            await client.execute_workflow(
+                MyServiceInterfaceAndImplCallerWorkflow.run,
+                args=(CallerReference.IMPLEMENTATION, NameOverride.NO, task_queue),
+                id=str(uuid.uuid4()),
+                task_queue=task_queue,
+            )
+            == "from service impl with interface but without name override"
+        )
+
+
+# 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}"