durable-workflow 2.5.0__tar.gz → 2.5.2__tar.gz

{durable_workflow-2.5.0/src/durable_workflow.egg-info → durable_workflow-2.5.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: durable-workflow
-Version: 2.5.0
+Version: 2.5.2
 Summary: Python client and worker SDK for Durable Workflow Cloud and self-hosted Server
 Author: Durable Workflow Contributors
 License-Expression: MIT

{durable_workflow-2.5.0 → durable_workflow-2.5.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "durable-workflow"
-version = "2.5.0"
+version = "2.5.2"
 description = "Python client and worker SDK for Durable Workflow Cloud and self-hosted Server"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -71,9 +71,9 @@ durable-workflow-replay-conformance = "durable_workflow.replay_conformance:main"
 durable-workflow-workflow-updates-conformance = "durable_workflow.workflow_updates_conformance:main"
 
 [tool.durable-workflow]
-product-train = "2.5.0"
-registry-version = "2.5.0"
-supported-server-versions = "2.5.0"
+product-train = "2.5.2"
+registry-version = "2.5.2"
+supported-server-versions = "2.5.16"
 worker-protocol-version = "1.19"
 control-plane-version = "2"
 durable-selection = true

{durable_workflow-2.5.0 → durable_workflow-2.5.2}/src/durable_workflow/__init__.py

@@ -81,6 +81,7 @@ from .errors import (
     ExternalPayloadUnavailable,
     ExternalPayloadUnsupported,
     InvalidArgument,
+    InvalidWorkflowDefinition,
     NamespaceNotFound,
     NexusOperationFailed,
     NonDeterministicReplayError,
@@ -369,6 +370,7 @@ __all__ = [
     "NexusOperationResult",
     "NexusServiceCall",
     "NonDeterministicReplayError",
+    "InvalidWorkflowDefinition",
     "NoopMetrics",
     "QueryFailed",
     "RuntimeCapabilityUnsupported",

{durable_workflow-2.5.0 → durable_workflow-2.5.2}/src/durable_workflow/errors.py

@@ -27,6 +27,10 @@ class DurableWorkflowError(Exception):
     """Base class for every exception raised by the SDK."""
 
 
+class InvalidWorkflowDefinition(DurableWorkflowError, ValueError):
+    """Workflow authoring uses an unsupported entry point or result."""
+
+
 class DurableOperationCancelled(DurableWorkflowError):
     """A durable selection member was explicitly cancelled."""
 

{durable_workflow-2.5.0 → durable_workflow-2.5.2}/src/durable_workflow/testing.py

@@ -51,6 +51,7 @@ from .workflow import (
     StartChildWorkflow,
     StartTimer,
     UpsertSearchAttributes,
+    _validate_workflow_entrypoint,
     registry,
     replay,
 )
@@ -134,6 +135,7 @@ class WorkflowEnvironment:
                 f"{workflow_cls!r} is not a workflow class; "
                 "decorate it with @workflow.defn(name=...) first."
             )
+        _validate_workflow_entrypoint(workflow_cls)
         self._registered_workflows[name] = workflow_cls
 
     def signal(

{durable_workflow-2.5.0 → durable_workflow-2.5.2}/src/durable_workflow/worker.py

@@ -104,6 +104,7 @@ from .workflow import (
     ScheduleActivity,
     StartChildWorkflow,
     UpsertMemo,
+    _validate_workflow_entrypoint,
     apply_update,
     commands_to_server_commands,
     query_state,
@@ -1023,7 +1024,10 @@ class Worker:
     ) -> None:
         self.client = client
         self.task_queue = task_queue
-        self.workflows = {_workflow_name(w): w for w in workflows}
+        self.workflows: dict[str, type] = {}
+        for definition in workflows:
+            _validate_workflow_entrypoint(definition)
+            self.workflows[_workflow_name(definition)] = definition
         self.workflow_definition_fingerprints = {
             workflow_type: _workflow_definition_fingerprint(workflow_cls)
             for workflow_type, workflow_cls in self.workflows.items()

{durable_workflow-2.5.0 → durable_workflow-2.5.2}/src/durable_workflow/workflow.py

@@ -21,6 +21,7 @@ from __future__ import annotations
 import base64
 import contextlib
 import hashlib
+import inspect
 import logging
 import math
 import random
@@ -58,6 +59,7 @@ from .errors import (
     ChildWorkflowFailed,
     ChildWorkflowTerminated,
     DurableOperationCancelled,
+    InvalidWorkflowDefinition,
     NexusOperationFailed,
     NonDeterministicReplayError,
     QueryFailed,
@@ -97,6 +99,31 @@ MESSAGE_STREAM_CURSOR_SCHEMA = "durable-workflow.v2.message-stream.cursor"
 MESSAGE_STREAM_MAX_BATCH = 100
 
 
+def _validate_workflow_entrypoint(cls: type) -> None:
+    entrypoint = getattr(cls, "run", None)
+    if not callable(entrypoint):
+        return
+    targets = [inspect.unwrap(entrypoint)]
+    if not inspect.isroutine(targets[0]):
+        targets.append(inspect.unwrap(targets[0].__call__))
+    if any(inspect.iscoroutinefunction(target) or inspect.isasyncgenfunction(target) for target in targets):
+        name = getattr(cls, "__workflow_name__", cls.__name__)
+        raise InvalidWorkflowDefinition(
+            f"unsupported_workflow_entrypoint: workflow {name!r} ({cls.__qualname__}.run) "
+            "must use a synchronous function or generator; yield durable commands instead of async def."
+        )
+
+
+def _validate_workflow_result(value: Any, cls: type) -> None:
+    if inspect.isawaitable(value) or inspect.isasyncgen(value):
+        if inspect.iscoroutine(value):
+            value.close()
+        raise InvalidWorkflowDefinition(
+            f"unsupported_workflow_result: {cls.__qualname__}.run returned an async value; "
+            "use a synchronous result or yield durable commands."
+        )
+
+
 def defn(*, name: str) -> Callable[[type[_WorkflowT]], type[_WorkflowT]]:
     """Register a class as a workflow type under a language-neutral name.
 
@@ -108,6 +135,7 @@ def defn(*, name: str) -> Callable[[type[_WorkflowT]], type[_WorkflowT]]:
 
     def wrap(cls: type[_WorkflowT]) -> type[_WorkflowT]:
         cls.__workflow_name__ = name  # type: ignore[attr-defined]
+        _validate_workflow_entrypoint(cls)
         signals: dict[str, str] = {}
         queries: dict[str, str] = {}
         updates: dict[str, str] = {}
@@ -4037,6 +4065,7 @@ def _replay_state(
     allow_cancellation_scope_authoring: bool = False,
     allow_cancellation_scope_delivery: bool = False,
 ) -> _ReplayState:
+    _validate_workflow_entrypoint(workflow_cls)
     if allow_cancellation_scope_delivery and not allow_cancellation_scope_authoring:
         raise LocalActivityExecutionAborted("scope delivery requires canonical scope authoring")
     if prepare_local_activity_groups and not prepare_local_activities:
@@ -5172,6 +5201,7 @@ def _replay_state(
     except Exception as exc:
         return _state([_fail_workflow_from_exception(exc)])
     if not hasattr(gen, "__next__"):
+        _validate_workflow_result(gen, workflow_cls)
         if isinstance(gen, ContinueAsNew):
             _assert_no_unconsumed_history("continue as new")
             return _state([gen])
@@ -5185,6 +5215,96 @@ def _replay_state(
     pending: list[Command] = []
     advanced_cmd: Any = None
     terminal_condition_reopen_cmd: WaitCondition | None = None
+    version_decisions: dict[str, tuple[int, str]] = {}
+
+    def _version_error(detail: str, step: _RecordedStep | None = None) -> NonDeterministicReplayError:
+        return NonDeterministicReplayError(
+            step.workflow_sequence if step is not None else authored_sequence,
+            "compatible version marker",
+            step.event_types if step is not None else [],
+            detail=detail,
+        )
+
+    def _recorded_version(step: _RecordedStep) -> int:
+        if step.history_index is None:
+            raise _version_error("Version marker is missing its history position.", step)
+        payload = events[step.history_index].get("payload") or {}
+        version = payload.get("version")
+        if type(version) is not int:
+            raise _version_error("Version marker must contain an integer version.", step)
+        change_id = payload.get("change_id")
+        if "change_id" in payload and (not isinstance(change_id, str) or not change_id.strip()):
+            raise _version_error("Version marker must retain a non-empty change ID.", step)
+        if "min_supported" in payload or "max_supported" in payload:
+            minimum, maximum = payload.get("min_supported"), payload.get("max_supported")
+            if (type(minimum) is not int or type(maximum) is not int
+                    or not minimum <= version <= maximum):
+                raise _version_error("Recorded version marker has an invalid supported range.", step)
+        return version
+
+    def _consume_duplicate_version_markers() -> None:
+        nonlocal result_cursor, authored_sequence
+        if not version_decisions:
+            return
+        while result_cursor < len(recorded_steps):
+            step = recorded_steps[result_cursor]
+            change_id = step.details.get("change_id")
+            if step.shape != "version marker" or change_id not in version_decisions:
+                return
+            if _next_unconsumed_recorded_step() is not step:
+                return
+            version = _recorded_version(step)
+            if version != version_decisions[change_id][0]:
+                raise _version_error(f"Conflicting recorded decisions for change ID {change_id!r}.", step)
+            # Earlier SDKs emitted a marker for every invocation. Consume these
+            # aliases while retaining their physical positions for cancellation
+            # and prepared operations. The stored history itself is unchanged.
+            result_cursor += 1
+            authored_sequence = max(authored_sequence, step.workflow_sequence + 1)
+
+    def _resolve_version(command: RecordVersionMarker) -> Any:
+        nonlocal result_cursor, authored_sequence
+        change_id = command.change_id
+        if not isinstance(change_id, str) or not change_id.strip():
+            raise _version_error("Version markers require a stable non-empty change ID.")
+        if (type(command.min_supported) is not int or type(command.max_supported) is not int
+                or command.min_supported > command.max_supported):
+            raise _version_error(f"Invalid supported range for change ID {change_id!r}.")
+        family = "version" if command.result_kind == "version" else "patch"
+        decision = version_decisions.get(change_id)
+        step = _next_unconsumed_recorded_step()
+        if decision is not None:
+            version, original_family = decision
+            if original_family != family:
+                raise _version_error(f"Change ID {change_id!r} cannot switch between version and patch helpers.", step)
+        elif step is not None and step.shape == "version marker":
+            _assert_step_matches(command, step)
+            version = _recorded_version(step)
+            result_cursor += 1
+            authored_sequence = max(authored_sequence, step.workflow_sequence + 1)
+        elif step is not None or (cancellation.delivery is not None and not cancellation_consumed) or any(
+            sequence not in consumed_scope_deliveries for sequence in committed_scopes.deliveries
+        ) or any(_history_event_type(event) in {
+            "WorkflowCompleted", "WorkflowFailed", "WorkflowCancelled", "WorkflowTerminated",
+            "WorkflowContinuedAsNew", "WorkflowTimedOut",
+        } for event in events):
+            # An unmarked recorded command proves this history passed the new
+            # patch site. Leave that command available for its original call.
+            version = -1
+        else:
+            version = command.version
+            if type(version) is not int:
+                raise _version_error(f"Invalid version for change ID {change_id!r}.")
+            ctx.logger._set_replaying(False)
+            pending.append(command)
+            authored_sequence += 1
+        if not command.min_supported <= version <= command.max_supported:
+            raise _version_error(
+                f"Recorded version {version} for change ID {change_id!r} is outside "
+                f"the supported range {command.min_supported}..{command.max_supported}.", step,
+            )
+        version_decisions.setdefault(change_id, (version, family))
+        return _version_marker_result(command, version)
 
     def _parallel_leaf_kind(command: Any) -> str:
         if isinstance(command, ScheduleActivity | RecordLocalActivity):
@@ -5942,6 +6062,7 @@ def _replay_state(
         return next(iter(memberships))
 
     def _terminal_state(value: Any, *, include_pending: bool) -> _ReplayState:
+        _validate_workflow_result(value, workflow_cls)
         _apply_due_receivers()
         _consume_terminal_condition_reopens()
         commands = list(pending) if include_pending else []
@@ -6064,6 +6185,7 @@ def _replay_state(
     replay_token = _ACTIVE_WORKFLOW_REPLAY.set(ctx)
     try:
         while True:
+            _consume_duplicate_version_markers()
             # Cursor-0 receivers are start-boundary events. Enter run() once
             # before applying them so workflow initialization observes the
             # same WorkflowStarted-before-Signal/Update ordering the server
@@ -6081,6 +6203,9 @@ def _replay_state(
                 first = False
             _apply_due_receivers()
             _validate_local_activity_policies(cmd)
+            if isinstance(cmd, RecordVersionMarker):
+                next_value = _resolve_version(cmd)
+                continue
             if prepare_local_activities and isinstance(cmd, list | SelectGroup) and _contains_local_activity(cmd) and (
                 not prepare_local_activity_groups or isinstance(cmd, SelectGroup)
             ):
@@ -6497,18 +6622,6 @@ def _replay_state(
                 pending.append(cmd)
                 next_value = None
                 continue
-            if isinstance(cmd, RecordVersionMarker):
-                if result_cursor < len(resolved_results):
-                    _assert_next_step_matches(cmd)
-                    val = resolved_results[result_cursor]
-                    result_cursor += 1
-                    next_value = _version_marker_result(cmd, val)
-                    continue
-                ctx.logger._set_replaying(False)
-                _assert_pending_step_matches(cmd)
-                pending.append(cmd)
-                next_value = _version_marker_result(cmd, cmd.version)
-                continue
             if isinstance(cmd, WaitCondition):
                 # A condition that is already true is not persisted. Apply
                 # receivers at the yield boundary before deciding whether the
@@ -6702,10 +6815,10 @@ def _replay_state(
         try:
             return _terminal_state(stop.value, include_pending=True)
         except Exception as exc:
-            if isinstance(exc, NonDeterministicReplayError):
+            if isinstance(exc, (NonDeterministicReplayError, InvalidWorkflowDefinition)):
                 raise
             return _state(pending + [_fail_workflow_from_exception(exc)])
-    except NonDeterministicReplayError:
+    except (NonDeterministicReplayError, InvalidWorkflowDefinition):
         raise
     except LocalActivityExecutionAborted:
         raise

{durable_workflow-2.5.0 → durable_workflow-2.5.2/src/durable_workflow.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: durable-workflow
-Version: 2.5.0
+Version: 2.5.2
 Summary: Python client and worker SDK for Durable Workflow Cloud and self-hosted Server
 Author: Durable Workflow Contributors
 License-Expression: MIT

{durable_workflow-2.5.0 → durable_workflow-2.5.2}/src/durable_workflow.egg-info/SOURCES.txt

@@ -82,6 +82,7 @@ tests/test_metrics.py
 tests/test_order_processing_example.py
 tests/test_parallel_completion_order_replay.py
 tests/test_parallel_saga_authoring.py
+tests/test_patch_history.py
 tests/test_pending_operation_replay.py
 tests/test_prepared_local_activity_client.py
 tests/test_prepared_local_activity_groups.py
@@ -116,6 +117,7 @@ tests/test_updates.py
 tests/test_wait_condition.py
 tests/test_worker.py
 tests/test_worker_session.py
+tests/test_workflow_entrypoint_validation.py
 tests/test_workflow_result_timeout.py
 tests/test_workflow_streams.py
 tests/test_workflow_updates_conformance.py

{durable_workflow-2.5.0 → durable_workflow-2.5.2}/tests/test_cooperative_remote_worker.py

@@ -47,22 +47,29 @@ def stop_receipt() -> dict[str, Any]:
             "heartbeat_recorded": False, "history_event_id": "receipt-event"}
 
 
+def write_pid_marker(marker: str) -> None:
+    target = Path(marker)
+    pending = target.with_name(target.name + ".pending")
+    pending.write_text(str(os.getpid()))
+    pending.replace(target)
+
+
 async def blocked_async(marker: str, heartbeat: bool = False) -> None:
     if heartbeat:
         await activity.context().heartbeat({"authored": True})
-    Path(marker).write_text(str(os.getpid()))
+    write_pid_marker(marker)
     await asyncio.Event().wait()
 
 
 def blocked_sync(marker: str, heartbeat: bool = False) -> None:
     if heartbeat:
         asyncio.run(activity.context().heartbeat({"authored": True}))
-    Path(marker).write_text(str(os.getpid()))
+    write_pid_marker(marker)
     time.sleep(60)
 
 
 def released_sync(marker: str) -> bytes:
-    Path(marker).write_text(str(os.getpid()))
+    write_pid_marker(marker)
     while not Path(marker + ".release").exists():
         time.sleep(0.02)
     return b"late result"

durable_workflow-2.5.2/tests/test_patch_history.py

@@ -0,0 +1,145 @@
+from __future__ import annotations
+
+from typing import Any
+
+import pytest
+
+from durable_workflow import serializer, workflow
+from durable_workflow.errors import NonDeterministicReplayError, WorkflowCancelled
+from durable_workflow.workflow import CompleteWorkflow, RecordVersionMarker, ScheduleActivity, replay
+from tests.test_cooperative_cancellation import marker as cancellation_marker
+from tests.test_cooperative_cancellation import request
+
+
+def version_marker(sequence: int, change_id: str = "same", version: int = 1) -> dict[str, Any]:
+    return {"event_type": "VersionMarkerRecorded", "payload": {
+        "sequence": sequence, "change_id": change_id, "version": version,
+        "min_supported": -1, "max_supported": 1,
+    }}
+
+
+def old_activity(sequence: int, completed: bool = True) -> list[dict[str, Any]]:
+    history = [{"event_type": "ActivityScheduled", "payload": {
+        "sequence": sequence, "activity_type": "old",
+    }}]
+    if completed:
+        history.append({"event_type": "ActivityCompleted", "payload": {
+            "sequence": sequence, "activity_type": "old", "result": serializer.encode("recorded"),
+            "payload_codec": "avro",
+        }})
+    return history
+
+
+@workflow.defn(name="tests.patch.insertion")
+class PatchInsertionWorkflow:
+    def run(self, ctx):  # type: ignore[no-untyped-def]
+        if (yield ctx.patched("same")):
+            yield ctx.schedule_activity("new", [])
+        return (yield ctx.schedule_activity("old", []))
+
+
+@workflow.defn(name="tests.patch.repeated")
+class RepeatedPatchWorkflow:
+    def run(self, ctx, repeat=True):  # type: ignore[no-untyped-def]
+        first = yield ctx.patched("same")
+        second = (yield ctx.patched("same")) if repeat else first
+        result = yield ctx.schedule_activity("old", [])
+        return [first, second, result]
+
+
+@workflow.defn(name="tests.patch.interleaved")
+class InterleavedPatchWorkflow:
+    def run(self, ctx, repeat=True):  # type: ignore[no-untyped-def]
+        first = yield ctx.patched("same")
+        result = yield ctx.schedule_activity("old", [])
+        second = (yield ctx.patched("same")) if repeat else first
+        return [first, second, result]
+
+
+@workflow.defn(name="tests.patch.ranges")
+class VersionRangeWorkflow:
+    def run(self, ctx, minimum=1, mixed=False):  # type: ignore[no-untyped-def]
+        first = yield ctx.get_version("same", 1, 2)
+        second = (yield ctx.patched("same")) if mixed else (yield ctx.get_version("same", minimum, 3))
+        return [first, second]
+
+
+@workflow.defn(name="tests.patch.cancellation")
+class PatchCancellationWorkflow:
+    def run(self, ctx):  # type: ignore[no-untyped-def]
+        decisions = [(yield ctx.patched("same")), (yield ctx.patched("same"))]
+        try:
+            yield ctx.schedule_activity("old", [])
+        except WorkflowCancelled:
+            return [decisions, "cancelled"]
+
+
+@pytest.mark.parametrize("completed", [False, True])
+def test_inserted_patch_preserves_unmarked_activity(completed: bool) -> None:
+    outcome = replay(PatchInsertionWorkflow, old_activity(1, completed), [])
+    if completed:
+        assert len(outcome.commands) == 1
+        command = outcome.commands[0]
+        assert isinstance(command, CompleteWorkflow)
+        assert command.result == "recorded"
+    else:
+        # The old activity is already scheduled. Await it without duplicating
+        # that command or introducing the new patched activity.
+        assert outcome.commands == []
+
+
+def test_repeated_patch_emits_one_marker_on_new_history() -> None:
+    commands = replay(RepeatedPatchWorkflow, [], []).commands
+    assert [type(command) for command in commands] == [RecordVersionMarker, ScheduleActivity]
+
+
+@pytest.mark.parametrize("repeat", [False, True])
+@pytest.mark.parametrize("duplicates", [False, True])
+def test_old_consistent_duplicate_markers_remain_replayable(repeat: bool, duplicates: bool) -> None:
+    history = [version_marker(1)]
+    if duplicates:
+        history.append(version_marker(2))
+    history += old_activity(3 if duplicates else 2)
+    commands = replay(RepeatedPatchWorkflow, history, [repeat]).commands
+    assert len(commands) == 1
+    assert isinstance(commands[0], CompleteWorkflow)
+    assert commands[0].result == [True, True, "recorded"]
+
+
+@pytest.mark.parametrize("repeat", [False, True])
+def test_duplicate_markers_after_an_activity_remain_replayable(repeat: bool) -> None:
+    history = [version_marker(1)] + old_activity(2) + [version_marker(3)]
+    commands = replay(InterleavedPatchWorkflow, history, [repeat]).commands
+    assert len(commands) == 1
+    assert isinstance(commands[0], CompleteWorkflow)
+    assert commands[0].result == [True, True, "recorded"]
+
+
+def test_repeated_version_reuses_first_decision() -> None:
+    commands = replay(VersionRangeWorkflow, [], []).commands
+    assert [type(command) for command in commands] == [RecordVersionMarker, CompleteWorkflow]
+    assert commands[-1].result == [2, 2]
+
+
+@pytest.mark.parametrize("arguments", [[3], [1, True]])
+def test_repeated_version_rejects_incompatible_range_or_family(arguments: list[Any]) -> None:
+    with pytest.raises(NonDeterministicReplayError):
+        replay(VersionRangeWorkflow, [], arguments)
+
+
+@pytest.mark.parametrize("version", [-1, 2, True])
+def test_conflicting_duplicate_marker_is_rejected(version: Any) -> None:
+    history = [version_marker(1), version_marker(2, version=version)] + old_activity(3)
+    with pytest.raises(NonDeterministicReplayError):
+        replay(RepeatedPatchWorkflow, history, [])
+
+
+@pytest.mark.parametrize("marker_count", [0, 1, 2])
+def test_patch_decisions_preserve_committed_cancellation_sequence(marker_count: int) -> None:
+    history = [version_marker(sequence) for sequence in range(1, marker_count + 1)]
+    history += old_activity(marker_count + 1, False)
+    history += [request(), cancellation_marker(marker_count + 1)]
+    commands = replay(PatchCancellationWorkflow, history, [], run_id="run-1").commands
+    assert len(commands) == 1
+    assert isinstance(commands[0], CompleteWorkflow)
+    assert commands[0].result == [[marker_count > 0, marker_count > 0], "cancelled"]

{durable_workflow-2.5.0 → durable_workflow-2.5.2}/tests/test_replay_regression_corpus.py

@@ -24,6 +24,7 @@ from tests.test_golden_history_replay import (
     GoldenTimeoutWaitWorkflow,
     GoldenVersionMarkerWorkflow,
 )
+from tests.test_patch_history import PatchCancellationWorkflow, PatchInsertionWorkflow, RepeatedPatchWorkflow
 from tests.test_pending_operation_replay import PendingOperation
 from tests.test_update_signal_condition_replay import (
     PostConditionReceiversWorkflow,
@@ -250,7 +251,15 @@ class ChildPolicyAuthorWorkflow:
         return (yield ctx.start_child_workflow("child", []))
 
 
+class UnsupportedAsyncWorkflow:
+    __workflow_name__ = "tests.replay.unsupported-async"
+
+    async def run(self, ctx: WorkflowContext) -> str:
+        return "body was never executed"
+
+
 WORKFLOWS = [
+    UnsupportedAsyncWorkflow,
     ChildPolicyAuthorWorkflow,
     ColdReplacementSatisfiedConditionWorkflow,
     CooperativeReopenedConditionCleanupWorkflow,
@@ -266,6 +275,9 @@ WORKFLOWS = [
     NestedParallelPathWorkflow,
     ParallelMetadataProducerWorkflow,
     ParallelResultBindingWorkflow,
+    PatchCancellationWorkflow,
+    PatchInsertionWorkflow,
+    RepeatedPatchWorkflow,
     PendingOperation,
     PagedRecordedSideEffectsWorkflow,
     PostConditionReceiversWorkflow,

durable_workflow-2.5.2/tests/test_workflow_entrypoint_validation.py

@@ -0,0 +1,116 @@
+from __future__ import annotations
+
+from collections.abc import AsyncIterator, Generator
+from functools import partial, wraps
+from typing import Any
+
+import pytest
+
+from durable_workflow import Client, Worker, workflow
+from durable_workflow.testing import WorkflowEnvironment
+
+
+class CoroutineWorkflow:
+    async def run(self, ctx: Any) -> str:
+        return "never executed"
+
+
+class AsyncGeneratorWorkflow:
+    async def run(self, ctx: Any) -> AsyncIterator[str]:
+        yield "unsupported"
+
+
+class AsyncCallable:
+    async def __call__(self, ctx: Any) -> str:
+        return "unsupported"
+
+
+class CallableWorkflow:
+    run = AsyncCallable()
+
+
+class PartialWorkflow:
+    run = staticmethod(partial(CoroutineWorkflow.run, object()))
+
+
+ASYNC_DEFINITIONS = [CoroutineWorkflow, AsyncGeneratorWorkflow, CallableWorkflow, PartialWorkflow]
+
+
+@pytest.mark.parametrize("definition", ASYNC_DEFINITIONS)
+def test_definition_rejects_async_entrypoints(definition: type) -> None:
+    with pytest.raises(ValueError, match="unsupported_workflow_entrypoint.*synchronous"):
+        workflow.defn(name="invalid-async")(definition)
+
+
+@pytest.mark.parametrize("definition", ASYNC_DEFINITIONS)
+def test_worker_rejects_undecorated_async_entrypoints_before_network(definition: type) -> None:
+    with pytest.raises(ValueError, match=definition.__name__):
+        Worker(Client("http://127.0.0.1:1"), task_queue="unused", workflows=[definition])
+
+
+@pytest.mark.parametrize("definition", ASYNC_DEFINITIONS)
+def test_direct_replay_rejects_async_without_creating_a_coroutine(definition: type) -> None:
+    with pytest.raises(ValueError, match="unsupported_workflow_entrypoint"):
+        workflow.replay(definition, [], [])
+
+
+def test_test_environment_revalidates_entrypoint_after_decoration() -> None:
+    @workflow.defn(name="changed-entrypoint")
+    class ChangedWorkflow:
+        def run(self, ctx: Any) -> str:
+            return "valid"
+
+    ChangedWorkflow.run = CoroutineWorkflow.run  # type: ignore[assignment]
+    with pytest.raises(ValueError, match="changed-entrypoint"):
+        WorkflowEnvironment().register_workflow(ChangedWorkflow)
+
+
+def test_wrapped_and_inherited_async_entrypoints_are_rejected() -> None:
+    class InheritedWorkflow(CoroutineWorkflow):
+        pass
+
+    class WrappedWorkflow:
+        @wraps(CoroutineWorkflow.run)
+        def run(self, ctx: Any) -> Any:
+            return CoroutineWorkflow.run(self, ctx)
+
+    for definition in [InheritedWorkflow, WrappedWorkflow]:
+        with pytest.raises(ValueError, match="unsupported_workflow_entrypoint"):
+            workflow.replay(definition, [], [])
+
+
+@pytest.mark.parametrize("generator", [False, True])
+def test_runtime_awaitable_result_is_not_completed(generator: bool) -> None:
+    class AwaitableResultWorkflow:
+        def run(self, ctx: Any) -> Any:
+            return CoroutineWorkflow.run(self, ctx)
+
+    class GeneratorAwaitableResultWorkflow:
+        def run(self, ctx: Any) -> Generator[Any, Any, Any]:
+            if False:
+                yield None
+            return CoroutineWorkflow.run(self, ctx)
+
+    definition = GeneratorAwaitableResultWorkflow if generator else AwaitableResultWorkflow
+    with pytest.raises(ValueError, match="unsupported_workflow_result"):
+        workflow.replay(definition, [], [])
+
+
+def test_synchronous_and_generator_workflows_remain_supported() -> None:
+    @workflow.defn(name="valid-sync")
+    class SynchronousWorkflow:
+        def run(self, ctx: Any) -> str:
+            return "done"
+
+    @workflow.defn(name="valid-generator")
+    class GeneratorWorkflow:
+        def run(self, ctx: Any) -> Generator[Any, Any, str]:
+            if False:
+                yield None
+            return "done"
+
+    Worker(Client("http://127.0.0.1:1"), task_queue="unused", workflows=[SynchronousWorkflow, GeneratorWorkflow])
+    environment = WorkflowEnvironment()
+    for definition in [SynchronousWorkflow, GeneratorWorkflow]:
+        assert environment.execute_workflow(definition) == "done"
+        assert workflow.replay(definition, [], []).commands[0].result == "done"  # type: ignore[union-attr]