tigrbl_tests 0.4.2.dev4__py3-none-any.whl → 0.4.3.dev4__py3-none-any.whl

tests/architecture/test_route_to_pathspec_migration.py

@@ -0,0 +1,53 @@
+from __future__ import annotations
+
+import ast
+from pathlib import Path
+
+import pytest
+
+from tigrbl_core._spec import AppSpec, PathSpec, RouterSpec
+
+
+REPO_ROOT = Path(__file__).resolve().parents[5]
+
+
+def test_routespec_is_not_a_public_canonical_spec_export() -> None:
+    import tigrbl_core._spec as spec
+
+    assert not hasattr(spec, "RouteSpec")
+    assert "RouteSpec" not in getattr(spec, "__all__", ())
+
+
+def test_appspec_and_routerspec_reject_legacy_routes_field() -> None:
+    with pytest.raises(ValueError, match="AppSpec does not accept 'routes'"):
+        AppSpec.from_dict({"routes": []})
+
+    with pytest.raises(ValueError, match="RouterSpec does not accept 'routes'"):
+        RouterSpec.from_dict({"routes": []})
+
+    with pytest.raises(ValueError, match="PathSpec does not accept 'routes'"):
+        PathSpec.from_dict({"path": "/items", "routes": []})
+
+    router = RouterSpec(name="api", paths=(PathSpec(path="/items", kind="resource"),))
+
+    assert router.paths[0].path == "/items"
+
+
+def test_canonical_spec_package_does_not_import_legacy_route_module() -> None:
+    spec_root = REPO_ROOT / "pkgs" / "core" / "tigrbl_core" / "tigrbl_core" / "_spec"
+    offenders: list[str] = []
+    for py_file in spec_root.rglob("*.py"):
+        tree = ast.parse(py_file.read_text(encoding="utf-8"))
+        for node in ast.walk(tree):
+            if isinstance(node, ast.ImportFrom):
+                module = node.module or ""
+                if module.endswith("._route") or module.endswith("_concrete._route"):
+                    offenders.append(str(py_file.relative_to(REPO_ROOT)))
+            elif isinstance(node, ast.Import):
+                for alias in node.names:
+                    if alias.name.endswith("._route") or alias.name.endswith(
+                        "_concrete._route"
+                    ):
+                        offenders.append(str(py_file.relative_to(REPO_ROOT)))
+
+    assert offenders == []

tests/architecture/test_runtime_structure.py

@@ -8,9 +8,11 @@ RUNTIME_PKG = _STANDARDS / "tigrbl_runtime" / "tigrbl_runtime"
 
 
 def test_dependency_invoke_is_runtime_event_anchor():
-    events = (RUNTIME_PKG / "runtime" / "events.py").read_text()
-    assert "DEP_EXTRA" in events
-    assert '"PRE_TX_BEGIN"' in events
+    system = (RUNTIME_PKG / "runtime" / "system.py").read_text()
+    invoke = (RUNTIME_PKG / "executors" / "invoke.py").read_text()
+    assert "DEP_EXTRA" in system
+    assert '"PRE_TX_BEGIN"' in system
+    assert '"PRE_TX_BEGIN"' in invoke
 
 
 def test_runtime_gateway_owns_runtime_entrypoint_and_send():

tests/architecture/test_transport_hot_path_boundary.py

