iii-sdk 0.21.4.dev2__tar.gz → 0.21.5.dev1__tar.gz

{iii_sdk-0.21.4.dev2 → iii_sdk-0.21.5.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: iii-sdk
-Version: 0.21.4.dev2
+Version: 0.21.5.dev1
 Summary: III SDK for Python
 Project-URL: Homepage, https://github.com/iii-hq/iii
 Project-URL: Repository, https://github.com/iii-hq/iii
@@ -14,7 +14,7 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Requires-Python: >=3.10
-Requires-Dist: iii-helpers==0.21.4.dev2
+Requires-Dist: iii-helpers==0.21.5.dev1
 Requires-Dist: opentelemetry-api>=1.25
 Requires-Dist: pydantic>=2.0
 Requires-Dist: websockets>=12.0

{iii_sdk-0.21.4.dev2 → iii_sdk-0.21.5.dev1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "iii-sdk"
-version = "0.21.4.dev2"
+version = "0.21.5.dev1"
 description = "III SDK for Python"
 authors = [{ name = "III" }]
 license = { text = "Apache-2.0" }
@@ -23,7 +23,7 @@ dependencies = [
     "websockets>=12.0",
     "pydantic>=2.0",
     "opentelemetry-api>=1.25",
-    "iii-helpers==0.21.4.dev2",
+    "iii-helpers==0.21.5.dev1",
 ]
 
 [project.urls]

{iii_sdk-0.21.4.dev2 → iii_sdk-0.21.5.dev1}/src/iii/iii.py

@@ -1130,7 +1130,8 @@ class III:
         The routing behavior and return type depend on the ``action`` field:
 
         - No action: synchronous -- waits for the function to return.
-        - ``TriggerAction.Enqueue(...)``: async via named queue -- returns ``EnqueueResult``.
+        - ``TriggerAction.Enqueue(...)``: async via named queue -- returns a dict
+          with ``messageReceiptId``.
         - ``TriggerAction.Void()``: fire-and-forget -- returns ``None``.
 
         Args:
@@ -1139,8 +1140,8 @@ class III:
 
         Returns:
             The function's return value for synchronous (no-action) calls,
-            an ``EnqueueResult`` for enqueue actions, or ``None`` for void
-            actions.
+            a ``{"messageReceiptId": ...}`` dict for enqueue actions, or
+            ``None`` for void actions.
 
         Raises:
             InvocationError: For any engine rejection. Inspect ``code``:
@@ -1159,7 +1160,8 @@ class III:
         The routing behavior and return type depend on the ``action`` field:
 
         - No action: synchronous -- waits for the function to return.
-        - ``TriggerAction.Enqueue(...)``: async via named queue -- returns ``EnqueueResult``.
+        - ``TriggerAction.Enqueue(...)``: async via named queue -- returns a dict
+          with ``messageReceiptId``.
         - ``TriggerAction.Void()``: fire-and-forget -- returns ``None``.
 
         Args:
@@ -1167,7 +1169,9 @@ class III:
                 and optional ``action`` / ``timeout_ms``.
 
         Returns:
-            The result of the function invocation, or ``None`` for void calls.
+            The function's return value for synchronous (no-action) calls,
+            a ``{"messageReceiptId": ...}`` dict for enqueue actions, or
+            ``None`` for void actions.
 
         Raises:
             InvocationError: For any engine rejection. Inspect ``code``:

{iii_sdk-0.21.4.dev2 → iii_sdk-0.21.5.dev1}/src/iii/iii_types.py

@@ -170,6 +170,9 @@ class RegisterFunctionMessage(BaseModel):
 class TriggerActionEnqueue(BaseModel):
     """Routes the invocation through a named queue for async processing.
 
+    Requires a queue worker in the project — run ``iii worker add queue``.
+    Without it the trigger rejects with ``enqueue_error`` (no queue provider).
+
     Attributes:
         type: Always ``'enqueue'``.
         queue: Name of the target queue.

{iii_sdk-0.21.4.dev2 → iii_sdk-0.21.5.dev1}/tests/test_http_external_functions_integration.py

@@ -21,10 +21,6 @@ def _unique_function_id(prefix: str) -> str:
     return f"{prefix}::{int(time.time())}::{random.random():.10f}".replace(".", "")
 
 
-def _unique_topic(prefix: str) -> str:
-    return f"{prefix}.{int(time.time())}.{random.random():.10f}".replace(".", "")
-
-
 class WebhookProbe:
     def __init__(self) -> None:
         self._received: list[dict[str, Any]] = []
@@ -191,6 +187,21 @@ def _make_integration_client() -> III:
     return client
 
 
+async def _invoke(client: III, function_id: str, payload: dict[str, Any]) -> Any:
+    """Directly invoke an HTTP external function without blocking the test loop.
+
+    ``client.trigger`` is synchronous and blocks the caller until the engine's
+    webhook POST round-trips. Since the WebhookProbe server runs on this same
+    event loop, calling it inline would deadlock -- so we run it on a worker
+    thread and let the loop keep serving the probe.
+    """
+    loop = asyncio.get_running_loop()
+    return await loop.run_in_executor(
+        None,
+        lambda: client.trigger({"function_id": function_id, "payload": payload}),
+    )
+
+
 # ===========================================================================
 # Unit tests (FakeWs)
 # ===========================================================================
@@ -282,16 +293,14 @@ def test_unregister_removes_function_from_sent_messages(monkeypatch: pytest.Monk
 
 
 @pytest.mark.asyncio
-async def test_delivers_queue_events_to_external_http_function() -> None:
+async def test_delivers_events_to_external_http_function() -> None:
     client = _make_integration_client()
 
     probe = WebhookProbe()
     await probe.start()
 
     function_id = _unique_function_id("test::http_external::target")
-    topic = _unique_topic("test.http_external.topic")
     payload = {"hello": "world", "count": 1}
-    trigger = None
     http_fn = None
 
     try:
@@ -301,21 +310,16 @@ async def test_delivers_queue_events_to_external_http_function() -> None:
         )
         time.sleep(0.5)
 
-        trigger = client.register_trigger(
-            {"type": "durable:subscriber", "function_id": function_id, "config": {"topic": topic}}
-        )
-        time.sleep(0.5)
-
-        client.trigger({"function_id": "iii::durable::publish", "payload": {"topic": topic, "data": payload}})
+        await _invoke(client, function_id, payload)
 
         webhook = await probe.wait_for_webhook(7.0)
 
         assert webhook["method"] == "POST"
         assert webhook["url"] == "/webhook"
-        assert webhook["body"] == payload
+        # Direct invocation injects caller metadata (e.g. _caller_worker_id) into
+        # the POSTed body, so assert the expected payload is a subset.
+        assert payload.items() <= webhook["body"].items()
     finally:
-        if trigger:
-            trigger.unregister()
         if http_fn:
             http_fn.unregister()
         await probe.close()
@@ -381,9 +385,7 @@ async def test_delivers_events_with_custom_headers() -> None:
     await probe.start()
 
     function_id = _unique_function_id("test::http_external::custom_headers")
-    topic = _unique_topic("test.http_external.headers")
     payload = {"event": "custom_header_test"}
-    trigger = None
     http_fn = None
 
     try:
@@ -398,17 +400,14 @@ async def test_delivers_events_with_custom_headers() -> None:
         )
         time.sleep(0.5)
 
-        trigger = client.register_trigger(
-            {"type": "durable:subscriber", "function_id": function_id, "config": {"topic": topic}}
-        )
-        time.sleep(0.5)
-
-        client.trigger({"function_id": "iii::durable::publish", "payload": {"topic": topic, "data": payload}})
+        await _invoke(client, function_id, payload)
 
         webhook = await probe.wait_for_webhook(7.0)
 
         assert webhook["method"] == "POST"
-        assert webhook["body"] == payload
+        # Direct invocation injects caller metadata (e.g. _caller_worker_id) into
+        # the POSTed body, so assert the expected payload is a subset.
+        assert payload.items() <= webhook["body"].items()
 
         # Verify custom headers were forwarded by the engine.
         # Header keys may be lowercased by the HTTP client.
@@ -418,8 +417,6 @@ async def test_delivers_events_with_custom_headers() -> None:
         )
         assert received_headers.get("x-another") == "123", f"Expected x-another=123, got headers: {received_headers}"
     finally:
-        if trigger:
-            trigger.unregister()
         if http_fn:
             http_fn.unregister()
         await probe.close()
@@ -437,15 +434,11 @@ async def test_delivers_events_to_multiple_external_functions() -> None:
 
     fn_id_a = _unique_function_id("test::http_external::multi_a")
     fn_id_b = _unique_function_id("test::http_external::multi_b")
-    topic_a = _unique_topic("test.http_external.multi_a")
-    topic_b = _unique_topic("test.http_external.multi_b")
     payload_a = {"source": "topic_a", "value": 1}
     payload_b = {"source": "topic_b", "value": 2}
 
     http_fn_a = None
     http_fn_b = None
-    trigger_a = None
-    trigger_b = None
 
     try:
         http_fn_a = client.register_function(
@@ -458,31 +451,20 @@ async def test_delivers_events_to_multiple_external_functions() -> None:
         )
         time.sleep(0.5)
 
-        trigger_a = client.register_trigger(
-            {"type": "durable:subscriber", "function_id": fn_id_a, "config": {"topic": topic_a}}
-        )
-        trigger_b = client.register_trigger(
-            {"type": "durable:subscriber", "function_id": fn_id_b, "config": {"topic": topic_b}}
-        )
-        time.sleep(0.5)
-
-        client.trigger({"function_id": "iii::durable::publish", "payload": {"topic": topic_a, "data": payload_a}})
-        client.trigger({"function_id": "iii::durable::publish", "payload": {"topic": topic_b, "data": payload_b}})
+        await _invoke(client, fn_id_a, payload_a)
+        await _invoke(client, fn_id_b, payload_b)
 
         webhook_a = await probe_a.wait_for_webhook(7.0)
         webhook_b = await probe_b.wait_for_webhook(7.0)
 
-        # Each probe should receive only its own topic's event.
-        assert webhook_a["body"] == payload_a, f"probe_a got wrong body: {webhook_a['body']}"
+        # Each probe should receive only its own function's event. Direct
+        # invocation injects caller metadata into the body, so assert subset.
+        assert payload_a.items() <= webhook_a["body"].items(), f"probe_a got wrong body: {webhook_a['body']}"
         assert webhook_a["url"] == "/hook_a"
 
-        assert webhook_b["body"] == payload_b, f"probe_b got wrong body: {webhook_b['body']}"
+        assert payload_b.items() <= webhook_b["body"].items(), f"probe_b got wrong body: {webhook_b['body']}"
         assert webhook_b["url"] == "/hook_b"
     finally:
-        if trigger_a:
-            trigger_a.unregister()
-        if trigger_b:
-            trigger_b.unregister()
         if http_fn_a:
             http_fn_a.unregister()
         if http_fn_b:
@@ -500,10 +482,8 @@ async def test_stops_delivering_after_unregister() -> None:
     await probe.start()
 
     function_id = _unique_function_id("test::http_external::stop_deliver")
-    topic = _unique_topic("test.http_external.stop_deliver")
     payload_before = {"phase": "before_unregister"}
     payload_after = {"phase": "after_unregister"}
-    trigger = None
     http_fn = None
 
     try:
@@ -513,30 +493,27 @@ async def test_stops_delivering_after_unregister() -> None:
         )
         time.sleep(0.5)
 
-        trigger = client.register_trigger(
-            {"type": "durable:subscriber", "function_id": function_id, "config": {"topic": topic}}
-        )
-        time.sleep(0.5)
-
-        # First enqueue -- should be delivered.
-        client.trigger({"function_id": "iii::durable::publish", "payload": {"topic": topic, "data": payload_before}})
+        # First invocation -- should be delivered.
+        await _invoke(client, function_id, payload_before)
         webhook = await probe.wait_for_webhook(7.0)
-        assert webhook["body"] == payload_before
+        # Direct invocation injects caller metadata (e.g. _caller_worker_id) into
+        # the POSTed body, so assert the expected payload is a subset.
+        assert payload_before.items() <= webhook["body"].items()
 
-        # Unregister trigger and function.
-        trigger.unregister()
-        trigger = None
+        # Unregister the function.
         http_fn.unregister()
         http_fn = None
         time.sleep(0.5)
 
-        # Second enqueue -- should NOT be delivered (function is gone).
-        client.trigger({"function_id": "iii::durable::publish", "payload": {"topic": topic, "data": payload_after}})
+        # Second invocation -- the function is gone, so the trigger is rejected
+        # and nothing reaches the webhook.
+        try:
+            await _invoke(client, function_id, payload_after)
+        except Exception:
+            pass
         no_delivery = await probe.wait_for_webhook_or_none(timeout=2.0)
         assert no_delivery is None, f"Expected no delivery after unregister, but got: {no_delivery}"
     finally:
-        if trigger:
-            trigger.unregister()
         if http_fn:
             http_fn.unregister()
         await probe.close()
@@ -551,9 +528,7 @@ async def test_delivers_with_put_method() -> None:
     await probe.start()
 
     function_id = _unique_function_id("test::http_external::put_method")
-    topic = _unique_topic("test.http_external.put_method")
     payload = {"action": "update", "id": 42}
-    trigger = None
     http_fn = None
 
     try:
@@ -563,20 +538,15 @@ async def test_delivers_with_put_method() -> None:
         )
         time.sleep(0.5)
 
-        trigger = client.register_trigger(
-            {"type": "durable:subscriber", "function_id": function_id, "config": {"topic": topic}}
-        )
-        time.sleep(0.5)
-
-        client.trigger({"function_id": "iii::durable::publish", "payload": {"topic": topic, "data": payload}})
+        await _invoke(client, function_id, payload)
 
         webhook = await probe.wait_for_webhook(7.0)
 
         assert webhook["method"] == "PUT", f"Expected PUT, got {webhook['method']}"
-        assert webhook["body"] == payload
+        # Direct invocation injects caller metadata (e.g. _caller_worker_id) into
+        # the POSTed body, so assert the expected payload is a subset.
+        assert payload.items() <= webhook["body"].items()
     finally:
-        if trigger:
-            trigger.unregister()
         if http_fn:
             http_fn.unregister()
         await probe.close()

iii_sdk-0.21.5.dev1/tests/test_trigger_action.py

@@ -0,0 +1,19 @@
+"""Contract test for the SDK-owned TriggerAction builders.
+
+The queue *behavior* (delivery, ordering, DLQ, durable fan-out) is exercised by
+the standalone queue worker's own suite; here we only pin the wire shape the
+engine's ``TriggerAction`` deserialization depends on, so it needs no live engine.
+"""
+
+from iii.iii_types import TriggerActionEnqueue, TriggerActionVoid
+
+
+def test_enqueue_serializes_to_type_and_queue() -> None:
+    assert TriggerActionEnqueue(queue="orders").model_dump() == {
+        "type": "enqueue",
+        "queue": "orders",
+    }
+
+
+def test_void_serializes_to_type() -> None:
+    assert TriggerActionVoid().model_dump() == {"type": "void"}

iii_sdk-0.21.4.dev2/tests/test_queue_integration.py

@@ -1,363 +0,0 @@
-"""Integration tests for queue enqueue and void trigger actions."""
-
-import time
-
-from iii import TriggerAction
-from iii.iii import III
-
-
-def wait_for(condition, timeout=5.0, interval=0.1):
-    """Poll until condition() is truthy or timeout."""
-    deadline = time.monotonic() + timeout
-    while time.monotonic() < deadline:
-        if condition():
-            return
-        time.sleep(interval)
-    raise TimeoutError(f"Condition not met within {timeout}s")
-
-
-def _wait_for_registration(iii_client: III, function_id: str, timeout: float = 5.0) -> None:
-    """Poll engine::functions::list until function_id is registered, or TimeoutError."""
-    deadline = time.monotonic() + timeout
-    while time.monotonic() < deadline:
-        try:
-            result = iii_client.trigger({"function_id": "engine::functions::list", "payload": {}})
-            functions = result.get("functions", []) if isinstance(result, dict) else []
-            ids = [f.get("function_id") for f in functions if isinstance(f, dict)]
-            if function_id in ids:
-                return
-        except Exception:
-            pass
-        time.sleep(0.1)
-    raise TimeoutError(f"Function {function_id} was not registered within {timeout}s")
-
-
-def test_enqueue_delivers_message_to_function(iii_client: III):
-    """Enqueue action delivers payload to the registered consumer function."""
-    received = []
-
-    def consumer_handler(input_data):
-        received.append(input_data)
-        return None
-
-    ref = iii_client.register_function("test.queue.py.consumer", consumer_handler)
-    time.sleep(0.3)
-
-    try:
-        result = iii_client.trigger(
-            {
-                "function_id": "test.queue.py.consumer",
-                "payload": {"order": "pizza"},
-                "action": TriggerAction.Enqueue(queue="test-orders"),
-            }
-        )
-
-        assert isinstance(result, dict)
-        assert isinstance(result["messageReceiptId"], str)
-
-        wait_for(lambda: len(received) > 0, timeout=5.0)
-
-        assert received[0]["order"] == "pizza"
-    finally:
-        ref.unregister()
-
-
-def test_void_trigger_returns_none(iii_client: III):
-    """Void trigger action fires without waiting and returns None."""
-    calls = []
-
-    def void_consumer_handler(input_data):
-        calls.append(input_data)
-        return None
-
-    ref = iii_client.register_function("test.queue.py.void-consumer", void_consumer_handler)
-    time.sleep(0.3)
-
-    try:
-        result = iii_client.trigger(
-            {
-                "function_id": "test.queue.py.void-consumer",
-                "payload": {"msg": "fire"},
-                "action": TriggerAction.Void(),
-            }
-        )
-
-        assert result is None
-
-        wait_for(lambda: len(calls) > 0, timeout=5.0)
-
-        assert calls[0]["msg"] == "fire"
-    finally:
-        ref.unregister()
-
-
-def test_enqueue_multiple_messages(iii_client: III):
-    """Multiple enqueued messages are all delivered to the consumer."""
-    received = []
-
-    def multi_handler(input_data):
-        received.append(input_data)
-        return None
-
-    ref = iii_client.register_function("test.queue.py.multi", multi_handler)
-    time.sleep(0.3)
-
-    try:
-        for i in range(5):
-            iii_client.trigger(
-                {
-                    "function_id": "test.queue.py.multi",
-                    "payload": {"index": i},
-                    "action": TriggerAction.Enqueue(queue="test-multi"),
-                }
-            )
-
-        wait_for(lambda: len(received) == 5, timeout=10.0)
-
-        assert len(received) == 5
-        received_indices = sorted(item["index"] for item in received)
-        assert received_indices == [0, 1, 2, 3, 4]
-    finally:
-        ref.unregister()
-
-
-def test_chained_enqueue(iii_client: III):
-    """Function A enqueues a message to function B, forming a chain."""
-    chain_received = []
-
-    def chain_a_handler(input_data):
-        iii_client.trigger(
-            {
-                "function_id": "test.queue.py.chain-b",
-                "payload": {**input_data, "chained": True},
-                "action": TriggerAction.Enqueue(queue="test-chain"),
-            }
-        )
-        return input_data
-
-    def chain_b_handler(input_data):
-        chain_received.append(input_data)
-        return None
-
-    ref_a = iii_client.register_function("test.queue.py.chain-a", chain_a_handler)
-    ref_b = iii_client.register_function("test.queue.py.chain-b", chain_b_handler)
-    time.sleep(0.3)
-
-    try:
-        iii_client.trigger(
-            {
-                "function_id": "test.queue.py.chain-a",
-                "payload": {"origin": "test"},
-                "action": TriggerAction.Enqueue(queue="test-chain"),
-            }
-        )
-
-        wait_for(lambda: len(chain_received) > 0, timeout=5.0)
-
-        assert chain_received[0]["chained"] is True
-        assert chain_received[0]["origin"] == "test"
-    finally:
-        ref_b.unregister()
-        ref_a.unregister()
-
-
-# ---------------------------------------------------------------------------
-# Durable subscriber / publisher scenarios (ported from motia-py, MOT-3109).
-# These exercise the `durable:subscriber` trigger + `iii::durable::publish`
-# path, complementing the TriggerAction.Enqueue tests above.
-# ---------------------------------------------------------------------------
-
-
-def test_durable_publish_delivers_to_subscribed_handler(iii_client: III):
-    """Publishing to a topic delivers the message to a subscribed handler."""
-    function_id = f"test.queue.py.durable.basic.{int(time.time() * 1000)}"
-    topic = f"test-topic-{int(time.time() * 1000)}"
-    received: list = []
-
-    def handler(data):
-        received.append(data)
-        return None
-
-    fn_ref = iii_client.register_function(function_id, handler)
-    trigger = iii_client.register_trigger(
-        {"type": "durable:subscriber", "function_id": function_id, "config": {"topic": topic}}
-    )
-    time.sleep(0.5)
-
-    try:
-        iii_client.trigger(
-            {
-                "function_id": "iii::durable::publish",
-                "payload": {"topic": topic, "data": {"order": "abc"}},
-            }
-        )
-        wait_for(lambda: len(received) > 0, timeout=5.0)
-        assert received == [{"order": "abc"}]
-    finally:
-        trigger.unregister()
-        fn_ref.unregister()
-
-
-def test_durable_publish_delivers_exact_payload(iii_client: III):
-    """Handler receives the exact published payload without mutation."""
-    function_id = f"test.queue.py.durable.payload.{int(time.time() * 1000)}"
-    topic = f"test-topic-payload-{int(time.time() * 1000)}"
-    payload = {"id": "x1", "count": 42, "nested": {"a": 1}}
-    received: list = []
-
-    def handler(data):
-        received.append(data)
-        return None
-
-    fn_ref = iii_client.register_function(function_id, handler)
-    trigger = iii_client.register_trigger(
-        {"type": "durable:subscriber", "function_id": function_id, "config": {"topic": topic}}
-    )
-    time.sleep(0.5)
-
-    try:
-        iii_client.trigger(
-            {
-                "function_id": "iii::durable::publish",
-                "payload": {"topic": topic, "data": payload},
-            }
-        )
-        wait_for(lambda: len(received) > 0, timeout=5.0)
-        assert received == [payload]
-    finally:
-        trigger.unregister()
-        fn_ref.unregister()
-
-
-def test_durable_subscriber_with_queue_config(iii_client: III):
-    """Subscription with queue_config (maxRetries, concurrency, type) still delivers."""
-    function_id = f"test.queue.py.durable.infra.{int(time.time() * 1000)}"
-    topic = f"test-topic-infra-{int(time.time() * 1000)}"
-    received: list = []
-
-    def handler(data):
-        received.append(data)
-        return None
-
-    fn_ref = iii_client.register_function(function_id, handler)
-    trigger = iii_client.register_trigger(
-        {
-            "type": "durable:subscriber",
-            "function_id": function_id,
-            "config": {
-                "topic": topic,
-                "queue_config": {
-                    "maxRetries": 5,
-                    "type": "standard",
-                    "concurrency": 2,
-                },
-            },
-        }
-    )
-    time.sleep(0.5)
-
-    try:
-        iii_client.trigger(
-            {
-                "function_id": "iii::durable::publish",
-                "payload": {"topic": topic, "data": {"infra": True}},
-            }
-        )
-        wait_for(lambda: len(received) > 0, timeout=5.0)
-        assert received == [{"infra": True}]
-    finally:
-        trigger.unregister()
-        fn_ref.unregister()
-
-
-def test_durable_multiple_subscribers_fanout(iii_client: III):
-    """Multiple subscribers on the same topic each receive every message."""
-    topic = f"test-topic-multi-{int(time.time() * 1000)}"
-    function_id1 = f"test.queue.py.durable.multi1.{int(time.time() * 1000)}"
-    function_id2 = f"test.queue.py.durable.multi2.{int(time.time() * 1000)}"
-    received1: list = []
-    received2: list = []
-
-    def handler1(data):
-        received1.append(data)
-        return None
-
-    def handler2(data):
-        received2.append(data)
-        return None
-
-    fn1 = iii_client.register_function(function_id1, handler1)
-    fn2 = iii_client.register_function(function_id2, handler2)
-    trigger1 = iii_client.register_trigger(
-        {"type": "durable:subscriber", "function_id": function_id1, "config": {"topic": topic}}
-    )
-    trigger2 = iii_client.register_trigger(
-        {"type": "durable:subscriber", "function_id": function_id2, "config": {"topic": topic}}
-    )
-    time.sleep(0.5)
-
-    try:
-        iii_client.trigger({"function_id": "iii::durable::publish", "payload": {"topic": topic, "data": {"msg": 1}}})
-        iii_client.trigger({"function_id": "iii::durable::publish", "payload": {"topic": topic, "data": {"msg": 2}}})
-        wait_for(lambda: len(received1) >= 2 and len(received2) >= 2, timeout=8.0)
-
-        assert len(received1) == 2
-        assert len(received2) == 2
-        assert {"msg": 1} in received1
-        assert {"msg": 2} in received1
-        assert {"msg": 1} in received2
-        assert {"msg": 2} in received2
-    finally:
-        trigger1.unregister()
-        trigger2.unregister()
-        fn1.unregister()
-        fn2.unregister()
-
-
-def test_durable_condition_function_filters_messages(iii_client: III):
-    """Registering a condition_function_id filters out non-matching messages."""
-    topic = f"test-topic-cond-{int(time.time() * 1000)}"
-    function_id = f"test.queue.py.durable.cond.{int(time.time() * 1000)}"
-    condition_path = f"{function_id}::conditions::0"
-    handler_calls: list = []
-
-    def handler(data):
-        handler_calls.append(data)
-        return None
-
-    def condition(input_data):
-        return bool(input_data.get("accept"))
-
-    fn_ref = iii_client.register_function(function_id, handler)
-    cond_ref = iii_client.register_function(condition_path, condition)
-    trigger = iii_client.register_trigger(
-        {
-            "type": "durable:subscriber",
-            "function_id": function_id,
-            "config": {
-                "topic": topic,
-                "condition_function_id": condition_path,
-            },
-        }
-    )
-
-    try:
-        _wait_for_registration(iii_client, function_id)
-        _wait_for_registration(iii_client, condition_path)
-
-        iii_client.trigger(
-            {"function_id": "iii::durable::publish", "payload": {"topic": topic, "data": {"accept": False}}}
-        )
-        iii_client.trigger(
-            {"function_id": "iii::durable::publish", "payload": {"topic": topic, "data": {"accept": True}}}
-        )
-        wait_for(lambda: len(handler_calls) >= 1, timeout=8.0)
-        # Give the rejected message a moment to ensure it does NOT arrive.
-        time.sleep(1.0)
-
-        assert len(handler_calls) == 1
-        assert handler_calls[0] == {"accept": True}
-    finally:
-        trigger.unregister()
-        cond_ref.unregister()
-        fn_ref.unregister()