durable-workflow 2.5.6__tar.gz → 2.5.8__tar.gz

{durable_workflow-2.5.6/src/durable_workflow.egg-info → durable_workflow-2.5.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: durable-workflow
-Version: 2.5.6
+Version: 2.5.8
 Summary: Python client and worker SDK for Durable Workflow Cloud and self-hosted Server
 Author: Durable Workflow Contributors
 License-Expression: MIT
@@ -155,12 +155,15 @@ capabilities with Server at startup. Use stable `2.x` SDK and Server channels
 for new applications. The [compatibility guide](https://durable-workflow.com/docs/2.0/compatibility/)
 documents protocol and upgrade guarantees.
 
-## Cooperative cancellation release candidate
+## Worker protocol and cooperative cancellation
+
+Workers use protocol 1.20 by default. For a Server that supports only 1.19, set
+`DURABLE_WORKFLOW_WORKER_PROTOCOL_VERSION=1.19`. This changes the request protocol
+without enabling optional worker features.
 
 Use `request_cancellation()` for bounded, replayable workflow cleanup. Opt in
 against a Server that advertises protocol 1.20 and the required capabilities:
-set `DURABLE_WORKFLOW_WORKER_PROTOCOL_VERSION=1.20` and include
-`cooperative_cancellation` in the Worker's `capabilities`. Durable local callback
+include `cooperative_cancellation` in the Worker's `capabilities`. Durable local callback
 admission also needs `prepared_local_activities`, with
 `prepared_local_activity_cancellation_policies` for explicit local policies.
 Independently cancellable scopes remain disabled.
@@ -196,11 +199,10 @@ to true. CI verifies that checkout, builds the candidate Server, enables protoco
 authority and exact source provenance. An optional exact `native_commit` mounts
 that public Native checkout read-only into the test stack. The image's published
 Composer authority stays intact and the evidence identifies the source overlay.
-These are source qualification runs. For a local
-candidate, set `DURABLE_WORKFLOW_WORKER_PROTOCOL_VERSION=1.20` before starting
-Compose and `DURABLE_WORKFLOW_COOPERATIVE_QUALIFICATION=1` for pytest. These cases
-fail if the runtime does not discover the required capability. Ordinary CI
-keeps protocol 1.19 and skips this unpublished feature's connected cases.
+These are source qualification runs. For a local candidate, set
+`DURABLE_WORKFLOW_COOPERATIVE_QUALIFICATION=1` for pytest. These cases fail if the
+runtime does not discover the required capability. Ordinary CI uses the SDK's
+default protocol and skips the optional connected cooperative cases.
 
 ## License
 

{durable_workflow-2.5.6 → durable_workflow-2.5.8}/README.md

@@ -115,12 +115,15 @@ capabilities with Server at startup. Use stable `2.x` SDK and Server channels
 for new applications. The [compatibility guide](https://durable-workflow.com/docs/2.0/compatibility/)
 documents protocol and upgrade guarantees.
 
-## Cooperative cancellation release candidate
+## Worker protocol and cooperative cancellation
+
+Workers use protocol 1.20 by default. For a Server that supports only 1.19, set
+`DURABLE_WORKFLOW_WORKER_PROTOCOL_VERSION=1.19`. This changes the request protocol
+without enabling optional worker features.
 
 Use `request_cancellation()` for bounded, replayable workflow cleanup. Opt in
 against a Server that advertises protocol 1.20 and the required capabilities:
-set `DURABLE_WORKFLOW_WORKER_PROTOCOL_VERSION=1.20` and include
-`cooperative_cancellation` in the Worker's `capabilities`. Durable local callback
+include `cooperative_cancellation` in the Worker's `capabilities`. Durable local callback
 admission also needs `prepared_local_activities`, with
 `prepared_local_activity_cancellation_policies` for explicit local policies.
 Independently cancellable scopes remain disabled.
@@ -156,11 +159,10 @@ to true. CI verifies that checkout, builds the candidate Server, enables protoco
 authority and exact source provenance. An optional exact `native_commit` mounts
 that public Native checkout read-only into the test stack. The image's published
 Composer authority stays intact and the evidence identifies the source overlay.
-These are source qualification runs. For a local
-candidate, set `DURABLE_WORKFLOW_WORKER_PROTOCOL_VERSION=1.20` before starting
-Compose and `DURABLE_WORKFLOW_COOPERATIVE_QUALIFICATION=1` for pytest. These cases
-fail if the runtime does not discover the required capability. Ordinary CI
-keeps protocol 1.19 and skips this unpublished feature's connected cases.
+These are source qualification runs. For a local candidate, set
+`DURABLE_WORKFLOW_COOPERATIVE_QUALIFICATION=1` for pytest. These cases fail if the
+runtime does not discover the required capability. Ordinary CI uses the SDK's
+default protocol and skips the optional connected cooperative cases.
 
 ## License
 

{durable_workflow-2.5.6 → durable_workflow-2.5.8}/pyproject.toml

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

{durable_workflow-2.5.6 → durable_workflow-2.5.8}/src/durable_workflow/client.py

@@ -72,7 +72,8 @@ from .nexus import NexusOperationResult, nexus_request_payload
 from .retry_policy import TransportRetryPolicy
 from .worker_session import WorkerSessionOptions
 
-PROTOCOL_VERSION = "1.19"
+PROTOCOL_VERSION = "1.20"
+MINIMUM_WORKER_PROTOCOL_VERSION = "1.19"
 CONTROL_PLANE_VERSION = "2"
 PORTABLE_WORKER_AFFINITY_CAPABILITY_MANIFEST: dict[str, dict[str, str | bool]] = {
     "local_activities": {

{durable_workflow-2.5.6 → durable_workflow-2.5.8}/src/durable_workflow/worker.py

@@ -55,6 +55,7 @@ from .client import (
     CONTROL_PLANE_REQUEST_CONTRACT_VERSION,
     CONTROL_PLANE_VERSION,
     DEFAULT_SDK_VERSION,
+    MINIMUM_WORKER_PROTOCOL_VERSION,
     PORTABLE_WORKER_AFFINITY_CAPABILITY_MANIFEST,
     PROTOCOL_VERSION,
     Client,
@@ -877,6 +878,16 @@ def _server_protocol_compatible(server_version: str, sdk_version: str) -> bool:
 
 
 def _validate_server_compatibility(info: dict[str, Any]) -> None:
+    requested_protocol = _protocol_version_from_env(
+        "DURABLE_WORKFLOW_WORKER_PROTOCOL_VERSION", PROTOCOL_VERSION,
+    )
+    if requested_protocol not in (MINIMUM_WORKER_PROTOCOL_VERSION, PROTOCOL_VERSION):
+        raise RuntimeError(
+            "Server compatibility error: sdk-python supports worker protocol "
+            f"{MINIMUM_WORKER_PROTOCOL_VERSION} or protocol {PROTOCOL_VERSION}; "
+            f"requested {requested_protocol!r}."
+        )
+
     control_plane = info.get("control_plane")
     if not isinstance(control_plane, dict):
         raise RuntimeError(
@@ -914,15 +925,15 @@ def _validate_server_compatibility(info: dict[str, Any]) -> None:
     if not isinstance(worker_protocol, dict):
         raise RuntimeError(
             "Server compatibility error: missing worker_protocol manifest; "
-            f"sdk-python requires worker_protocol.version {PROTOCOL_VERSION}."
+            f"sdk-python requires worker_protocol.version {requested_protocol}."
         )
 
     worker_protocol_version = _manifest_version(worker_protocol)
-    if not _server_protocol_compatible(worker_protocol_version, PROTOCOL_VERSION):
+    if not _server_protocol_compatible(worker_protocol_version, requested_protocol):
         raise RuntimeError(
             "Server compatibility error: incompatible worker_protocol.version "
             f"{worker_protocol_version!r}; sdk-python requires major-equal and "
-            f"minor>={PROTOCOL_VERSION!r}."
+            f"minor>={requested_protocol!r}."
         )
 
     auth_composition = info.get("auth_composition_contract")
@@ -4233,6 +4244,7 @@ class Worker:
         """
         background_tasks: list[asyncio.Task[Any]] = []
         deadline = asyncio.get_running_loop().time() + timeout
+        startup_completed = False
 
         self._begin_run()
         try:
@@ -4241,6 +4253,7 @@ class Worker:
             finally:
                 self._registration_done.set()
 
+            startup_completed = True
             if self._stop.is_set():
                 raise asyncio.CancelledError
             background_tasks.append(asyncio.create_task(self._heartbeat_loop()))
@@ -4262,6 +4275,11 @@ class Worker:
                 run_until_loop, timeout=max(0.0, deadline - asyncio.get_running_loop().time()),
             )
         except asyncio.TimeoutError as error:
+            if not startup_completed:
+                raise TimeoutError(
+                    f"worker {self.worker_id} startup did not finish within the "
+                    f"{timeout}s workflow wait budget for {workflow_id}"
+                ) from error
             raise TimeoutError(f"workflow {workflow_id} not terminal after {timeout}s") from error
         finally:
             primary_error = sys.exc_info()[1]

{durable_workflow-2.5.6 → durable_workflow-2.5.8/src/durable_workflow.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: durable-workflow
-Version: 2.5.6
+Version: 2.5.8
 Summary: Python client and worker SDK for Durable Workflow Cloud and self-hosted Server
 Author: Durable Workflow Contributors
 License-Expression: MIT
@@ -155,12 +155,15 @@ capabilities with Server at startup. Use stable `2.x` SDK and Server channels
 for new applications. The [compatibility guide](https://durable-workflow.com/docs/2.0/compatibility/)
 documents protocol and upgrade guarantees.
 
-## Cooperative cancellation release candidate
+## Worker protocol and cooperative cancellation
+
+Workers use protocol 1.20 by default. For a Server that supports only 1.19, set
+`DURABLE_WORKFLOW_WORKER_PROTOCOL_VERSION=1.19`. This changes the request protocol
+without enabling optional worker features.
 
 Use `request_cancellation()` for bounded, replayable workflow cleanup. Opt in
 against a Server that advertises protocol 1.20 and the required capabilities:
-set `DURABLE_WORKFLOW_WORKER_PROTOCOL_VERSION=1.20` and include
-`cooperative_cancellation` in the Worker's `capabilities`. Durable local callback
+include `cooperative_cancellation` in the Worker's `capabilities`. Durable local callback
 admission also needs `prepared_local_activities`, with
 `prepared_local_activity_cancellation_policies` for explicit local policies.
 Independently cancellable scopes remain disabled.
@@ -196,11 +199,10 @@ to true. CI verifies that checkout, builds the candidate Server, enables protoco
 authority and exact source provenance. An optional exact `native_commit` mounts
 that public Native checkout read-only into the test stack. The image's published
 Composer authority stays intact and the evidence identifies the source overlay.
-These are source qualification runs. For a local
-candidate, set `DURABLE_WORKFLOW_WORKER_PROTOCOL_VERSION=1.20` before starting
-Compose and `DURABLE_WORKFLOW_COOPERATIVE_QUALIFICATION=1` for pytest. These cases
-fail if the runtime does not discover the required capability. Ordinary CI
-keeps protocol 1.19 and skips this unpublished feature's connected cases.
+These are source qualification runs. For a local candidate, set
+`DURABLE_WORKFLOW_COOPERATIVE_QUALIFICATION=1` for pytest. These cases fail if the
+runtime does not discover the required capability. Ordinary CI uses the SDK's
+default protocol and skips the optional connected cooperative cases.
 
 ## License
 

{durable_workflow-2.5.6 → durable_workflow-2.5.8}/tests/test_cancellation_scope_opening.py

@@ -152,8 +152,8 @@ async def test_invalid_authority_fails_before_io(change: dict[str, Any]) -> None
             send.assert_not_awaited()
 
 
-async def test_published_protocol_refuses_opening_before_io(monkeypatch: pytest.MonkeyPatch) -> None:
-    monkeypatch.delenv("DURABLE_WORKFLOW_WORKER_PROTOCOL_VERSION")
+async def test_previous_protocol_refuses_opening_before_io(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setenv("DURABLE_WORKFLOW_WORKER_PROTOCOL_VERSION", "1.19")
     async with Client("http://server", namespace="tenant") as client:
         with patch.object(client, "_request", new_callable=AsyncMock) as send:
             with pytest.raises(ValueError, match="1.20"):

{durable_workflow-2.5.6 → durable_workflow-2.5.8}/tests/test_client.py

@@ -164,10 +164,15 @@ class TestHeaders:
 
     def test_worker_headers(self, client: Client) -> None:
         h = client._headers(worker=True)
-        assert PROTOCOL_VERSION == "1.19"
+        assert PROTOCOL_VERSION == "1.20"
         assert h["X-Durable-Workflow-Protocol-Version"] == PROTOCOL_VERSION
         assert "X-Durable-Workflow-Control-Plane-Version" not in h
 
+    def test_explicit_previous_worker_protocol(self, client: Client, monkeypatch: pytest.MonkeyPatch) -> None:
+        monkeypatch.setenv("DURABLE_WORKFLOW_WORKER_PROTOCOL_VERSION", "1.19")
+        assert client._headers(worker=True)["X-Durable-Workflow-Protocol-Version"] == "1.19"
+        assert client._headers(worker=False)["X-Durable-Workflow-Control-Plane-Version"] == "2"
+
     def test_conformance_protocol_header_overrides(self, client: Client, monkeypatch: pytest.MonkeyPatch) -> None:
         monkeypatch.setenv("DURABLE_WORKFLOW_CONTROL_PLANE_VERSION", "3")
         monkeypatch.setenv("DURABLE_WORKFLOW_WORKER_PROTOCOL_VERSION", "2.0")

{durable_workflow-2.5.6 → durable_workflow-2.5.8}/tests/test_cooperative_cancellation_client.py

@@ -406,14 +406,11 @@ async def test_activity_stop_receipt_rejects_invalid_identity_before_io(
 
 
 @pytest.mark.asyncio
-@pytest.mark.parametrize("version", [None, "1.19", "2.20", "invalid"])
-async def test_activity_stop_receipt_requires_explicit_worker_opt_in(
-    client: Client, monkeypatch: pytest.MonkeyPatch, version: str | None,
+@pytest.mark.parametrize("version", ["1.19", "2.20", "invalid"])
+async def test_activity_stop_receipt_requires_compatible_protocol(
+    client: Client, monkeypatch: pytest.MonkeyPatch, version: str,
 ) -> None:
-    if version is None:
-        monkeypatch.delenv("DURABLE_WORKFLOW_WORKER_PROTOCOL_VERSION", raising=False)
-    else:
-        monkeypatch.setenv("DURABLE_WORKFLOW_WORKER_PROTOCOL_VERSION", version)
+    monkeypatch.setenv("DURABLE_WORKFLOW_WORKER_PROTOCOL_VERSION", version)
     with patch.object(client._http, "request", new_callable=AsyncMock) as send, pytest.raises(ValueError):
         await client.acknowledge_activity_cancellation(
             task_id="task/1", activity_attempt_id="attempt-1", lease_owner="worker-1", request_id="original-request",

{durable_workflow-2.5.6 → durable_workflow-2.5.8}/tests/test_cooperative_cancellation_worker.py

@@ -134,7 +134,7 @@ class ClaimServer:
         return {"outcome": "completed"}
 
     async def worker(self, monkeypatch: pytest.MonkeyPatch, **kwargs: Any) -> Worker:
-        monkeypatch.setenv("DURABLE_WORKFLOW_WORKER_PROTOCOL_VERSION", "1.20")
+        monkeypatch.delenv("DURABLE_WORKFLOW_WORKER_PROTOCOL_VERSION", raising=False)
         # These transport/replay fixtures use local callbacks that share mock
         # state with this process. They never poll or advertise remote handlers.
         local_callbacks = kwargs.pop("activities", [])

{durable_workflow-2.5.6 → durable_workflow-2.5.8}/tests/test_cooperative_remote_worker.py

@@ -94,7 +94,7 @@ async def application_failure(kind: str) -> None:
 
 @pytest_asyncio.fixture
 async def owner(monkeypatch: pytest.MonkeyPatch):  # type: ignore[no-untyped-def]
-    monkeypatch.setenv("DURABLE_WORKFLOW_WORKER_PROTOCOL_VERSION", "1.20")
+    monkeypatch.delenv("DURABLE_WORKFLOW_WORKER_PROTOCOL_VERSION", raising=False)
     client = AsyncMock(spec=Client)
     client.get_cluster_info.return_value = compatible_cluster_info(worker_protocol={
         "version": "1.20", "server_capabilities": {"cooperative_cancellation": True},
@@ -317,8 +317,8 @@ async def test_client_observation_keeps_worker_credentials_namespace_and_fence(m
         assert send.await_args.kwargs["json"] == {"activity_attempt_id": "attempt", "lease_owner": "owner"}
 
 
-async def test_client_observation_requires_explicit_protocol_before_io(monkeypatch: pytest.MonkeyPatch) -> None:
-    monkeypatch.delenv("DURABLE_WORKFLOW_WORKER_PROTOCOL_VERSION", raising=False)
+async def test_client_observation_refuses_previous_protocol_before_io(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setenv("DURABLE_WORKFLOW_WORKER_PROTOCOL_VERSION", "1.19")
     async with Client("http://runtime.test") as client:
         with (patch.object(client._http, "request", new_callable=AsyncMock) as send,
               pytest.raises(ValueError, match="1.20")):

{durable_workflow-2.5.6 → durable_workflow-2.5.8}/tests/test_prepared_local_activity_client.py

@@ -66,8 +66,8 @@ async def test_invalid_claim_or_authority_never_starts_transport(change: dict[st
             send.assert_not_awaited()
 
 
-async def test_default_protocol_refuses_before_io(monkeypatch: pytest.MonkeyPatch) -> None:
-    monkeypatch.delenv("DURABLE_WORKFLOW_WORKER_PROTOCOL_VERSION")
+async def test_previous_protocol_refuses_before_io(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setenv("DURABLE_WORKFLOW_WORKER_PROTOCOL_VERSION", "1.19")
     async with Client("http://server") as client:
         with patch.object(client, "_request", new_callable=AsyncMock) as send:
             with pytest.raises(ValueError, match="1.20"):

{durable_workflow-2.5.6 → durable_workflow-2.5.8}/tests/test_release_metadata.py

@@ -45,13 +45,13 @@ def test_worker_release_identity_matches_supported_server_and_protocol() -> None
     assert release["product-train"] == project["version"]
     assert release["registry-version"] == project["version"].replace("-rc.", "rc")
     assert check_release_metadata.VERSION_PATTERN.fullmatch(release["supported-server-versions"]) is not None
-    assert release["worker-protocol-version"] == PROTOCOL_VERSION == "1.19"
+    assert release["worker-protocol-version"] == PROTOCOL_VERSION == "1.20"
     assert release["durable-selection"] is True
     assert release["durable-selection-minimum-worker-protocol-version"] == "1.19"
 
     assert declared_runtime_protocol_version(
         (REPO_ROOT / "src" / "durable_workflow" / "client.py").read_text(encoding="utf-8")
-    ) == "1.19"
+    ) == "1.20"
 
 
 def pypi_json(source: SourceMetadata, **overrides: object) -> bytes:

{durable_workflow-2.5.6 → durable_workflow-2.5.8}/tests/test_worker.py

@@ -1114,6 +1114,39 @@ class TestWorkerRegistration:
             await worker._register()
         mock_client.register_worker.assert_not_called()
 
+    @pytest.mark.asyncio
+    async def test_register_accepts_explicit_previous_protocol(
+        self, mock_client: AsyncMock, monkeypatch: pytest.MonkeyPatch,
+    ) -> None:
+        monkeypatch.setenv("DURABLE_WORKFLOW_WORKER_PROTOCOL_VERSION", "1.19")
+        mock_client.get_cluster_info = AsyncMock(
+            return_value=compatible_cluster_info(worker_protocol={"version": "1.19"})
+        )
+        worker = Worker(mock_client, task_queue="q1", workflows=[TestWorkflow], activities=[])
+        await worker._register()
+        mock_client.register_worker.assert_called_once()
+
+    @pytest.mark.asyncio
+    async def test_default_protocol_refuses_previous_server_before_registration(self, mock_client: AsyncMock) -> None:
+        mock_client.get_cluster_info = AsyncMock(
+            return_value=compatible_cluster_info(worker_protocol={"version": "1.19"})
+        )
+        worker = Worker(mock_client, task_queue="q1", workflows=[TestWorkflow], activities=[])
+        with pytest.raises(RuntimeError, match="minor>='1.20'"):
+            await worker._register()
+        mock_client.register_worker.assert_not_called()
+
+    @pytest.mark.asyncio
+    @pytest.mark.parametrize("version", ["1.18", "1.21", "2.0"])
+    async def test_register_rejects_unsupported_protocol_override(
+        self, mock_client: AsyncMock, monkeypatch: pytest.MonkeyPatch, version: str,
+    ) -> None:
+        monkeypatch.setenv("DURABLE_WORKFLOW_WORKER_PROTOCOL_VERSION", version)
+        worker = Worker(mock_client, task_queue="q1", workflows=[TestWorkflow], activities=[])
+        with pytest.raises(RuntimeError, match="supports worker protocol 1.19 or protocol 1.20"):
+            await worker._register()
+        mock_client.register_worker.assert_not_called()
+
     @pytest.mark.asyncio
     async def test_register_accepts_higher_compatible_minor_protocol(self, mock_client: AsyncMock) -> None:
         # Server is one minor ahead of the SDK. MINOR bumps in workflow:v2's
@@ -5068,6 +5101,34 @@ class TestRunUntil:
         assert mock_client.describe_workflow.await_count == 2
         assert mock_client.poll_workflow_task.call_args.kwargs["history_page_size"] == 500
 
+    @pytest.mark.asyncio
+    @pytest.mark.parametrize("blocked_method", ["get_cluster_info", "register_worker"])
+    async def test_run_until_identifies_startup_timeout_before_polling(
+        self, mock_client: AsyncMock, blocked_method: str
+    ) -> None:
+        started = asyncio.Event()
+
+        async def blocked(*args: object, **kwargs: object) -> None:
+            started.set()
+            await asyncio.Event().wait()
+
+        setattr(mock_client, blocked_method, AsyncMock(side_effect=blocked))
+        worker = Worker(mock_client, task_queue="q1", workflows=[TestWorkflow])
+
+        with pytest.raises(TimeoutError) as failure:
+            await worker.run_until(workflow_id="wf-startup-timeout", timeout=0.05)
+
+        assert started.is_set()
+        assert "startup" in str(failure.value)
+        assert worker.worker_id in str(failure.value)
+        assert "wf-startup-timeout" in str(failure.value)
+        assert isinstance(failure.value.__cause__, asyncio.TimeoutError)
+        assert worker._stop.is_set()
+        assert worker._registration_done.is_set()
+        mock_client.poll_workflow_task.assert_not_awaited()
+        mock_client.poll_activity_task.assert_not_awaited()
+        mock_client.deregister_worker_registration.assert_not_awaited()
+
     @pytest.mark.asyncio
     async def test_run_until_times_out_and_stops_worker(self, mock_client: AsyncMock) -> None:
         mock_client.describe_workflow = AsyncMock(
@@ -5086,9 +5147,11 @@ class TestRunUntil:
             poll_timeout=0.01,
         )
 
-        with pytest.raises(TimeoutError, match="wf-timeout"):
+        with pytest.raises(TimeoutError, match="wf-timeout") as failure:
             await worker.run_until(workflow_id="wf-timeout", timeout=0.02, poll_interval=0.01)
 
+        assert "not terminal" in str(failure.value)
+        assert "startup" not in str(failure.value)
         assert worker._stop.is_set()
 
     @pytest.mark.asyncio