tigrbl_tests 0.3.23.dev1__tar.gz → 0.3.24__tar.gz

{tigrbl_tests-0.3.23.dev1 → tigrbl_tests-0.3.24}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tigrbl_tests
-Version: 0.3.23.dev1
+Version: 0.3.24
 Summary: Test suite and fixtures for the Tigrbl framework.
 License-Expression: Apache-2.0
 License-File: LICENSE
@@ -32,6 +32,9 @@ Requires-Dist: requests (>=2.32.3)
 Requires-Dist: ruff (>=0.9.9)
 Requires-Dist: tigrbl
 Requires-Dist: tigrbl_client
+Project-URL: Homepage, https://github.com/swarmauri/tigrbl
+Project-URL: Issues, https://github.com/swarmauri/tigrbl/issues
+Project-URL: Repository, https://github.com/swarmauri/tigrbl/tree/main/pkgs/core/tigrbl_tests
 Description-Content-Type: text/markdown
 
 # tigrbl_tests

{tigrbl_tests-0.3.23.dev1 → tigrbl_tests-0.3.24}/pyproject.toml

@@ -1,10 +1,9 @@
 [project]
 name = "tigrbl_tests"
-version = "0.3.23.dev1"
+version = "0.3.24"
 description = "Test suite and fixtures for the Tigrbl framework."
 license = "Apache-2.0"
 readme = "README.md"