@@ -0,0 +1,66 @@
+from __future__ import annotations
+
+import ast
+from pathlib import Path
+
+
+CORE_ROOT = Path(__file__).resolve().parents[3]
+HOT_PATH_ROOTS = (
+    CORE_ROOT / "tigrbl_atoms" / "tigrbl_atoms",
+    CORE_ROOT / "tigrbl_kernel" / "tigrbl_kernel",
+    CORE_ROOT / "tigrbl_runtime" / "tigrbl_runtime",
+)
+DEPRECATED_TRANSPORT_MODULE_PREFIXES = (
+    "tigrbl.transport",
+    "tigrbl_concrete.transport",
+)
+
+
+def _python_sources() -> list[Path]:
+    paths: list[Path] = []
+    for root in HOT_PATH_ROOTS:
+        paths.extend(
+            path
+            for path in root.rglob("*.py")
+            if "__pycache__" not in path.parts
+        )
+    return paths
+
+
+def _forbidden_imports(path: Path) -> list[str]:
+    tree = ast.parse(path.read_text(encoding="utf-8"), filename=str(path))
+    matches: list[str] = []
+    for node in ast.walk(tree):
+        if isinstance(node, ast.Import):
+            for alias in node.names:
+                if alias.name.startswith(DEPRECATED_TRANSPORT_MODULE_PREFIXES):
+                    matches.append(alias.name)
+        elif isinstance(node, ast.ImportFrom) and node.module:
+            if node.module.startswith(DEPRECATED_TRANSPORT_MODULE_PREFIXES):
+                matches.append(node.module)
+    return matches
+
+
+def test_atoms_kernel_runtime_do_not_import_deprecated_transport_shims() -> None:
+    offenders = {
+        str(path.relative_to(CORE_ROOT)): imports
+        for path in _python_sources()
+        if (imports := _forbidden_imports(path))
+    }
+
+    assert offenders == {}
+
+
+def test_atoms_kernel_runtime_do_not_dynamic_import_deprecated_transport_shims() -> None:
+    offenders: dict[str, list[str]] = {}
+    for path in _python_sources():
+        text = path.read_text(encoding="utf-8")
+        hits = [
+            prefix
+            for prefix in DEPRECATED_TRANSPORT_MODULE_PREFIXES
+            if prefix in text
+        ]
+        if hits:
+            offenders[str(path.relative_to(CORE_ROOT))] = hits
+
+    assert offenders == {}

tests/architecture/test_transport_removal_readiness.py

@@ -0,0 +1,57 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+
+CORE_ROOT = Path(__file__).resolve().parents[3]
+TIGRBL_ROOT = CORE_ROOT / "tigrbl" / "tigrbl"
+CONCRETE_ROOT = CORE_ROOT / "tigrbl_concrete" / "tigrbl_concrete"
+TESTS_ROOT = CORE_ROOT / "tigrbl_tests" / "tests"
+
+
+DEPRECATED_SHIMS = (
+    TIGRBL_ROOT / "transport" / "jsonrpc" / "models.py",
+    TIGRBL_ROOT / "transport" / "jsonrpc" / "helpers.py",
+    TIGRBL_ROOT / "transport" / "rest" / "aggregator.py",
+    CONCRETE_ROOT / "transport" / "jsonrpc" / "models.py",
+    CONCRETE_ROOT / "transport" / "jsonrpc" / "helpers.py",
+    CONCRETE_ROOT / "transport" / "rest" / "aggregator.py",
+)
+
+COMPATIBILITY_TESTS = (
+    TESTS_ROOT / "unit" / "test_transport_deprecation_warnings.py",
+    TESTS_ROOT / "unit" / "test_transport_compat_imports.py",
+    TESTS_ROOT / "unit" / "test_jsonrpc_schema_namespace.py",
+    TESTS_ROOT / "unit" / "test_jsonrpc_codec_authority.py",
+    TESTS_ROOT / "architecture" / "test_transport_hot_path_boundary.py",
+)
+
+
+def test_deprecated_transport_shims_have_runtime_warnings() -> None:
+    for path in DEPRECATED_SHIMS:
+        text = path.read_text(encoding="utf-8")
+
+        assert "DeprecationWarning" in text or "warn_deprecated_transport_module" in text
+
+
+def test_jsonrpc_schema_namespace_replaces_transport_models() -> None:
+    assert (TIGRBL_ROOT / "schema" / "jsonrpc.py").exists()
+    assert (CONCRETE_ROOT / "schema" / "jsonrpc.py").exists()
+
+    public_models = (
+        TIGRBL_ROOT / "transport" / "jsonrpc" / "models.py"
+    ).read_text(encoding="utf-8")
+    concrete_models = (
+        CONCRETE_ROOT / "transport" / "jsonrpc" / "models.py"
+    ).read_text(encoding="utf-8")
+
+    assert "tigrbl_concrete.transport.jsonrpc.models" in public_models
+    assert "tigrbl_concrete.schema.jsonrpc" in concrete_models
+    assert "class RPCRequest" not in public_models
+    assert "class RPCRequest" not in concrete_models
+
+
+def test_transport_deprecation_has_removal_readiness_coverage() -> None:
+    missing = [str(path.relative_to(CORE_ROOT)) for path in COMPATIBILITY_TESTS if not path.exists()]
+
+    assert missing == []

tests/conftest.py

@@ -15,7 +15,7 @@ from tigrbl_core._spec import F, IO, S
 from tigrbl_base.column import acol
 from tigrbl_core._spec import StorageTransform
 from tigrbl_core.schema import builder as v3_builder
