Skip tests under Java test server

Author: dandavison

tests/nexus/test_dynamic_creation_of_user_handler_classes.py

@@ -8,6 +8,7 @@
 from temporalio import nexus, workflow
 from temporalio.client import Client
 from temporalio.nexus._util import get_operation_factory
+from temporalio.testing import WorkflowEnvironment
 from temporalio.worker import Worker
 from tests.helpers.nexus import create_nexus_endpoint
 
@@ -69,7 +70,11 @@ def increment(self) -> nexusrpc.handler.OperationHandler[int, int]:
 
 async def test_run_nexus_service_from_programmatically_created_service_handler(
     client: Client,
+    env: WorkflowEnvironment,
 ):
+    if env.supports_time_skipping:
+        pytest.skip("Nexus tests don't work with time-skipping server")
+
     task_queue = str(uuid.uuid4())
 
     service_handler = nexusrpc.handler._core.ServiceHandler(

tests/nexus/test_handler.py

@@ -562,6 +562,9 @@ async def test_start_operation_happy_path(
     with_service_definition: bool,
     env: WorkflowEnvironment,
 ):
+    if env.supports_time_skipping:
+        pytest.skip("Nexus tests don't work with time-skipping server")
+
     if with_service_definition:
         await _test_start_operation_with_service_definition(test_case, env)
     else:
@@ -582,6 +585,9 @@ async def test_start_operation_happy_path(
 async def test_start_operation_protocol_level_failures(
     test_case: Type[_TestCase], env: WorkflowEnvironment
 ):
+    if env.supports_time_skipping:
+        pytest.skip("Nexus tests don't work with time-skipping server")
+
     await _test_start_operation_with_service_definition(test_case, env)
 
 
@@ -596,6 +602,9 @@ async def test_start_operation_protocol_level_failures(
 async def test_start_operation_operation_failures(
     test_case: Type[_TestCase], env: WorkflowEnvironment
 ):
+    if env.supports_time_skipping:
+        pytest.skip("Nexus tests don't work with time-skipping server")
+
     await _test_start_operation_with_service_definition(test_case, env)
 
 
@@ -722,6 +731,9 @@ class AsyncHandlerHappyPathWithoutTypeAnnotations(_TestCase):
 async def test_start_operation_without_type_annotations(
     test_case: Type[_TestCase], env: WorkflowEnvironment
 ):
+    if env.supports_time_skipping:
+        pytest.skip("Nexus tests don't work with time-skipping server")
+
     if test_case.skip:
         pytest.skip(test_case.skip)
     task_queue = str(uuid.uuid4())
@@ -765,6 +777,9 @@ def test_operation_without_type_annotations_without_service_definition_raises_va
 
 
 async def test_logger_uses_operation_context(env: WorkflowEnvironment, caplog: Any):
+    if env.supports_time_skipping:
+        pytest.skip("Nexus tests don't work with time-skipping server")
+
     task_queue = str(uuid.uuid4())
     service_name = MyService.__name__
     operation_name = "log"
@@ -923,6 +938,9 @@ async def test_handler_instantiation(
 
 
 async def test_cancel_operation_with_invalid_token(env: WorkflowEnvironment):
+    if env.supports_time_skipping:
+        pytest.skip("Nexus tests don't work with time-skipping server")
+
     """Verify that canceling an operation with an invalid token fails correctly."""
     task_queue = str(uuid.uuid4())
     endpoint = (await create_nexus_endpoint(task_queue, env.client)).endpoint.id
@@ -953,6 +971,9 @@ async def test_cancel_operation_with_invalid_token(env: WorkflowEnvironment):
 async def test_request_id_is_received_by_sync_operation(
     env: WorkflowEnvironment,
 ):
+    if env.supports_time_skipping:
+        pytest.skip("Nexus tests don't work with time-skipping server")
+
     task_queue = str(uuid.uuid4())
     endpoint = (await create_nexus_endpoint(task_queue, env.client)).endpoint.id
     service_client = ServiceClient(
@@ -1019,6 +1040,9 @@ async def operation_that_executes_a_workflow_before_starting_the_backing_workflo
 
 
 async def test_request_id_becomes_start_workflow_request_id(env: WorkflowEnvironment):
+    if env.supports_time_skipping:
+        pytest.skip("Nexus tests don't work with time-skipping server")
+
     # We send two Nexus requests that would start a workflow with the same workflow ID,
     # using reuse_policy=REJECT_DUPLICATE. This would fail if they used different
     # request IDs. However, when we use the same request ID, it does not fail,

tests/nexus/test_handler_async_operation.py

@@ -144,6 +144,9 @@ async def test_async_operation_lifecycle(
         Type[MyServiceHandlerWithNonAsyncDefs],
     ],
 ):
+    if env.supports_time_skipping:
+        pytest.skip("Nexus tests don't work with time-skipping server")
+
     task_executor = await TaskExecutor.connect()
     task_queue = str(uuid.uuid4())
     endpoint = (await create_nexus_endpoint(task_queue, env.client)).endpoint.id

tests/nexus/test_workflow_caller.py

@@ -47,6 +47,7 @@
 )
 from temporalio.nexus import WorkflowRunOperationContext, workflow_run_operation
 from temporalio.service import RPCError, RPCStatusCode
+from temporalio.testing import WorkflowEnvironment
 from temporalio.worker import Worker
 from tests.helpers.nexus import create_nexus_endpoint, make_nexus_endpoint_name
 
@@ -443,11 +444,15 @@ async def run(
 )
 async def test_sync_response(
     client: Client,
+    env: WorkflowEnvironment,
     exception_in_operation_start: bool,
     request_cancel: bool,
     op_definition_type: OpDefinitionType,
     caller_reference: CallerReference,
 ):
+    if env.supports_time_skipping:
+        pytest.skip("Nexus tests don't work with time-skipping server")
+
     task_queue = str(uuid.uuid4())
     async with Worker(
         client,
@@ -514,11 +519,15 @@ async def test_sync_response(
 )
 async def test_async_response(
     client: Client,
+    env: WorkflowEnvironment,
     exception_in_operation_start: bool,
     request_cancel: bool,
     op_definition_type: OpDefinitionType,
     caller_reference: CallerReference,
 ):
+    if env.supports_time_skipping:
+        pytest.skip("Nexus tests don't work with time-skipping server")
+
     task_queue = str(uuid.uuid4())
     async with Worker(
         client,
@@ -669,11 +678,15 @@ async def _start_wf_and_nexus_op(
 @pytest.mark.parametrize("response_type", [SyncResponse, AsyncResponse])
 async def test_untyped_caller(
     client: Client,
+    env: WorkflowEnvironment,
     exception_in_operation_start: bool,
     op_definition_type: OpDefinitionType,
     caller_reference: CallerReference,
     response_type: ResponseType,
 ):
+    if env.supports_time_skipping:
+        pytest.skip("Nexus tests don't work with time-skipping server")
+
     task_queue = str(uuid.uuid4())
     async with Worker(
         client,
@@ -830,7 +843,12 @@ async def run(
 # TODO(nexus-prerelease): check missing decorator behavior
 
 
-async def test_service_interface_and_implementation_names(client: Client):
+async def test_service_interface_and_implementation_names(
+    client: Client, env: WorkflowEnvironment
+):
+    if env.supports_time_skipping:
+        pytest.skip("Nexus tests don't work with time-skipping server")
+
     # Note that:
     # - The caller can specify the service & operation via a reference to either the
     #   interface or implementation class.
@@ -956,7 +974,11 @@ async def run(self, input: str, task_queue: str) -> str:
 
 async def test_workflow_run_operation_can_execute_workflow_before_starting_backing_workflow(
     client: Client,
+    env: WorkflowEnvironment,
 ):
+    if env.supports_time_skipping:
+        pytest.skip("Nexus tests don't work with time-skipping server")
+
     task_queue = str(uuid.uuid4())
     async with Worker(
         client,
@@ -1222,7 +1244,12 @@ async def run(self, op: str, input: OverloadTestValue) -> OverloadTestValue:
         "by_name_multi_param",
     ],
 )
-async def test_workflow_run_operation_overloads(client: Client, op: str):
+async def test_workflow_run_operation_overloads(
+    client: Client, env: WorkflowEnvironment, op: str
+):
+    if env.supports_time_skipping:
+        pytest.skip("Nexus tests don't work with time-skipping server")
+
     task_queue = str(uuid.uuid4())
     async with Worker(
         client,

tests/nexus/test_workflow_caller_error_chains.py

@@ -20,6 +20,7 @@
     ApplicationError,
     NexusOperationError,
 )
+from temporalio.testing import WorkflowEnvironment
 from temporalio.worker import Worker
 from tests.helpers.nexus import create_nexus_endpoint, make_nexus_endpoint_name
 
@@ -398,8 +399,11 @@ async def invoke_nexus_op_and_assert_error(self, input: ErrorTestInput) -> None:
 
 @pytest.mark.parametrize("test_case", list(error_conversion_test_cases.values()))
 async def test_errors_raised_by_nexus_operation(
-    client: Client, test_case: type[ErrorConversionTestCase]
+    client: Client, env: WorkflowEnvironment, test_case: type[ErrorConversionTestCase]
 ):
+    if env.supports_time_skipping:
+        pytest.skip("Nexus tests don't work with time-skipping server")
+
     task_queue = str(uuid.uuid4())
     async with Worker(
         client,

tests/nexus/test_workflow_caller_errors.py

@@ -31,6 +31,7 @@
     NexusOperationError,
     TimeoutError,
 )
+from temporalio.testing import WorkflowEnvironment
 from temporalio.worker import Worker
 from tests.helpers import assert_eq_eventually
 from tests.helpers.nexus import create_nexus_endpoint, make_nexus_endpoint_name
@@ -107,7 +108,12 @@ async def run(self, input: ErrorTestInput) -> None:
         "retried_due_to_internal_handler_error",
     ],
 )
-async def test_nexus_operation_is_retried(client: Client, operation_name: str):
+async def test_nexus_operation_is_retried(
+    client: Client, env: WorkflowEnvironment, operation_name: str
+):
+    if env.supports_time_skipping:
+        pytest.skip("Nexus tests don't work with time-skipping server")
+
     input = ErrorTestInput(
         service_name="ErrorTestService",
         operation_name=operation_name,
@@ -154,10 +160,14 @@ async def times_called() -> int:
 )
 async def test_nexus_operation_fails_without_retry_as_handler_error(
     client: Client,
+    env: WorkflowEnvironment,
     operation_name: str,
     handler_error_type: nexusrpc.HandlerErrorType,
     handler_error_message: str,
 ):
+    if env.supports_time_skipping:
+        pytest.skip("Nexus tests don't work with time-skipping server")
+
     input = ErrorTestInput(
         service_name=(
             "ErrorTestService"
@@ -224,7 +234,12 @@ async def run(self) -> None:
         )
 
 
-async def test_error_raised_by_timeout_of_nexus_start_operation(client: Client):
+async def test_error_raised_by_timeout_of_nexus_start_operation(
+    client: Client, env: WorkflowEnvironment
+):
+    if env.supports_time_skipping:
+        pytest.skip("Nexus tests don't work with time-skipping server")
+
     task_queue = str(uuid.uuid4())
     async with Worker(
         client,
@@ -302,7 +317,12 @@ async def run(self) -> None:
         await op_handle
 
 
-async def test_error_raised_by_timeout_of_nexus_cancel_operation(client: Client):
+async def test_error_raised_by_timeout_of_nexus_cancel_operation(
+    client: Client, env: WorkflowEnvironment
+):
+    if env.supports_time_skipping:
+        pytest.skip("Nexus tests don't work with time-skipping server")
+
     pytest.skip("TODO(nexus-prerelease): finish writing this test")
     task_queue = str(uuid.uuid4())
     async with Worker(

tests/nexus/test_workflow_run_operation.py

@@ -90,6 +90,9 @@ async def test_workflow_run_operation(
     env: WorkflowEnvironment,
     service_handler_cls: Type[Any],
 ):
+    if env.supports_time_skipping:
+        pytest.skip("Nexus tests don't work with time-skipping server")
+
     task_queue = str(uuid.uuid4())
     endpoint = (await create_nexus_endpoint(task_queue, env.client)).endpoint.id
     assert (service_defn := nexusrpc.get_service_definition(service_handler_cls))