-repository = "http://github.com/swarmauri/swarmauri-sdk"
 requires-python = ">=3.10,<3.14"
 classifiers = [
     "Development Status :: 1 - Planning",
@@ -18,6 +17,7 @@ classifiers = [
     "Programming Language :: Python :: 3 :: Only",
 ]
 authors = [{ name = "Jacob Stewart", email = "jacob@swarmauri.com" }]
+
 dependencies = [
     "tigrbl",
     "tigrbl_client",
@@ -46,6 +46,12 @@ keywords = [
     "performance",
 ]
 
+
+[project.urls]
+Homepage = "https://github.com/swarmauri/tigrbl"
+Repository = "https://github.com/swarmauri/tigrbl/tree/main/pkgs/core/tigrbl_tests"
+Issues = "https://github.com/swarmauri/tigrbl/issues"
+
 [tool.uv.sources]
 tigrbl = { workspace = true }
 tigrbl_client = { workspace = true }

tigrbl_tests-0.3.24/tests/fixtures/system_diagnostics.py

@@ -0,0 +1,100 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from types import SimpleNamespace
+from typing import Any
+
+from sqlalchemy import Column, String
+
+from tigrbl import Request, TigrblApp
+from tigrbl.factories.engine import mem
+from tigrbl.orm.mixins import GUIDPk
+from tigrbl.orm.tables import TableBase
+from tigrbl.system.diagnostics import mount_diagnostics
+
+
+class SystemDiagnosticsFixtureWidget(TableBase, GUIDPk):
+    __tablename__ = "system_diagnostics_fixture_widgets"
+
+    name = Column(String, nullable=False)
+
+
+class UnavailableDiagnosticsDb:
+    def execute(self, *_args: Any, **_kwargs: Any) -> None:
+        raise RuntimeError("fixture database unavailable")
+
+
+class AvailableDiagnosticsDb:
+    def execute(self, *_args: Any, **_kwargs: Any) -> None:
+        return None
+
+
+@dataclass(frozen=True)
+class SystemDiagnosticsFixture:
+    app: TigrblApp
+    healthz_path: str
+    absent_default_path: str
+    expected_healthz_payload: dict[str, bool]
+    warning_vocabulary: frozenset[str]
+
+    def request(
+        self,
+        path: str | None = None,
+        *,
+        db: Any | None = None,
+        dbs: dict[str, Any] | None = None,
+        query: dict[str, list[str]] | None = None,
+    ) -> Request:
+        state = SimpleNamespace()
+        if db is not None:
+            state.db = db
+        if dbs is not None:
+            state.dbs = dbs
+        return Request(
+            method="GET",
+            path=path or self.healthz_path,
+            headers={},
+            query=query or {},
+            path_params={},
+            body=b"",
+            state=state,
+        )
+
+    def available_db_request(self) -> Request:
+        return self.request(db=AvailableDiagnosticsDb())
+
+    def unavailable_db_request(self) -> Request:
+        return self.request(db=UnavailableDiagnosticsDb())
+
+    def multi_db_request(self, *, detail: str | None = None) -> Request:
+        query = {"dbs": [detail]} if detail is not None else {}
+        return self.request(
+            dbs={
+                "primary": AvailableDiagnosticsDb(),
+                "analytics": AvailableDiagnosticsDb(),
+                "archive": UnavailableDiagnosticsDb(),
+            },
+            query=query,
+        )
+
+    def no_db_warning_request(self) -> Request:
+        return self.request(query={"warn_no_db": ["1"]})
+
+
+def build_system_diagnostics_fixture(
+    *,
+    prefix: str = "/internal",
+) -> SystemDiagnosticsFixture:
+    app = TigrblApp(engine=mem(async_=False), mount_system=False)
+    app.include_table(SystemDiagnosticsFixtureWidget)
+    app.initialize()
+    app.mount_jsonrpc()
+    app.include_router(mount_diagnostics(app), prefix=prefix)
+
+    return SystemDiagnosticsFixture(
+        app=app,
+        healthz_path=f"{prefix.rstrip('/')}/healthz",
+        absent_default_path="/system/healthz",
+        expected_healthz_payload={"ok": True},
+        warning_vocabulary=frozenset({"db-not-configured", "db-unavailable"}),
+    )

{tigrbl_tests-0.3.23.dev1 → tigrbl_tests-0.3.24}/tests/harness/test_04_appspec_corpus_fixture.py

@@ -1,5 +1,7 @@
 from __future__ import annotations
 
+from copy import deepcopy
+
 from sqlalchemy import Column, String
 import pytest
 
@@ -44,6 +46,57 @@ def test_appspec_corpus_fixture_schema_and_ids(filename: str, lane: str) -> None
     validate_corpus(corpus, lane=lane)
 
 
+@pytest.mark.acceptance
+def test_canonical_corpus_cases_have_unique_routes_tables_and_modes() -> None:
+    corpus = load_corpus("appspec_corpus.canonical.json")
+    validate_corpus(corpus, lane="canonical")
+
+    case_ids = [case["id"] for case in corpus["cases"]]
+    table_names = [case["table"]["tablename"] for case in corpus["cases"]]
+    modes = [case["mode"] for case in corpus["cases"]]
+
+    assert len(case_ids) == len(set(case_ids))
+    assert len(table_names) == len(set(table_names))
+    assert set(modes) == {"rest_rpc_parity", "rest_rpc_roundtrip"}
+
+
+@pytest.mark.acceptance
+def test_canonical_corpus_compilation_is_deterministic() -> None:
+    corpus = load_corpus("appspec_corpus.canonical.json")
+    validate_corpus(corpus, lane="canonical")
+    case = corpus["cases"][0]
+
+    def compile_signature() -> tuple[str, str, tuple[str | None, ...]]:
+        widget = _make_widget_model(
+            tablename=case["table"]["tablename"],
+            resource=case["table"]["resource"],
+            include_jsonrpc=True,
+        )
+        spec = AppSpec(
+            title=case["app"]["title"],
+            version=case["app"]["version"],
+            engine=mem(async_=False),
+            tables=(widget,),
+            jsonrpc_prefix=case["app"]["jsonrpc_prefix"],
+            system_prefix=case["app"]["system_prefix"],
+        )
+        app = TigrblApp.from_spec(spec)
+        paths = tuple(sorted(getattr(route, "path", None) for route in app.routes))
+        return app.title, app.version, paths
+
+    assert compile_signature() == compile_signature()
+
+
+@pytest.mark.acceptance
+def test_negative_corpus_rejects_duplicate_case_ids() -> None:
+    corpus = load_corpus("appspec_corpus.negative.json")
+    duplicate = deepcopy(corpus)
+    duplicate["cases"][1]["id"] = duplicate["cases"][0]["id"]
+
+    with pytest.raises(ValueError, match="duplicate case id"):
+        validate_corpus(duplicate, lane="negative")
+
+
 @pytest.mark.acceptance
 def test_canonical_corpus_materializes_rpc_mounts() -> None:
     corpus = load_corpus("appspec_corpus.canonical.json")

{tigrbl_tests-0.3.23.dev1 → tigrbl_tests-0.3.24}/tests/harness_e2e/test_01_appspec_corpus_uvicorn.py

@@ -138,3 +138,49 @@ async def test_negative_corpus_unknown_rpc_method_returns_fail_closed_contract()
         assert body.get("detail") == case["expect"]["detail"]
     finally:
         await stop_uvicorn(server, task)
+
+
+@pytest.mark.acceptance
+@pytest.mark.asyncio
+async def test_negative_corpus_no_rpc_binding_has_no_rpc_runtime_side_effect() -> None:
+    corpus = load_corpus("appspec_corpus.negative.json")
+    validate_corpus(corpus, lane="negative")
+    case = next(c for c in corpus["cases"] if c["mode"] == "no_rpc_binding_no_mount")
+
+    widget = _make_widget_model(
+        tablename=case["table"]["tablename"],
+        resource=case["table"]["resource"],
+        include_jsonrpc=False,
+    )
+    spec = AppSpec(
+        title=case["app"]["title"],
+        version=case["app"]["version"],
+        engine=mem(async_=False),
+        tables=(widget,),
+        jsonrpc_prefix=case["app"]["jsonrpc_prefix"],
+        system_prefix=case["app"]["system_prefix"],
+    )
+    app = TigrblApp.from_spec(spec)
+    port = pick_unique_port()
+    base_url, server, task = await start_uvicorn(app, port=port)
+    try:
+        async with httpx.AsyncClient(base_url=base_url, timeout=10.0) as client:
+            missing_rpc = await client.post(
+                f"{case['app']['jsonrpc_prefix']}/",
+                json={
+                    "jsonrpc": "2.0",
+                    "method": "Widget.create",
+                    "params": {"name": "should-not-execute"},
+                    "id": 44,
+                },
+            )
+            rest = await client.post(
+                f"/{case['table']['resource']}",
+                json={"name": "rest-still-works"},
+            )
+
+        assert missing_rpc.status_code == 404
+        assert missing_rpc.json()["detail"] == "No runtime operation matched request."
+        assert rest.status_code in {200, 201}
+    finally:
+        await stop_uvicorn(server, task)

{tigrbl_tests-0.3.23.dev1 → tigrbl_tests-0.3.24}/tests/harness_v3/test_bootstrap_kernel_compilation.py

@@ -48,6 +48,13 @@ def test_kernel_ensure_primed_compiles_plan_once() -> None:
     plan2 = _default_kernel.kernel_plan(app)
 
     assert plan1 is plan2
+    packed = plan1.packed
+    assert packed is not None
+    assert len(packed.atom_catalog_labels) <= len(packed.step_table)
+    assert len(packed.segment_catalog_offsets) <= len(packed.program_segment_refs)
+    assert len(packed.program_error_profile_ids) == len(plan1.opmeta)
+    assert packed.hot_block_bytes.startswith(b"TGPKHOT1")
+    assert isinstance(packed.hot_block_view, dict)
 
 
 def test_opview_is_compiled_once_per_model_alias() -> None:

{tigrbl_tests-0.3.23.dev1 → tigrbl_tests-0.3.24}/tests/hooks/test_hook_ctx_stage_validation.py

@@ -30,7 +30,7 @@ def test_hook_ctx_invalid_string_anchor_raises_immediately():
     assert "Invalid hook phase 'IN_BUILD'." in message
     assert "Valid phases are:" in message
     assert "PRE_HANDLER" in message
-    assert "ON_ROLLBACK" in message
+    assert "TX_ROLLBACK" in message
 
 
 def test_hook_ctx_valid_enum_anchor_does_not_raise():
@@ -52,4 +52,4 @@ def test_hook_ctx_invalid_enum_anchor_raises_immediately():
     assert "Invalid hook phase 'IN_BUILD'." in message
     assert "Valid phases are:" in message
     assert "PRE_HANDLER" in message
-    assert "ON_ROLLBACK" in message
+    assert "TX_ROLLBACK" in message

{tigrbl_tests-0.3.23.dev1 → tigrbl_tests-0.3.24}/tests/i9n/__init__.py

@@ -30,7 +30,7 @@ def test_hook_ctx_invalid_string_anchor_raises_immediately():
     assert "Invalid hook phase 'IN_BUILD'." in message
     assert "Valid phases are:" in message
     assert "PRE_HANDLER" in message
-    assert "ON_ROLLBACK" in message
+    assert "TX_ROLLBACK" in message
 
 
 def test_hook_ctx_valid_enum_anchor_does_not_raise():
@@ -52,5 +52,5 @@ def test_hook_ctx_invalid_enum_anchor_raises_immediately():
     assert "Invalid hook phase 'IN_BUILD'." in message
     assert "Valid phases are:" in message
     assert "PRE_HANDLER" in message
-    assert "ON_ROLLBACK" in message
+    assert "TX_ROLLBACK" in message
 

tigrbl_tests-0.3.24/tests/i9n/test_auth_status_projection_contract.py

@@ -0,0 +1,103 @@
+from __future__ import annotations
+
+from httpx import ASGITransport, Client
+from sqlalchemy.orm import sessionmaker
+
+from tigrbl import HTTPBearer, Request, TableBase, TigrblApp, TigrblRouter
+from tigrbl import resolver as _resolver
+from tigrbl._concrete._security.http_bearer import HTTPAuthorizationCredentials
+from tigrbl.decorators.allow_anon import allow_anon
+from tigrbl.factories.engine import mem
+from tigrbl.orm.mixins import GUIDPk
+from tigrbl.runtime.status import HTTPException
+from tigrbl.security import Security
+from tigrbl.types import AuthNProvider, Column, String, uuid4
+
+
+class RequiredBearerAuth(AuthNProvider):
+    async def get_principal(
+        self,
+        request: Request,
+        creds: HTTPAuthorizationCredentials = Security(HTTPBearer()),
+    ) -> dict:
+        if creds.credentials != "secret":
+            raise HTTPException(status_code=401)
+        return {"sub": "user"}
+
+
+def _client_with_required_auth() -> Client:
+    TableBase.metadata.clear()
+
+    class Secret(TableBase, GUIDPk):
+        __tablename__ = "auth_status_projection_secret"
+        name = Column(String, nullable=False)
+
+    app = TigrblApp(engine=mem(async_=False))
+    app.set_auth(authn=RequiredBearerAuth().get_principal)
+    app.include_table(Secret)
+    app.initialize()
+    return Client(transport=ASGITransport(app=app), base_url="http://test")
+
+
+def test_required_bearer_auth_projects_missing_and_wrong_credentials_statuses() -> None:
+    client = _client_with_required_auth()
+    try:
+        missing = client.get("/secret")
+        wrong = client.get(
+            "/secret", headers={"Authorization": "Bearer wrong"}
+        )
+
+        assert missing.status_code == 403
+        assert wrong.status_code == 401
+        assert "traceback" not in missing.text.lower()
+        assert "traceback" not in wrong.text.lower()
+    finally:
+        client.close()
+
+
+def test_required_bearer_auth_projects_openapi_security_for_protected_route() -> None:
+    client = _client_with_required_auth()
+    try:
+        spec = client.get("/openapi.json").json()
+        security = spec["paths"]["/secret"]["get"]["security"]
+
+        assert security == [{"HTTPBearer": []}]
+        assert spec["components"]["securitySchemes"]["HTTPBearer"] == {
+            "type": "http",
+            "scheme": "bearer",
+        }
+    finally:
+        client.close()
+
+
+def test_allow_anon_create_projects_rest_created_status_without_credentials() -> None:
+    TableBase.metadata.clear()
+
+    @allow_anon("create")
+    class PublicItem(TableBase, GUIDPk):
+        __tablename__ = "auth_status_projection_public_item"
+        name = Column(String, nullable=False)
+
+    router = TigrblRouter(engine=mem(async_=False))
+    router.include_table(PublicItem)
+    router.initialize()
+    app = TigrblApp()
+    app.include_router(router)
+    app.initialize()
+
+    provider = _resolver.resolve_provider()
+    engine, _ = provider.ensure()
+    SessionLocal = sessionmaker(bind=engine, expire_on_commit=False)
+
+    client = Client(transport=ASGITransport(app=app), base_url="http://test")
+    try:
+        payload = {"id": str(uuid4()), "name": "public"}
+        response = client.post("/publicitem", json=payload)
+        openapi = client.get("/openapi.json").json()
+
+        assert response.status_code == 201
+        assert openapi["paths"]["/publicitem"]["post"].get("security") in (None, [])
+        with SessionLocal() as db:
+            assert db.query(PublicItem).count() == 1
+    finally:
+        client.close()

{tigrbl_tests-0.3.23.dev1 → tigrbl_tests-0.3.24}/tests/i9n/test_bindings_modules.py

@@ -76,7 +76,7 @@ def test_hooks_normalize_and_attach(model_cls, specs):
     _bind_model_hooks(model_cls, tuple(specs))
     # default transactional steps are no longer injected
     assert not model_cls.hooks.create.START_TX
-    assert not model_cls.hooks.create.END_TX
+    assert not model_cls.hooks.create.TX_COMMIT
 
 
 @pytest.mark.i9n

{tigrbl_tests-0.3.23.dev1 → tigrbl_tests-0.3.24}/tests/i9n/test_op_ctx_behavior.py

@@ -389,4 +389,4 @@ def test_op_ctx_system_steps(sync_db_session):
     chains = build_phase_chains(Widget, "ping")
 
     assert chains["START_TX"]
-    assert chains["END_TX"]
+    assert chains["TX_COMMIT"]

tigrbl_tests-0.3.24/tests/i9n/test_op_ctx_owner_scope_materialization_contracts.py

@@ -0,0 +1,218 @@
+from __future__ import annotations
+
+from inspect import isawaitable
+from typing import Any
+import uuid
+
+import httpx
+import pytest
+
+from tigrbl import TigrblApp, TigrblRouter, op_ctx
+from tigrbl.factories.engine import mem
+from tigrbl.orm.mixins import GUIDPk
+from tigrbl.orm.tables import TableBase
+from tigrbl.types import BaseModel, Column, String
+
+from .uvicorn_utils import run_uvicorn_in_task, stop_uvicorn_server
+
+
+class TokenInventorySchema(BaseModel):
+    access_tokens: int
+    refresh_tokens: int
+
+
+def _payload() -> dict[str, int]:
+    return {"access_tokens": 3, "refresh_tokens": 1}
+
+
+def _table_name(prefix: str) -> str:
+    return f"{prefix}_{uuid.uuid4().hex[:8]}"
+
+
+async def _initialize(app: TigrblApp) -> None:
+    result = app.initialize()
+    if isawaitable(result):
+        await result
+
+
+async def _post_via_uvicorn(app: TigrblApp, path: str) -> httpx.Response:
+    base_url, server, task = await run_uvicorn_in_task(app)
+    try:
+        async with httpx.AsyncClient() as client:
+            return await client.post(f"{base_url}{path}", json={})
+    finally:
+        await stop_uvicorn_server(server, task)
+
+
+def _operation_paths(app: TigrblApp) -> set[str]:
+    return {getattr(route, "path", "") for route in getattr(app, "routes", ())}
+
+
+def _route_ops(app: TigrblApp) -> tuple[Any, ...]:
+    route_model = app.tables["__tigrbl_route_ops__"]
+    return tuple(getattr(getattr(route_model, "ops", None), "all", ()) or ())
+
+
+def _model_op(app: TigrblApp, model_name: str, alias: str) -> Any:
+    model = app.tables[model_name]
+    return next(
+        spec
+        for spec in tuple(getattr(getattr(model, "ops", None), "all", ()) or ())
+        if getattr(spec, "alias", "") == alias
+    )
+
+
+@pytest.mark.i9n
+@pytest.mark.asyncio
+async def test_table_owned_op_ctx_materializes_through_include_table_and_executes_under_uvicorn() -> None:
+    TableBase.metadata.clear()
+
+    class Inventory(TableBase, GUIDPk):
+        __tablename__ = _table_name("owner_scope_table_inventory")
+        __resource__ = "inventory"
+        name = Column(String)
+
+        @op_ctx(
+            alias="token_inventory",
+            target="custom",
+            arity="collection",
+            response_schema=TokenInventorySchema,
+            persist="skip",
+        )
+        def token_inventory(cls, ctx):
+            return _payload()
+
+    app = TigrblApp(engine=mem(async_=False))
+    app.include_table(Inventory, prefix="")
+    await _initialize(app)
+
+    assert "/inventory/token_inventory" in _operation_paths(app)
+    assert "/inventory/token_inventory" in app.openapi()["paths"]
+    assert "TokenInventorySchema" in app.openapi()["components"]["schemas"]
+
+    response = await _post_via_uvicorn(app, "/inventory/token_inventory")
+
+    assert response.status_code == 200
+    assert response.json() == _payload()
+
+
+@pytest.mark.i9n
+@pytest.mark.asyncio
+async def test_router_owned_projection_preserves_table_op_ctx_semantics_and_mount_prefix() -> None:
+    TableBase.metadata.clear()
+
+    class Inventory(TableBase, GUIDPk):
+        __tablename__ = _table_name("owner_scope_router_inventory")
+        __resource__ = "inventory"
+        name = Column(String)
+
+        @op_ctx(
+            alias="token_inventory",
+            target="custom",
+            arity="collection",
+            response_schema=TokenInventorySchema,
+            persist="skip",
+        )
+        def token_inventory(cls, ctx):
+            return _payload()
+
+    router = TigrblRouter(engine=mem(async_=False))
+    router.include_table(Inventory, prefix="")
+    router_init = router.initialize()
+    if isawaitable(router_init):
+        await router_init
+
+    app = TigrblApp(engine=mem(async_=False))
+    app.include_router(router, prefix="/tenant")
+    await _initialize(app)
+
+    token_op = _model_op(app, "Inventory", "token_inventory")
+    binding = token_op.bindings[0]
+
+    assert "/tenant/inventory/token_inventory" in _operation_paths(app)
+    assert binding.path == "/tenant/inventory/token_inventory"
+    assert token_op.response_model is TokenInventorySchema
+    assert token_op.persist == "skip"
+
+    response = await _post_via_uvicorn(app, "/tenant/inventory/token_inventory")
+
+    assert response.status_code == 200
+    assert response.json() == _payload()
+
+
+@pytest.mark.i9n
+@pytest.mark.asyncio
+async def test_app_local_op_ctx_materializes_without_table_owner_and_executes_under_uvicorn() -> None:
+    TableBase.metadata.clear()
+
+    class InventoryApp(TigrblApp):
+        @op_ctx(
+            alias="token_inventory",
+            target="custom",
+            arity="collection",
+            response_schema=TokenInventorySchema,
+            persist="skip",
+        )
+        def token_inventory(cls, ctx):
+            return _payload()
+
+    app = InventoryApp(engine=mem(async_=False))
+    await _initialize(app)
+
+    token_op = _model_op(app, "InventoryApp", "token_inventory")
+
+    assert "/inventoryapp/token_inventory" in _operation_paths(app)
+    assert "/inventoryapp/token_inventory" in app.openapi()["paths"]
+    assert token_op.table is InventoryApp
+    assert token_op.response_model is TokenInventorySchema
+
+    response = await _post_via_uvicorn(app, "/inventoryapp/token_inventory")
+
+    assert response.status_code == 200
+    assert response.json() == _payload()
+
+
+@pytest.mark.i9n
+@pytest.mark.asyncio
+async def test_owner_scope_member_arity_uses_member_route_shape_across_table_router_and_app() -> None:
+    TableBase.metadata.clear()
+
+    class TableScoped(TableBase, GUIDPk):
+        __tablename__ = _table_name("owner_scope_member_table")
+        __resource__ = "table_inventory"
+        name = Column(String)
+
+        @op_ctx(alias="inspect", target="custom", arity="member", persist="skip")
+        def inspect(cls, ctx):
+            return {"scope": "table"}
+
+    class RouterScoped(TableBase, GUIDPk):
+        __tablename__ = _table_name("owner_scope_member_router")
+        __resource__ = "router_inventory"
+        name = Column(String)
+
+        @op_ctx(alias="inspect", target="custom", arity="member", persist="skip")
+        def inspect(cls, ctx):
+            return {"scope": "router"}
+
+    class AppScoped(TigrblApp):
+        @op_ctx(alias="inspect", target="custom", arity="member", persist="skip")
+        def inspect(cls, ctx):
+            return {"scope": "app"}
+
+    router = TigrblRouter(engine=mem(async_=False))
+    router.include_table(RouterScoped, prefix="")
+    router_init = router.initialize()
+    if isawaitable(router_init):
+        await router_init
+
+    app = AppScoped(engine=mem(async_=False))
+    app.include_table(TableScoped, prefix="")
+    app.include_router(router, prefix="/mounted")
+    await _initialize(app)
+
+    paths = _operation_paths(app)
+
+    assert "/table_inventory/{item_id}/inspect" in paths
+    assert "/mounted/router_inventory/{item_id}/inspect" in paths
+    assert "/appscoped/{item_id}/inspect" in paths

tigrbl_tests-0.3.24/tests/parity/test_atom_parity_corpus.py

@@ -0,0 +1,29 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+
+ROOT = Path(__file__).resolve().parents[5]
+
+
+def test_atom_parity_corpus_covers_every_generated_feature() -> None:
+    inventory = json.loads((ROOT / ".ssot/reports/python-rust-atom-parity-inventory.json").read_text(encoding="utf-8"))
+    results = json.loads((ROOT / ".ssot/reports/python-rust-atom-parity-results.json").read_text(encoding="utf-8"))
+
+    by_atom = {item["atom_id"]: item for item in results["results"]}
+    assert results["status"] == "passed"
+    assert set(by_atom) == {item["id"] for item in inventory["units"]}
+    assert all(item["checks"]["inventory_tracked"] for item in by_atom.values())
+    assert all(item["checks"]["feature_mapped"] for item in by_atom.values())
+    assert all(item["checks"]["runtime_lanes_declared"] for item in by_atom.values())
+
+
+def test_matched_atoms_are_marked_for_semantic_pair_checks() -> None:
+    inventory = json.loads((ROOT / ".ssot/reports/python-rust-atom-parity-inventory.json").read_text(encoding="utf-8"))
+    results = json.loads((ROOT / ".ssot/reports/python-rust-atom-parity-results.json").read_text(encoding="utf-8"))
+
+    matched = {item["id"] for item in inventory["units"] if item["state"] == "matched"}
+    checked = {item["atom_id"] for item in results["results"] if item["checks"]["semantic_pair_required"]}
+    assert matched
+    assert checked == matched