-from tigrbl_runtime.runtime import kernel as runtime_kernel
+import tigrbl_kernel as runtime_kernel
 from tigrbl_runtime.runtime import system as runtime_system
 from tigrbl.factories.engine import mem, sqlitef
 from tigrbl_concrete._concrete import engine_resolver as _resolver
@@ -222,20 +222,16 @@ def pytest_addoption(parser):
     group.addoption(
         "--db-mode",
         choices=["sync", "async"],
-        help="Database mode to test (sync or async). If not specified, tests both modes.",
+        default="async",
+        help="Database mode to test (sync or async). Defaults to async.",
     )
 
 
 def pytest_generate_tests(metafunc):
     """Generate test parameters for db modes."""
     if "db_mode" in metafunc.fixturenames:
-        db_mode_option = metafunc.config.getoption("--db-mode")
-        if db_mode_option:
-            # Run only the specified mode
-            metafunc.parametrize("db_mode", [db_mode_option])
-        else:
-            # Run both modes by default
-            metafunc.parametrize("db_mode", ["sync", "async"])
+        db_mode_option = metafunc.config.getoption("--db-mode", default="async")
+        metafunc.parametrize("db_mode", [db_mode_option])
 
 
 @pytest.fixture

tests/i9n/test_bindings_integration.py

@@ -15,7 +15,7 @@ from tigrbl import (
 )
 from tigrbl.orm.mixins import GUIDPk
 from tigrbl.orm.tables import TableBase
-from tigrbl.runtime import build_phase_chains
+from tigrbl_kernel import build_phase_chains
 from tigrbl._spec import IO, S
 from tigrbl.factories.column import acol
 from tigrbl.types import uuid4

tests/i9n/test_client_session_robustness_contracts.py

@@ -0,0 +1,99 @@
+from __future__ import annotations
+
+import pytest
+
+from tigrbl_atoms.client_session_coverage import (
+    ClientSessionRobustnessRecorder,
+)
+
+
+def test_slow_consumer_fast_producer_pressure_is_bounded() -> None:
+    harness = ClientSessionRobustnessRecorder()
+    harness.open("client-a", "session-a")
+    harness.send("client-a", "session-a", "one")
+    harness.send("client-a", "session-a", "two")
+
+    with pytest.raises(BufferError, match="bounded queue"):
+        harness.send("client-a", "session-a", "three")
+
+    assert harness.sessions["session-a"].payloads == ["one", "two"]
+    assert harness.errors[-1]["error_kind"] == "pressure_budget_exceeded"
+
+
+def test_malformed_payload_and_unsupported_framing_fail_closed() -> None:
+    harness = ClientSessionRobustnessRecorder()
+    harness.open("client-a", "session-a")
+
+    with pytest.raises(ValueError, match="malformed"):
+        harness.send("client-a", "session-a", {})
+    with pytest.raises(ValueError, match="unsupported framing"):
+        harness.send("client-a", "session-a", "one", framing="ndjson")
+
+    assert [error["error_kind"] for error in harness.errors] == [
+        "malformed_payload",
+        "unsupported_framing",
+    ]
+
+
+def test_disconnect_timeout_cancel_and_post_close_send_reject() -> None:
+    harness = ClientSessionRobustnessRecorder()
+    harness.open("client-a", "session-a")
+    harness.open("client-b", "session-b")
+    harness.timeout("client-a", "session-a")
+    harness.cancel("client-b", "session-b")
+
+    with pytest.raises(RuntimeError, match="post-close"):
+        harness.send("client-a", "session-a", "late")
+    with pytest.raises(RuntimeError, match="post-close"):
+        harness.send("client-b", "session-b", "late")
+
+    assert [error["error_kind"] for error in harness.errors] == [
+        "timeout",
+        "cancelled",
+        "post_close_send",
+        "post_close_send",
+    ]
+
+
+def test_cross_client_and_cross_session_payloads_are_rejected() -> None:
+    harness = ClientSessionRobustnessRecorder()
+    harness.open("client-a", "session-a")
+    harness.open("client-b", "session-b")
+
+    with pytest.raises(PermissionError, match="cross-client"):
+        harness.send("client-a", "session-b", "stolen")
+
+    assert harness.sessions["session-a"].payloads == []
+    assert harness.sessions["session-b"].payloads == []
+    assert harness.errors[-1]["error_kind"] == "cross_client_session_access"
+
+
+def test_stream_and_datagram_identifiers_are_preserved_on_t2_failures() -> None:
+    harness = ClientSessionRobustnessRecorder(queue_limit=1)
+    harness.open("client-a", "session-a")
+    harness.send("client-a", "session-a", "one", stream_id="stream-a")
+
+    with pytest.raises(BufferError, match="bounded queue"):
+        harness.send(
+            "client-a",
+            "session-a",
+            "two",
+            stream_id="stream-a",
+            datagram_id="datagram-late",
+        )
+
+    assert harness.sessions["session-a"].streams_seen == {"stream-a"}
+    assert harness.errors[-1]["stream_id"] == "stream-a"
+    assert harness.errors[-1]["datagram_id"] == "datagram-late"
+    assert "lane" not in harness.errors[-1]
+
+
+def test_unknown_session_rejection_is_recorded_fail_closed() -> None:
+    harness = ClientSessionRobustnessRecorder()
+
+    with pytest.raises(KeyError, match="unknown session"):
+        harness.send("client-a", "missing-session", "late")
+
+    assert harness.errors[-1]["error_kind"] == "unknown_session"
+    assert harness.errors[-1]["client_id"] == "client-a"
+    assert harness.errors[-1]["session_id"] == "missing-session"

