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

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

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

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "durable-workflow"
-version = "2.4.2"
+version = "2.5.0"
 description = "Python client and worker SDK for Durable Workflow Cloud and self-hosted Server"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -71,8 +71,8 @@ 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.4.2"
-registry-version = "2.4.2"
+product-train = "2.5.0"
+registry-version = "2.5.0"
 supported-server-versions = "2.5.0"
 worker-protocol-version = "1.19"
 control-plane-version = "2"

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

@@ -95,6 +95,7 @@ from .errors import (
     ServerError,
     SignalFailed,
     Unauthorized,
+    UpdateFailed,
     UpdateRejected,
     UpdateValidationFailed,
     WorkflowAlreadyStarted,
@@ -385,6 +386,7 @@ __all__ = [
     "SignalFailed",
     "TransportRetryPolicy",
     "Unauthorized",
+    "UpdateFailed",
     "UpdateRejected",
     "UpdateValidationFailed",
     "WorkflowAlreadyStarted",

durable_workflow-2.5.0/src/durable_workflow/_sticky_workflow_cache.py

@@ -0,0 +1,103 @@
+"""Bounded snapshots of durable wire history, never live workflow instances."""
+
+from __future__ import annotations
+
+import json
+import time
+from collections import OrderedDict
+from dataclasses import dataclass
+from typing import Any
+
+CacheKey = tuple[str, str, str]
+
+
+def complete_history(history: list[dict[str, Any]]) -> bool:
+    if not history or any(not isinstance(event, dict) for event in history):
+        return False
+    types = [event.get("event_type") for event in history[:2]]
+    if types[0] != "WorkflowStarted" and types != ["StartAccepted", "WorkflowStarted"]:
+        return False
+    return all(type(event.get("sequence")) is int and event["sequence"] == index
+               for index, event in enumerate(history, 1))
+
+
+@dataclass(frozen=True)
+class _Entry:
+    encoded: bytes
+    expires_at: float
+    resume_token: str | None
+    resume_offset: int
+
+
+class StickyWorkflowCache:
+    def __init__(self, capacity: int, max_bytes: int, ttl_seconds: int) -> None:
+        for name, value, minimum in (("capacity", capacity, 0), ("max_bytes", max_bytes, 1),
+                                     ("ttl_seconds", ttl_seconds, 1)):
+            if type(value) is not int or value < minimum:
+                raise ValueError(f"sticky_cache_{name} must be an integer of at least {minimum}")
+        if ttl_seconds > 3600:
+            raise ValueError("sticky_cache_ttl_seconds must be at most 3600")
+        self.capacity = capacity
+        self.max_bytes = max_bytes
+        self.ttl_seconds = ttl_seconds
+        self._entries: OrderedDict[CacheKey, _Entry] = OrderedDict()
+        self._bytes = 0
+        self._metrics = {"hit": 0, "miss": 0, "eviction": 0, "forced_cold_replay": 0}
+
+    @property
+    def enabled(self) -> bool:
+        return self.capacity > 0
+
+    def _expire(self) -> None:
+        now = time.monotonic()
+        for key, entry in list(self._entries.items()):
+            if entry.expires_at <= now:
+                self.discard(key)
+
+    def discard(self, key: CacheKey) -> None:
+        entry = self._entries.pop(key, None)
+        if entry is not None:
+            self._bytes -= len(entry.encoded)
+
+    def lookup(self, key: CacheKey) -> tuple[list[dict[str, Any]], str | None, int] | None:
+        self._expire()
+        entry = self._entries.get(key)
+        if entry is None:
+            return None
+        self._entries.move_to_end(key)
+        # Decoding isolates the retained snapshot from replay and handler mutation.
+        history: list[dict[str, Any]] = json.loads(entry.encoded)
+        return history, entry.resume_token, entry.resume_offset
+
+    def remember(self, key: CacheKey, history: list[dict[str, Any]], *,
+                 resume_token: str | None = None, resume_offset: int = 0) -> bool:
+        self._expire()
+        self.discard(key)
+        if not self.enabled or not complete_history(history):
+            return False
+        try:
+            encoded = json.dumps(history, ensure_ascii=False, separators=(",", ":"), allow_nan=False).encode("utf-8")
+        except (TypeError, ValueError):
+            return False
+        if len(encoded) > self.max_bytes:
+            return False
+        while self._entries and (len(self._entries) >= self.capacity or self._bytes + len(encoded) > self.max_bytes):
+            oldest = next(iter(self._entries))
+            self.discard(oldest)
+            self._metrics["eviction"] += 1
+        self._entries[key] = _Entry(encoded, time.monotonic() + self.ttl_seconds, resume_token, resume_offset)
+        self._bytes += len(encoded)
+        return True
+
+    def record_replay(self, *, hit: bool, forced: bool = False) -> None:
+        self._metrics["hit" if hit else "miss"] += 1
+        if forced:
+            self._metrics["forced_cold_replay"] += 1
+
+    def metrics(self) -> dict[str, int]:
+        self._expire()
+        return {**self._metrics, "entries": len(self._entries), "history_bytes": self._bytes}
+
+    def clear(self) -> None:
+        self._entries.clear()
+        self._bytes = 0

{durable_workflow-2.4.2 → durable_workflow-2.5.0}/src/durable_workflow/client.py

@@ -87,7 +87,7 @@ PORTABLE_WORKER_AFFINITY_CAPABILITY_MANIFEST: dict[str, dict[str, str | bool]] =
     "sticky_execution": {
         "supported": False,
         "minimum_protocol_version": "1.18",
-        "reason": "python_worker_uses_complete_durable_history_replay",
+        "reason": "sticky_cache_disabled",
     },
 }
 _MESSAGE_STREAMS_CAPABILITY = "message_streams"
@@ -4349,7 +4349,9 @@ class Client:
         :class:`~durable_workflow.errors.UpdateRejected` when the workflow's
         validator rejects the update, or
         :class:`~durable_workflow.errors.UpdateValidationFailed` when the
-        declared validation boundary cannot be enforced.
+        declared validation boundary cannot be enforced. An accepted update
+        whose handler fails raises :class:`~durable_workflow.errors.UpdateFailed`
+        with the failure message, Server response and durable identities.
         """
         await self._require_update_wait_stage(wait_for or "accepted")
         body: dict[str, Any] = {}
@@ -5110,6 +5112,7 @@ class Client:
         commands: list[dict[str, Any]],
         message_stream_cursors: list[dict[str, Any]] | None = None,
         message_stream_waits: list[dict[str, Any]] | None = None,
+        sticky_cache: dict[str, Any] | None = None,
     ) -> Any:
         """Report successful execution of a workflow task with its emitted commands.
 
@@ -5141,6 +5144,8 @@ class Client:
             body["message_stream_cursors"] = message_stream_cursors
         if message_stream_waits:
             body["message_stream_waits"] = message_stream_waits
+        if sticky_cache is not None:
+            body["sticky_cache"] = sticky_cache
         return await self._request(
             "POST", f"/worker/workflow-tasks/{task_id}/complete", worker=True, json=body
         )

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

@@ -453,6 +453,29 @@ class NonDeterministicReplayError(DurableWorkflowError):
         self.recorded_event_types = list(recorded_event_types)
 
 
+class UpdateFailed(InvalidArgument):
+    """An accepted workflow update failed during handler execution.
+
+    ``body`` preserves the Server response, including its durable failure
+    identity. This inherits from :class:`InvalidArgument` to preserve catches
+    written for earlier SDK versions that mapped all HTTP 422 responses there.
+    """
+
+    def __init__(self, message: str, *, status: int, body: dict[str, Any]) -> None:
+        super().__init__(message)
+        self.status = status
+        self.body = body
+        self.workflow_id = self._identity(body, "workflow_id")
+        self.run_id = self._identity(body, "run_id")
+        self.update_id = self._identity(body, "update_id")
+        self.failure_id = self._identity(body, "failure_id")
+
+    @staticmethod
+    def _identity(body: dict[str, Any], name: str) -> str | None:
+        value = body.get(name)
+        return value if isinstance(value, str) and value.strip() else None
+
+
 class UpdateRejected(DurableWorkflowError):
     """A workflow update was rejected by the workflow's validator."""
 
@@ -859,6 +882,13 @@ def _raise_for_status(status: int, body: object, *, context: str = "") -> None:
             raise signal_failed("signal argument validation failed")
         if reason == "invalid_query_arguments":
             raise query_failed("query argument validation failed")
+        if isinstance(body, dict) and body.get("update_status") == "failed":
+            failure_message = body.get("failure_message")
+            if not isinstance(failure_message, str) or not failure_message.strip():
+                failure_message = message
+            if not isinstance(failure_message, str) or not failure_message.strip():
+                failure_message = "workflow update failed"
+            raise UpdateFailed(failure_message, status=status, body=body)
         errors = None
         if isinstance(body, dict):
             errors = body.get("errors") or body.get("validation_errors")

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

@@ -41,6 +41,7 @@ from ._activity_process import CallbackFailure, CallbackInvocation, CallbackProc
 from ._cancellation_scope_history import CancellationScopeBudget, CancellationScopeDeliveryReceipt
 from ._cooperative_cancellation import CancellationRequest, read_cancellation_history
 from ._prepared_local_activity import PreparedAttempt, PreparedCancellationObserved, PreparedLocalRunner
+from ._sticky_workflow_cache import CacheKey, StickyWorkflowCache, complete_history
 from .activity import ActivityContext, ActivityInfo, _set_context
 from .auth_composition import (
     AUTH_COMPOSITION_CONTRACT_SCHEMA,
@@ -53,6 +54,7 @@ from .client import (
     CONTROL_PLANE_REQUEST_CONTRACT_SCHEMA,
     CONTROL_PLANE_REQUEST_CONTRACT_VERSION,
     CONTROL_PLANE_VERSION,
+    DEFAULT_SDK_VERSION,
     PORTABLE_WORKER_AFFINITY_CAPABILITY_MANIFEST,
     PROTOCOL_VERSION,
     Client,
@@ -1008,6 +1010,9 @@ class Worker:
         max_concurrent_workflow_tasks: int = 10,
         max_concurrent_activity_tasks: int = 10,
         max_concurrent_worker_sessions: int = 10,
+        sticky_cache_capacity: int = 0,
+        sticky_cache_max_bytes: int = 16 * 1024 * 1024,
+        sticky_cache_ttl_seconds: int = 300,
         shutdown_timeout: float = 30.0,
         heartbeat_interval: float = 60.0,
         metrics: MetricsRecorder | None = None,
@@ -1029,6 +1034,11 @@ class Worker:
         }
         self.activities = {_activity_name(a): a for a in activities}
         self.capabilities = tuple(dict.fromkeys(capability.strip() for capability in capabilities))
+        self._sticky_cache = StickyWorkflowCache(
+            sticky_cache_capacity, sticky_cache_max_bytes, sticky_cache_ttl_seconds,
+        )
+        if "sticky_execution" in self.capabilities and not self._sticky_cache.enabled:
+            raise ValueError("sticky_execution requires a positive sticky_cache_capacity")
         self._cooperative_cancellation_supported = False
         self._prepared_local_activities_supported = False
         self._prepared_local_activity_groups_supported = False
@@ -1211,6 +1221,13 @@ class Worker:
         _validate_server_compatibility(info)
         protocol = info.get("worker_protocol")
         server_capabilities = protocol.get("server_capabilities") if isinstance(protocol, Mapping) else None
+        sticky_support = (
+            server_capabilities.get("sticky_execution") if isinstance(server_capabilities, Mapping) else None
+        )
+        if self._sticky_cache.enabled and (
+            not isinstance(sticky_support, Mapping) or sticky_support.get("supported") is not True
+        ):
+            raise RuntimeError("sticky execution requires Server's advertised sticky_execution support")
         self._cooperative_cancellation_supported = (
             "cooperative_cancellation" in self.capabilities
             and isinstance(protocol, Mapping)
@@ -1292,6 +1309,15 @@ class Worker:
             capabilities.append("prepared_local_activity_cancellation_policies")
         if PORTABLE_WORKER_AFFINITY_CAPABILITY_MANIFEST["worker_sessions"]["supported"]:
             capabilities.append("worker_sessions")
+        affinity_manifest = {name: dict(entry) for name, entry in PORTABLE_WORKER_AFFINITY_CAPABILITY_MANIFEST.items()}
+        if self._sticky_cache.enabled:
+            if "sticky_execution" not in capabilities:
+                capabilities.append("sticky_execution")
+            affinity_manifest["sticky_execution"] = {
+                "supported": True,
+                "minimum_protocol_version": "1.18",
+                "implementation": "bounded_durable_history_cache",
+            }
 
         ack = await self.client.register_worker(
             worker_id=self.worker_id,
@@ -1306,7 +1332,7 @@ class Worker:
             build_id=self.build_id,
             capabilities=capabilities,
             capability_manifest={
-                **PORTABLE_WORKER_AFFINITY_CAPABILITY_MANIFEST,
+                **affinity_manifest,
                 **({"prepared_local_activities": {
                     "supported": True, "minimum_protocol_version": "1.20",
                     "implementation": "durable_sequential_admission",
@@ -1514,8 +1540,65 @@ class Worker:
     async def _load_workflow_claim_history(
         self, task: dict[str, Any], *, first_page_token: str | None = None,
     ) -> list[dict[str, Any]]:
-        history = [] if first_page_token is not None else list(task.get("history_events", []))
-        token = first_page_token if first_page_token is not None else task.get("next_history_page_token")
+        if first_page_token is not None:
+            return await self._fetch_workflow_claim_history_pages(task, [], first_page_token)
+        inline = list(task.get("history_events", []))
+        key = self._sticky_cache_key(task)
+        mode = task.get("sticky_replay_mode")
+        cached = self._sticky_cache.lookup(key) if key is not None and mode == "sticky_hit_expected" else None
+        if cached is not None and key is not None:
+            prefix, resume_token, resume_offset = cached
+            overlap = min(len(inline), len(prefix))
+            # Published Server responses also express the boundary as an event count.
+            # Retained histories are contiguous from sequence 1, so the two agree.
+            raw_last_sequence = task.get("last_history_sequence", task.get("total_history_events"))
+            last_sequence = raw_last_sequence if isinstance(raw_last_sequence, int) else -1
+            anchored = (
+                complete_history(inline) and inline[:overlap] == prefix[:overlap]
+                and type(raw_last_sequence) is int and last_sequence >= len(prefix)
+            )
+            if anchored:
+                if resume_token is not None and resume_offset >= len(inline) and len(inline) < len(prefix):
+                    try:
+                        tail = await self._fetch_workflow_claim_history_pages(task, [], resume_token)
+                    except (InvalidArgument, LocalActivityExecutionAborted):
+                        tail = []
+                    except ServerError as error:
+                        if error.status != 400 or error.reason() != "invalid_page_token":
+                            raise
+                        tail = []
+                    if tail[:len(prefix) - resume_offset] == prefix[resume_offset:]:
+                        history = prefix[:resume_offset] + tail
+                        if complete_history(history) and len(history) >= last_sequence:
+                            # Paging measured the offset within the tail; retain its absolute boundary.
+                            task["_sticky_resume_offset"] += resume_offset
+                            self._sticky_cache.record_replay(hit=True)
+                            return history
+                else:
+                    history = await self._fetch_workflow_claim_history_pages(
+                        task, inline, task.get("next_history_page_token"),
+                    )
+                    if complete_history(history) and history[:len(prefix)] == prefix and len(history) >= last_sequence:
+                        self._sticky_cache.record_replay(hit=True)
+                        return history
+            # A cached prefix must never replace an inconsistent authoritative page.
+            self._sticky_cache.discard(key)
+        if key is not None:
+            self._sticky_cache.record_replay(
+                hit=False, forced=mode in {"sticky_hit_expected", "forced_cold_replay"},
+            )
+        if mode in {"sticky_hit_expected", "forced_cold_replay"} and not complete_history(inline):
+            history = await self._fetch_workflow_claim_history_pages(task, [], "MA==")
+            if not complete_history(history):
+                raise LocalActivityExecutionAborted("cold replay lacks a complete canonical history prefix")
+            return history
+        return await self._fetch_workflow_claim_history_pages(task, inline, task.get("next_history_page_token"))
+
+    async def _fetch_workflow_claim_history_pages(
+        self, task: dict[str, Any], history: list[dict[str, Any]], token: Any,
+    ) -> list[dict[str, Any]]:
+        task["_sticky_resume_token"] = None
+        task["_sticky_resume_offset"] = 0
         seen: set[str] = set()
         while token is not None:
             if not isinstance(token, str) or not token or token in seen:
@@ -1529,10 +1612,46 @@ class Worker:
                 raise LocalActivityExecutionAborted("workflow history page was not acknowledged")
             if any(not isinstance(event, dict) for event in page["history_events"]):
                 raise LocalActivityExecutionAborted("workflow history page contains a malformed event")
+            task["_sticky_resume_token"] = token
+            task["_sticky_resume_offset"] = len(history)
             history.extend(page["history_events"])
             token = page.get("next_history_page_token")
         return history
 
+    def _sticky_cache_key(self, task: dict[str, Any]) -> CacheKey | None:
+        if not self._sticky_cache.enabled:
+            return None
+        workflow_id, run_id = task.get("workflow_id"), task.get("run_id")
+        if not isinstance(workflow_id, str) or not workflow_id or not isinstance(run_id, str) or not run_id:
+            return None
+        return workflow_id, run_id, self.build_id.strip() if self.build_id is not None else DEFAULT_SDK_VERSION
+
+    def _sticky_cache_claim(
+        self, task: dict[str, Any], history: list[dict[str, Any]], commands: list[dict[str, Any]],
+    ) -> dict[str, Any] | None:
+        key = self._sticky_cache_key(task)
+        if key is None:
+            return None
+        if any(command.get("type") in {"complete_workflow", "fail_workflow", "continue_as_new"}
+               for command in commands):
+            self._sticky_cache.discard(key)
+            return None
+        if not self._sticky_cache.remember(
+            key, history, resume_token=task.get("_sticky_resume_token"),
+            resume_offset=task.get("_sticky_resume_offset", 0),
+        ):
+            return None
+        return {
+            "worker_id": self.worker_id, "workflow_id": key[0], "run_id": key[1], "build_id": key[2],
+            "ttl_seconds": self._sticky_cache.ttl_seconds,
+            "metrics": {name: self._sticky_cache.metrics()[name]
+                        for name in ("hit", "miss", "eviction", "forced_cold_replay")},
+        }
+
+    def sticky_cache_metrics(self) -> dict[str, int]:
+        """Return replay counters, retained entries and encoded history bytes."""
+        return self._sticky_cache.metrics()
+
     async def _refresh_cancellation_history(
         self, task: dict[str, Any], observed: CancellationRequest,
     ) -> list[dict[str, Any]]:
@@ -2416,6 +2535,7 @@ class Worker:
                     task_id=task_id,
                     attempt=attempt,
                     commands=[command],
+                    sticky_cache=self._sticky_cache_claim(task, history, [command]),
                 )
             except Exception as e:
                 log.warning("failed to complete workflow update task %s: %s", task_id, e)
@@ -2622,6 +2742,7 @@ class Worker:
                 commands=commands,
                 message_stream_cursors=outcome.message_stream_cursors,
                 message_stream_waits=outcome.message_stream_waits,
+                sticky_cache=self._sticky_cache_claim(task, history, commands),
             )
         except Exception as e:
             log.warning("failed to complete workflow task %s: %s", task_id, e)
@@ -2640,9 +2761,11 @@ class Worker:
         commands: list[dict[str, Any]],
         message_stream_cursors: list[dict[str, Any]] | None = None,
         message_stream_waits: list[dict[str, Any]] | None = None,
+        sticky_cache: dict[str, Any] | None = None,
     ) -> None:
         for completion_attempt in range(1, _WORKFLOW_TASK_COMPLETION_MAX_ATTEMPTS + 1):
             try:
+                completion_kwargs = {"sticky_cache": sticky_cache} if sticky_cache is not None else {}
                 await self.client.complete_workflow_task(
                     task_id=task_id,
                     lease_owner=self.worker_id,
@@ -2650,6 +2773,7 @@ class Worker:
                     commands=commands,
                     message_stream_cursors=message_stream_cursors,
                     message_stream_waits=message_stream_waits,
+                    **completion_kwargs,
                 )
                 return
             except Exception as error:
@@ -4353,6 +4477,7 @@ class Worker:
             await self.client.deregister_worker_registration(self.worker_id)
             self._registered = False
             log.info("worker %s deregistered", self.worker_id)
+        self._sticky_cache.clear()
 
     @staticmethod
     def _remaining_shutdown_time(deadline: float) -> float:

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

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

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

@@ -8,6 +8,7 @@ src/durable_workflow/_cancellation_scope.py
 src/durable_workflow/_cancellation_scope_history.py
 src/durable_workflow/_cooperative_cancellation.py
 src/durable_workflow/_prepared_local_activity.py
+src/durable_workflow/_sticky_workflow_cache.py
 src/durable_workflow/activity.py
 src/durable_workflow/auth_composition.py
 src/durable_workflow/cancellation.py
@@ -106,6 +107,7 @@ tests/test_serializer.py
 tests/test_signals.py
 tests/test_sleep.py
 tests/test_standalone_activity_client.py
+tests/test_sticky_execution.py
 tests/test_storage_admission.py
 tests/test_sync.py
 tests/test_testing_harness.py

{durable_workflow-2.4.2 → durable_workflow-2.5.0}/tests/test_client.py

@@ -30,6 +30,7 @@ from durable_workflow.errors import (
     ServerError,
     SignalFailed,
     Unauthorized,
+    UpdateFailed,
     UpdateRejected,
     WorkflowAlreadyStarted,
     WorkflowNotFound,
@@ -3090,6 +3091,34 @@ class TestHeartbeatActivityTask:
 
 
 class TestUpdateWorkflow:
+    @pytest.mark.asyncio
+    async def test_failed_update_retries_preserve_failure_identity(self, client: Client) -> None:
+        body = {
+            "update_status": "failed", "accepted": True,
+            "failure_message": "inventory unavailable", "workflow_id": "wf-1",
+            "run_id": "run-1", "update_id": "update-1", "failure_id": "failure-1",
+        }
+        with patch.object(
+            client._http, "request", new_callable=AsyncMock, return_value=_mock_response(422, body),
+        ) as request:
+            failures = []
+            for _ in range(2):
+                with pytest.raises(UpdateFailed) as exc_info:
+                    await client.update_workflow(
+                        "wf-1", "reserve", wait_for="completed", request_id="request-1",
+                    )
+                failures.append(exc_info.value)
+            assert request.await_count == 2
+            assert all(call.kwargs["json"]["request_id"] == "request-1"
+                       for call in request.await_args_list)
+        for error in failures:
+            assert str(error) == "inventory unavailable"
+            assert error.status == 422
+            assert error.body == body
+            assert (error.workflow_id, error.run_id, error.update_id, error.failure_id) == (
+                "wf-1", "run-1", "update-1", "failure-1",
+            )
+
     @pytest.mark.asyncio
     async def test_unsupported_wait_stage_raises_typed_error_before_update(self) -> None:
         client = Client("http://localhost:8080", token="test-token")

{durable_workflow-2.4.2 → durable_workflow-2.5.0}/tests/test_errors.py

@@ -13,6 +13,7 @@ from durable_workflow.errors import (
     ServerError,
     SignalFailed,
     Unauthorized,
+    UpdateFailed,
     UpdateRejected,
     UpdateValidationFailed,
     WorkflowAlreadyStarted,
@@ -102,6 +103,56 @@ class TestRaiseForStatus:
         with pytest.raises(InvalidArgument) as exc_info:
             _raise_for_status(422, {"message": "bad", "errors": {"f": ["req"]}})
         assert exc_info.value.errors == {"f": ["req"]}
+        assert type(exc_info.value) is InvalidArgument
+
+    def test_422_accepted_update_failure_preserves_diagnostics_and_legacy_catch(self) -> None:
+        body = {
+            "update_status": "failed", "accepted": True,
+            "failure_message": "inventory unavailable", "message": "generic failure",
+            "workflow_id": "wf-1", "run_id": "run-1", "update_id": "update-1",
+            "failure_id": "failure-1",
+        }
+        with pytest.raises(InvalidArgument) as exc_info:
+            _raise_for_status(422, body)
+        error = exc_info.value
+        assert isinstance(error, UpdateFailed)
+        assert str(error) == "inventory unavailable"
+        assert error.status == 422
+        assert error.body is body
+        assert error.errors is None
+        assert (error.workflow_id, error.run_id, error.update_id, error.failure_id) == (
+            "wf-1", "run-1", "update-1", "failure-1",
+        )
+
+    @pytest.mark.parametrize("failure_message", [None, "", "  ", 42])
+    @pytest.mark.parametrize("message", ["handler failed", None, "", "  ", 42])
+    def test_update_failure_message_fallback(self, failure_message: object, message: object) -> None:
+        with pytest.raises(UpdateFailed) as exc_info:
+            _raise_for_status(422, {
+                "update_status": "failed", "failure_message": failure_message, "message": message,
+            })
+        assert str(exc_info.value) == (
+            message if message == "handler failed" else "workflow update failed"
+        )
+
+    def test_update_failure_missing_or_malformed_identities_remain_absent(self) -> None:
+        with pytest.raises(UpdateFailed) as exc_info:
+            _raise_for_status(422, {
+                "update_status": "failed", "workflow_id": 42, "run_id": " ", "update_id": None,
+            })
+        error = exc_info.value
+        assert (error.workflow_id, error.run_id, error.update_id, error.failure_id) == (
+            None, None, None, None,
+        )
+
+    def test_rejected_update_arguments_are_not_handler_failure(self) -> None:
+        with pytest.raises(InvalidArgument) as exc_info:
+            _raise_for_status(422, {
+                "update_status": "rejected", "message": "invalid arguments",
+                "validation_errors": {"quantity": ["must be positive"]},
+            })
+        assert type(exc_info.value) is InvalidArgument
+        assert exc_info.value.errors == {"quantity": ["must be positive"]}
 
     def test_422_update_validator_rejected_is_typed(self) -> None:
         with pytest.raises(UpdateRejected) as exc_info:
@@ -109,6 +160,7 @@ class TestRaiseForStatus:
                 422,
                 {
                     "reason": "update_validator_rejected",
+                    "update_status": "failed",
                     "message": "approval required",
                     "validation_errors": {"approved": ["must be true"]},
                 },
@@ -132,6 +184,7 @@ class TestRaiseForStatus:
                 status,
                 {
                     "reason": reason,
+                    "update_status": "failed",
                     "message": "validation could not complete",
                     "retryable": retryable,
                 },

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

@@ -489,6 +489,27 @@ async def test_worker_replays_recorded_side_effects_across_history_pages() -> No
     assert serializer.decode_envelope(commands[0]["result"]) == 198
 
 
+@pytest.mark.asyncio
+async def test_replacement_with_sticky_suffix_fetches_cold_history_before_replay() -> None:
+    fixture = json.loads((FIXTURE_DIR / "sticky-cold-prefix-side-effects-avro.json").read_text(encoding="utf-8"))
+    history = fixture["history"]
+    client = AsyncMock(spec=Client)
+    client.workflow_task_history.return_value = {"history_events": history, "next_history_page_token": None}
+    worker = Worker(client, task_queue="cold-sticky", workflows=[PagedRecordedSideEffectsWorkflow])
+    commands = await worker._run_workflow_task_core({
+        "task_id": "replacement-task", "workflow_id": "cold-sticky", "run_id": "original-run",
+        "workflow_type": fixture["workflow"]["type"], "workflow_task_attempt": 2,
+        "history_events": history[-1:], "sticky_replay_mode": "sticky_hit_expected",
+        "arguments": serializer.encode([], codec="avro"), "payload_codec": "avro",
+    })
+    client.workflow_task_history.assert_awaited_once_with(
+        task_id="replacement-task", next_history_page_token="MA==", lease_owner=worker.worker_id,
+        workflow_task_attempt=2,
+    )
+    assert commands is not None
+    assert serializer.decode_envelope(commands[0]["result"]) == 198
+
+
 @pytest.mark.parametrize(
     "fixture",
     [