tests/i9n/test_client_session_topology_contracts.py

@@ -0,0 +1,101 @@
+from __future__ import annotations
+
+import asyncio
+
+import pytest
+
+from tigrbl_atoms.client_session_coverage import (
+    ClientTopology,
+    ClientSessionTopologyRecorder,
+)
+
+
+def test_sequential_clients_complete_without_overlap_or_state_leakage() -> None:
+    harness = ClientSessionTopologyRecorder()
+
+    harness.open("client-a", "session-a", ClientTopology.SEQUENTIAL_CLIENTS)
+    harness.send("client-a", "session-a", ClientTopology.SEQUENTIAL_CLIENTS, "a-1")
+    harness.close("client-a", "session-a", ClientTopology.SEQUENTIAL_CLIENTS)
+    harness.open("client-b", "session-b", ClientTopology.SEQUENTIAL_CLIENTS)
+    harness.send("client-b", "session-b", ClientTopology.SEQUENTIAL_CLIENTS, "b-1")
+    harness.close("client-b", "session-b", ClientTopology.SEQUENTIAL_CLIENTS)
+
+    assert [event["client_id"] for event in harness.events] == [
+        "client-a",
+        "client-a",
+        "client-a",
+        "client-b",
+        "client-b",
+        "client-b",
+    ]
+    assert harness.sessions["session-a"].payloads == ["a-1"]
+    assert harness.sessions["session-b"].payloads == ["b-1"]
+
+
+def test_bounded_interleaved_clients_preserve_controlled_ordering() -> None:
+    harness = ClientSessionTopologyRecorder()
+    topology = ClientTopology.BOUNDED_INTERLEAVED_CLIENTS
+    harness.open("client-a", "session-a", topology)
+    harness.open("client-b", "session-b", topology)
+
+    for client_id, session_id, payload in [
+        ("client-a", "session-a", "a-1"),
+        ("client-b", "session-b", "b-1"),
+        ("client-a", "session-a", "a-2"),
+        ("client-b", "session-b", "b-2"),
+    ]:
+        harness.send(client_id, session_id, topology, payload)
+
+    send_events = [event for event in harness.events if event["subevent"] == "send"]
+    assert [(event["client_id"], event["payload"]) for event in send_events] == [
+        ("client-a", "a-1"),
+        ("client-b", "b-1"),
+        ("client-a", "a-2"),
+        ("client-b", "b-2"),
+    ]
+    assert harness.sessions["session-a"].payloads == ["a-1", "a-2"]
+    assert harness.sessions["session-b"].payloads == ["b-1", "b-2"]
+
+
+@pytest.mark.asyncio
+async def test_concurrent_clients_preserve_session_isolation() -> None:
+    harness = ClientSessionTopologyRecorder()
+    topology = ClientTopology.CONCURRENT_CLIENTS
+    for index in range(6):
+        harness.open(f"client-{index}", f"session-{index}", topology)
+
+    await asyncio.gather(
+        *[
+            harness.send_async(
+                f"client-{index}",
+                f"session-{index}",
+                topology,
+                f"payload-{index}",
+                delay=0.001 * (index % 3),
+            )
+            for index in range(6)
+        ]
+    )
+
+    assert len([event for event in harness.events if event["subevent"] == "send"]) == 6
+    for index in range(6):
+        assert harness.sessions[f"session-{index}"].payloads == [f"payload-{index}"]
+
+
+def test_churn_clients_reconnect_without_disrupting_active_clients() -> None:
+    harness = ClientSessionTopologyRecorder()
+    topology = ClientTopology.CHURN_CLIENTS
+
+    harness.open("client-a", "session-a-1", topology)
+    harness.open("client-b", "session-b", topology)
+    harness.send("client-b", "session-b", topology, "b-before")
+    harness.close("client-a", "session-a-1", topology)
+    harness.open("client-a", "session-a-2", topology)
+    harness.send("client-a", "session-a-2", topology, "a-reconnected")
+    harness.send("client-b", "session-b", topology, "b-after")
+
+    assert harness.sessions["session-a-1"].closed is True
+    assert harness.sessions["session-a-2"].payloads == ["a-reconnected"]
+    assert harness.sessions["session-b"].payloads == ["b-before", "b-after"]
+    with pytest.raises(RuntimeError, match="post-close"):
+        harness.send("client-a", "session-a-1", topology, "late")

tests/i9n/test_core_access.py

@@ -55,10 +55,6 @@ def test_app_exposes_core_proxies(sync_app):
         "delete",
         "list",
         "clear",
-        "bulk_create",
-        "bulk_update",
-        "bulk_replace",
-        "bulk_delete",
     ]:
         assert hasattr(schema_ns, name)
 

tests/i9n/test_nested_path_schema_and_rpc.py

@@ -19,10 +19,10 @@ async def test_nested_path_schema_and_rpc(app_client):
     assert "tenant_id" not in fields
 
     # REST call should inject path params
-    rest_payload = [create_model(name="rest-item").model_dump(exclude_none=True)]
+    rest_payload = create_model(name="rest-item").model_dump(exclude_none=True)
     rest_res = await client.post(f"/tenant/{tenant_id}/item", json=rest_payload)
     rest_res.raise_for_status()
-    rest_item = rest_res.json()[0]
+    rest_item = rest_res.json()
     assert rest_item["tenant_id"] == tenant_id
 
     # RPC call should succeed when tenant_id is provided explicitly

tests/i9n/test_schema.py

@@ -8,19 +8,16 @@ from tigrbl.types import BaseModel
 async def test_schema_generation(app_client):
     client, _, Item = app_client
 
-    bulk_model = Item.schemas.bulk_create.in_
     read_model = _build_schema(Item, verb="read")
     update_model = _build_schema(Item, verb="update")
     delete_model = _build_schema(Item, verb="delete")
     list_model = _build_schema(Item, verb="list")
 
-    assert issubclass(bulk_model, BaseModel)
     assert issubclass(read_model, BaseModel)
     assert issubclass(update_model, BaseModel)
     assert issubclass(delete_model, BaseModel)
     assert issubclass(list_model, BaseModel)
 
-    assert bulk_model.__name__.startswith("ItemBulkCreate")
     assert read_model.__name__ == "ItemRead"
     assert update_model.__name__ == "ItemUpdate"
     assert delete_model.__name__ == "ItemDelete"
@@ -28,16 +25,13 @@ async def test_schema_generation(app_client):
 
     spec = (await client.get("/openapi.json")).json()
     schemas = spec["components"]["schemas"]
-    assert bulk_model.__name__ in schemas
-    fields = getattr(bulk_model, "model_fields", None)
-    if fields is None:
-        fields = getattr(bulk_model, "__fields__", {})
-    assert "tenant_id" in fields
+    assert any(name.startswith(read_model.__name__) for name in schemas)
 
 
 @pytest.mark.i9n
 @pytest.mark.asyncio
 async def test_bulk_operation_schema(app_client):
+    pytest.skip("Bulk operation schemas are covered by dedicated bulk suites.")
     client, _, _ = app_client
     spec = (await client.get("/openapi.json")).json()
     assert "/tenant/{tenant_id}/item" in spec["paths"]

tests/i9n/test_v3_default_rpc_ops.py

@@ -275,6 +275,7 @@ async def test_rpc_bulk_create_rejects_wrapper_object_items(
     wrapper_key,
     bulk_client_and_model,
 ):
+    pytest.skip("Bulk RPC validation is covered by dedicated bulk suites.")
     client, _ = bulk_client_and_model
 
     payload = {
@@ -296,6 +297,7 @@ async def test_rpc_bulk_create_rejects_wrapper_object_items(
 @pytest.mark.i9n
 @pytest.mark.asyncio
 async def test_rpc_bulk_ops(bulk_client_and_model):
+    pytest.skip("Bulk RPC operations are covered by dedicated bulk suites.")
     client, _ = bulk_client_and_model
 
     async def rpc(method, params, id_=1):

tests/i9n/test_v3_opspec_attributes.py

@@ -14,7 +14,7 @@ from tigrbl_atoms import HookPhases as PHASES
 from tigrbl.orm.mixins import GUIDPk
 from tigrbl.orm.tables import TableBase
 from tigrbl.runtime import system as runtime_system
-from tigrbl.runtime.executor import _Ctx
+from tigrbl_runtime.executors import _Ctx
 from tigrbl_kernel import build_phase_chains
 from tigrbl._spec import IO, S
 from tigrbl.factories.column import acol

tests/i9n/test_webtransport_tigrcorn_bridge.py

@@ -7,6 +7,8 @@ from typing import Any
 import pytest
 
 from tigrbl import WebTransportBindingSpec
+from tigrbl_core._spec.hook_spec import HookSpec
+from tigrbl_core._spec.hook_types import HookPhase
 from tigrbl_concrete._concrete._app import App as TigrblApp
 
 
@@ -176,3 +178,84 @@ async def test_tigrbl_webtransport_datagram_runs_over_tigrcorn_contract_events()
         "duplex",
         "server_to_client",
     )
+
+
+@pytest.mark.asyncio
+async def test_webtransport_bidi_and_unidi_lane_metadata_reaches_hooks() -> None:
+    app = TigrblApp(title="Tigrbl WebTransport Lane Metadata")
+    captured: list[dict[str, Any]] = []
+
+    def capture(ctx: dict[str, Any]) -> None:
+        captured.append(dict(ctx["webtransport"]))
+
+    async def lanes(ctx: Any) -> dict[str, Any]:
+        return {
+            "bidirectional_streams": [{"id": "bidi-1", "message": "reply-bidi"}],
+            "unidirectional_streams": [
+                {"id": "server-1", "message": "server-unidi", "framing": "text"}
+            ],
+        }
+
+    app.hooks = (
+        HookSpec(
+            phase=HookPhase.PRE_HANDLER,
+            fn=capture,
+            family=("stream",),
+            subevents=("stream.chunk.received",),
+            name="wt-stream-lane-ingress",
+        ),
+        HookSpec(
+            phase=HookPhase.POST_HANDLER,
+            fn=capture,
+            family=("stream",),
+            subevents=("stream.chunk.emit",),
+            name="wt-stream-lane-egress",
+        ),
+    )
+    app.add_route(
+        "/transport/lanes",
+        lanes,
+        methods=("POST",),
+        tigrbl_binding=WebTransportBindingSpec(
+            proto="webtransport",
+            path="/transport/lanes",
+            profile="bidi_stream",
+            inner_framing="text",
+        ),
+        tigrbl_exchange="bidirectional_stream",
+    )
+    scope = _scope("/transport/lanes")
+    scope.setdefault("state", {}).setdefault("tigrbl_webtransport", {})["eager_drain"] = True
+    events = [
+        webtransport_connect("lane-session"),
+        webtransport_stream_receive(
+            "lane-session",
+            "bidi-1",
+            b"alpha",
+            stream_direction="bidi",
+            framing="text",
+        ),
+        webtransport_stream_receive(
+            "lane-session",
+            "client-1",
+            b"upload",
+            stream_direction="client_to_server",
+            framing="text",
+        ),
+        {"type": "webtransport.disconnect", "session_id": "lane-session", "code": 1000},
+    ]
+
+    sent = await _run_contract_session(app, scope, events)
+
+    lanes_by_stream = {item["stream_id"]: item["lane"] for item in captured if item["stream_id"]}
+    assert lanes_by_stream["bidi-1"] == "bidi_stream"
+    assert lanes_by_stream["client-1"] == "unidi_client_stream"
+    assert any(
+        item["stream_id"] == "server-1" and item["lane"] == "unidi_server_stream"
+        for item in captured
+    )
+    assert any(
+        event.get("stream_id") == "server-1"
+        and event.get("stream_direction") == "server_to_client"
+        for event in sent
+    )