tigrbl_tests 0.3.8.dev1__tar.gz → 0.3.9__tar.gz

{tigrbl_tests-0.3.8.dev1 → tigrbl_tests-0.3.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tigrbl_tests
-Version: 0.3.8.dev1
+Version: 0.3.9
 Summary: Test suite and fixtures for the Tigrbl framework.
 License-Expression: Apache-2.0
 License-File: LICENSE

{tigrbl_tests-0.3.8.dev1 → tigrbl_tests-0.3.9}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "tigrbl_tests"
-version = "0.3.8.dev1"
+version = "0.3.9"
 description = "Test suite and fixtures for the Tigrbl framework."
 license = "Apache-2.0"
 readme = "README.md"

tigrbl_tests-0.3.9/tests/i9n/test_mountable_favicon_uvicorn.py

@@ -0,0 +1,51 @@
+import httpx
+import pytest
+
+from tigrbl import TigrblApi, TigrblApp
+from tigrbl.system import mount_favicon
+
+from .uvicorn_utils import run_uvicorn_in_task, stop_uvicorn_server
+
+
+@pytest.mark.i9n
+@pytest.mark.asyncio
+async def test_favicon_mountable_on_tigrbl_app_uvicorn():
+    app = TigrblApp()
+    mount_favicon(app, path="/custom/favicon.svg", name="favicon_custom")
+
+    base_url, server, task = await run_uvicorn_in_task(app)
+    try:
+        async with httpx.AsyncClient() as client:
+            svg_response = await client.get(f"{base_url}/custom/favicon.svg")
+            ico_response = await client.get(
+                f"{base_url}/favicon.ico", follow_redirects=False
+            )
+        assert svg_response.status_code == 200
+        assert svg_response.headers.get("content-type") == "image/svg+xml"
+        assert svg_response.content
+        assert ico_response.status_code == 307
+        assert ico_response.headers.get("location") == "/custom/favicon.svg"
+    finally:
+        await stop_uvicorn_server(server, task)
+
+
+@pytest.mark.i9n
+@pytest.mark.asyncio
+async def test_favicon_mountable_on_tigrbl_api_uvicorn():
+    api = TigrblApi()
+    mount_favicon(api, path="/custom/favicon.svg", name="favicon_custom")
+
+    base_url, server, task = await run_uvicorn_in_task(api)
+    try:
+        async with httpx.AsyncClient() as client:
+            svg_response = await client.get(f"{base_url}/custom/favicon.svg")
+            ico_response = await client.get(
+                f"{base_url}/favicon.ico", follow_redirects=False
+            )
+        assert svg_response.status_code == 200
+        assert svg_response.headers.get("content-type") == "image/svg+xml"
+        assert svg_response.content
+        assert ico_response.status_code == 307
+        assert ico_response.headers.get("location") == "/custom/favicon.svg"
+    finally:
+        await stop_uvicorn_server(server, task)

{tigrbl_tests-0.3.8.dev1 → tigrbl_tests-0.3.9}/tests/i9n/test_mountable_lens_uvicorn.py

@@ -22,11 +22,11 @@ async def test_lens_mountable_on_tigrbl_app_uvicorn():
         assert 'id="root"' in response.text
         assert 'type="importmap"' in response.text
         assert (
-            '"@tigrbljs/tigrbl-lens": "https://esm.sh/@tigrbljs/tigrbl-lens@0.0.14"'
+            '"@tigrbljs/tigrbl-lens": "https://esm.sh/@tigrbljs/tigrbl-lens@latest"'
             in response.text
         )
         assert (
-            'href="https://esm.sh/@tigrbljs/tigrbl-lens@0.0.14/dist/tigrbl-lens.css"'
+            'href="https://esm.sh/@tigrbljs/tigrbl-lens@latest/dist/tigrbl-lens.css"'
             in response.text
         )
         assert 'import { createRoot } from "react-dom/client";' in response.text

tigrbl_tests-0.3.9/tests/mount/test_mount_favico.py

@@ -0,0 +1,114 @@
+"""Focused mount tests for bound ``mount_favicon`` helpers.
+
+These tests verify both ``TigrblApp`` and ``TigrblApi`` expose the system
+mount method directly, with SVG redirect and ICO file fallback behavior intact.
+"""
+
+from pathlib import Path
+
+import pytest
+from httpx import ASGITransport, AsyncClient
+
+from tigrbl import TigrblApi, TigrblApp
+
+
+class TestMountFaviconOnTigrblApp:
+    """Validate favicon mounting behavior for ``TigrblApp`` instances."""
+
+    @pytest.mark.asyncio
+    async def test_mount_favicon_svg_route_and_ico_redirect(self) -> None:
+        """The default mount serves ``/favicon.svg`` and redirects ``/favicon.ico``."""
+        app = TigrblApp()
+        app.mount_favicon(name="favicon_default_route")
+
+        transport = ASGITransport(app=app)
+        async with AsyncClient(transport=transport, base_url="http://test") as client:
+            svg_response = await client.get("/favicon.svg")
+            ico_response = await client.get("/favicon.ico", follow_redirects=False)
+
+        assert svg_response.status_code == 200
+        assert svg_response.headers["content-type"].startswith("image/svg+xml")
+        assert svg_response.content
+
+        assert ico_response.status_code == 307
+        assert ico_response.headers["location"] == "/favicon.svg"
+
+    @pytest.mark.asyncio
+    async def test_mount_favicon_supports_custom_svg_path(self) -> None:
+        """A custom SVG mount path should be the target for ICO redirects."""
+        app = TigrblApp()
+        app.mount_favicon(path="/assets/favicon.svg", name="favicon_assets_route")
+
+        transport = ASGITransport(app=app)
+        async with AsyncClient(transport=transport, base_url="http://test") as client:
+            svg_response = await client.get("/assets/favicon.svg")
+            ico_response = await client.get("/favicon.ico", follow_redirects=False)
+
+        assert svg_response.status_code == 200
+        assert svg_response.headers["content-type"].startswith("image/svg+xml")
+
+        assert ico_response.status_code == 307
+        assert ico_response.headers["location"] == "/assets/favicon.svg"
+
+    @pytest.mark.asyncio
+    async def test_mount_favicon_serves_ico_file_directly(self, tmp_path: Path) -> None:
+        """When an ICO file is configured, only ICO should be served directly."""
+        app = TigrblApp()
+        favicon_ico = tmp_path / "favicon.ico"
+        favicon_ico.write_bytes(b"\x00\x00\x01\x00")
+
+        app.mount_favicon(favicon_path=favicon_ico, name="favicon_ico_route")
+
+        transport = ASGITransport(app=app)
+        async with AsyncClient(transport=transport, base_url="http://test") as client:
+            ico_response = await client.get("/favicon.ico")
+            svg_response = await client.get("/favicon.svg")
+
+        assert ico_response.status_code == 200
+        assert ico_response.headers["content-type"].startswith("image/x-icon")
+        assert ico_response.content == b"\x00\x00\x01\x00"
+
+        assert svg_response.status_code == 404
+
+
+class TestMountFaviconOnTigrblApi:
+    """Validate favicon mounting behavior for ``TigrblApi`` instances."""
+
+    def test_tigrbl_api_binds_mount_favicon_method(self) -> None:
+        """``TigrblApi`` should expose ``mount_favicon`` as an instance API."""
+        api = TigrblApi()
+
+        assert hasattr(api, "mount_favicon")
+
+    @pytest.mark.asyncio
+    async def test_bound_mount_favicon_supports_api_instances(self) -> None:
+        """The bound method should mount favicon routes on APIs."""
+        api = TigrblApi()
+        api.mount_favicon(path="/branding/favicon.svg", name="api_branding_favicon")
+
+        transport = ASGITransport(app=api)
+        async with AsyncClient(transport=transport, base_url="http://test") as client:
+            svg_response = await client.get("/branding/favicon.svg")
+            ico_response = await client.get("/favicon.ico", follow_redirects=False)
+
+        assert svg_response.status_code == 200
+        assert svg_response.headers["content-type"].startswith("image/svg+xml")
+        assert ico_response.status_code == 307
+        assert ico_response.headers["location"] == "/branding/favicon.svg"
+
+    @pytest.mark.asyncio
+    async def test_bound_mount_favicon_retains_default_fallback(self) -> None:
+        """Passing ``None`` for favicon path should use the default SVG asset."""
+        api = TigrblApi()
+        api.mount_favicon(path="/fallback/favicon.svg", favicon_path=None)
+
+        transport = ASGITransport(app=api)
+        async with AsyncClient(transport=transport, base_url="http://test") as client:
+            svg_response = await client.get("/fallback/favicon.svg")
+            ico_response = await client.get("/favicon.ico", follow_redirects=False)
+
+        assert svg_response.status_code == 200
+        assert svg_response.headers["content-type"].startswith("image/svg+xml")
+        assert svg_response.content
+        assert ico_response.status_code == 307
+        assert ico_response.headers["location"] == "/fallback/favicon.svg"

tigrbl_tests-0.3.9/tests/request/test_request_asgi_scope_compat.py

@@ -0,0 +1,41 @@
+from __future__ import annotations
+
+from tigrbl.requests import Request
+
+
+def test_request_accepts_scope_with_receive_kwarg_for_compatibility() -> None:
+    scope = {
+        "type": "http",
+        "method": "post",
+        "path": "/rpc",
+        "root_path": "/api",
+        "headers": [(b"authorization", b"Bearer test-token")],
+        "query_string": b"a=1&a=2&b=3",
+        "path_params": {"tenant_id": "abc"},
+        "client": ("198.51.100.77", 443),
+    }
+
+    async def _receive() -> dict[str, object]:
+        return {"type": "http.request", "body": b"", "more_body": False}
+
+    request = Request(scope, receive=_receive)
+
+    assert request.method == "POST"
+    assert request.path == "/rpc"
+    assert str(request.url) == "/api/rpc?a=1&a=2&b=3"
+    assert request.query == {"a": ["1", "2"], "b": ["3"]}
+    assert request.path_params == {"tenant_id": "abc"}
+    assert request.headers.authorization == "Bearer test-token"
+    assert request.bearer_token == "test-token"
+    assert request.client.ip == "198.51.100.77"
+
+
+def test_request_rejects_duplicated_scope_inputs() -> None:
+    scope = {"type": "http", "method": "GET", "path": "/"}
+
+    try:
+        Request(scope, scope=scope)
+    except TypeError as exc:
+        assert "scope cannot be provided" in str(exc)
+    else:  # pragma: no cover - explicit failure branch
+        raise AssertionError("expected Request to reject duplicate scope inputs")

{tigrbl_tests-0.3.8.dev1 → tigrbl_tests-0.3.9}/tests/unit/test_jsonrpc_openrpc.py

@@ -21,19 +21,31 @@ def test_openrpc_endpoint_exposed():
     app, _ = _build_app()
     transport = ASGITransport(app=app)
     with Client(transport=transport, base_url="http://test") as client:
-        response = client.get("/rpc/openrpc.json")
+        response = client.get("/openrpc.json")
 
         assert response.status_code == 200
         payload = response.json()
         assert payload["openrpc"] == "1.2.6"
+        assert payload["servers"] == [{"name": app.title, "url": "/rpc"}]
         assert "methods" in payload
 
 
+def test_openrpc_server_url_respects_jsonrpc_prefix():
+    app, _ = _build_app()
+    app.jsonrpc_prefix = "/rpc/custom"
+    transport = ASGITransport(app=app)
+
+    with Client(transport=transport, base_url="http://test") as client:
+        payload = client.get("/openrpc.json").json()
+
+    assert payload["servers"] == [{"name": app.title, "url": "/rpc/custom"}]
+
+
 def test_openrpc_includes_method_schema():
     app, model = _build_app()
     transport = ASGITransport(app=app)
     with Client(transport=transport, base_url="http://test") as client:
-        payload = client.get("/rpc/openrpc.json").json()
+        payload = client.get("/openrpc.json").json()
         methods = {method["name"]: method for method in payload["methods"]}
 
         create_method = methods[f"{model.__name__}.create"]

tigrbl_tests-0.3.9/tests/unit/test_middleware_http_and_cors.py

@@ -0,0 +1,266 @@
+from __future__ import annotations
+
+import pytest
+
+from tigrbl.middlewares import BaseHTTPMiddleware, CORSMiddleware
+from tigrbl.requests import Request
+from tigrbl.responses import Response
+
+
+async def _run_asgi(app, scope: dict, body: bytes = b"") -> list[dict]:
+    sent: list[dict] = []
+    emitted = False
+
+    async def receive() -> dict:
+        nonlocal emitted
+        if emitted:
+            return {"type": "http.request", "body": b"", "more_body": False}
+        emitted = True
+        return {"type": "http.request", "body": body, "more_body": False}
+
+    async def send(message: dict) -> None:
+        sent.append(message)
+
+    await app(scope, receive, send)
+    return sent
+
+
+class RewriteMiddleware(BaseHTTPMiddleware):
+    async def dispatch(self, request: Request, call_next):
+        rewritten = Request(
+            method="POST",
+            path="/rewritten",
+            headers={**request.headers, "x-forwarded": "yes"},
+            query={"changed": ["1"]},
+            path_params={},
+            body=b"forwarded",
+            script_name="",
+            scope=request.scope,
+        )
+        return await call_next(rewritten)
+
+
+@pytest.mark.asyncio
+async def test_base_http_middleware_call_next_uses_forwarded_scope_and_body() -> None:
+    async def endpoint(scope, receive, send):
+        body_msg = await receive()
+        payload = (
+            f"{scope.get('method')}|{scope.get('path')}|"
+            f"{scope.get('query_string', b'').decode('latin-1')}|"
+            f"{dict((k.decode('latin-1'), v.decode('latin-1')) for k, v in scope['headers'])['x-forwarded']}|"
+            f"{body_msg.get('body', b'').decode('latin-1')}"
+        ).encode("utf-8")
+        await send(
+            {
+                "type": "http.response.start",
+                "status": 200,
+                "headers": [(b"content-type", b"text/plain")],
+            }
+        )
+        await send({"type": "http.response.body", "body": payload, "more_body": False})
+
+    app = RewriteMiddleware(endpoint)
+    messages = await _run_asgi(
+        app,
+        {
+            "type": "http",
+            "method": "GET",
+            "path": "/original",
+            "query_string": b"before=1",
+            "headers": [(b"host", b"test")],
+        },
+        body=b"ignored",
+    )
+
+    body = next(m for m in messages if m["type"] == "http.response.body")["body"]
+    assert body == b"POST|/rewritten|changed=1|yes|forwarded"
+
+
+class ShortCircuitMiddleware(BaseHTTPMiddleware):
+    async def dispatch(self, request: Request, call_next):
+        return Response.text("should-be-stripped", status_code=204)
+
+
+@pytest.mark.asyncio
+async def test_base_http_middleware_normalizes_no_body_responses() -> None:
+    async def endpoint(scope, receive, send):
+        del scope, receive
+        await send({"type": "http.response.start", "status": 200, "headers": []})
+        await send({"type": "http.response.body", "body": b"ok", "more_body": False})
+
+    app = ShortCircuitMiddleware(endpoint)
+    messages = await _run_asgi(
+        app,
+        {
+            "type": "http",
+            "method": "GET",
+            "path": "/",
+            "query_string": b"",
+            "headers": [],
+        },
+    )
+
+    start = next(m for m in messages if m["type"] == "http.response.start")
+    body = next(m for m in messages if m["type"] == "http.response.body")
+    header_names = {k.lower() for k, _ in start["headers"]}
+
+    assert body["body"] == b""
+    assert b"content-length" not in header_names
+    assert b"content-type" not in header_names
+
+
+@pytest.mark.asyncio
+async def test_cors_middleware_handles_preflight_and_simple_requests() -> None:
+    async def endpoint(scope, receive, send):
+        del scope, receive
+        await send(
+            {
+                "type": "http.response.start",
+                "status": 200,
+                "headers": [(b"content-type", b"text/plain")],
+            }
+        )
+        await send({"type": "http.response.body", "body": b"ok", "more_body": False})
+
+    app = CORSMiddleware(endpoint, allow_origin="https://client.test")
+
+    preflight = await _run_asgi(
+        app,
+        {
+            "type": "http",
+            "method": "OPTIONS",
+            "path": "/",
+            "query_string": b"",
+            "headers": [
+                (b"origin", b"https://client.test"),
+                (b"access-control-request-method", b"GET"),
+                (b"access-control-request-headers", b"x-custom"),
+            ],
+        },
+    )
+    preflight_start = next(m for m in preflight if m["type"] == "http.response.start")
+    preflight_headers = {
+        k.decode("latin-1"): v.decode("latin-1") for k, v in preflight_start["headers"]
+    }
+    assert preflight_start["status"] == 204
+    assert preflight_headers["access-control-allow-origin"] == "https://client.test"
+    assert preflight_headers["access-control-allow-headers"] == "x-custom"
+
+    simple = await _run_asgi(
+        app,
+        {
+            "type": "http",
+            "method": "GET",
+            "path": "/",
+            "query_string": b"",
+            "headers": [(b"origin", b"https://client.test")],
+        },
+    )
+    simple_start = next(m for m in simple if m["type"] == "http.response.start")
+    simple_headers = {
+        k.decode("latin-1"): v.decode("latin-1") for k, v in simple_start["headers"]
+    }
+    assert simple_start["status"] == 200
+    assert simple_headers["access-control-allow-origin"] == "https://client.test"
+
+
+def test_cors_middleware_wsgi_preserves_duplicate_headers() -> None:
+    captured: dict[str, object] = {}
+
+    def wsgi_app(environ, start_response):
+        del environ
+        start_response(
+            "200 OK",
+            [("set-cookie", "session=abc"), ("set-cookie", "theme=dark")],
+        )
+        return [b"ok"]
+
+    app = CORSMiddleware(wsgi_app, allow_origin="https://client.test")
+
+    def start_response(status: str, headers: list[tuple[str, str]], *args):
+        del args
+        captured["status"] = status
+        captured["headers"] = headers
+
+    body = app.wsgi(
+        {
+            "REQUEST_METHOD": "GET",
+            "HTTP_ORIGIN": "https://client.test",
+        },
+        start_response,
+    )
+
+    assert body == [b"ok"]
+    assert captured["status"] == "200 OK"
+    headers = captured["headers"]
+    assert isinstance(headers, list)
+    assert [value for key, value in headers if key.lower() == "set-cookie"] == [
+        "session=abc",
+        "theme=dark",
+    ]
+    assert (
+        dict((key.lower(), value) for key, value in headers)[
+            "access-control-allow-origin"
+        ]
+        == "https://client.test"
+    )
+
+
+@pytest.mark.asyncio
+async def test_cors_middleware_accepts_list_origins_and_regex() -> None:
+    async def endpoint(scope, receive, send):
+        del scope, receive
+        await send(
+            {
+                "type": "http.response.start",
+                "status": 200,
+                "headers": [],
+            }
+        )
+        await send({"type": "http.response.body", "body": b"ok", "more_body": False})
+
+    app = CORSMiddleware(
+        endpoint,
+        allow_origins=["https://allowed.example", "https://other.example"],
+        allow_origin_regex=r"https://.*\.trusted\.example",
+        allow_methods=["GET", "POST"],
+        allow_headers=["x-custom", "authorization"],
+    )
+
+    allowed = await _run_asgi(
+        app,
+        {
+            "type": "http",
+            "method": "GET",
+            "path": "/",
+            "query_string": b"",
+            "headers": [(b"origin", b"https://allowed.example")],
+        },
+    )
+    allowed_headers = {
+        k.decode("latin-1"): v.decode("latin-1")
+        for k, v in next(m for m in allowed if m["type"] == "http.response.start")[
+            "headers"
+        ]
+    }
+    assert allowed_headers["access-control-allow-origin"] == "https://allowed.example"
+    assert allowed_headers["access-control-allow-methods"] == "GET,POST"
+    assert allowed_headers["access-control-allow-headers"] == "x-custom,authorization"
+
+    regex_allowed = await _run_asgi(
+        app,
+        {
+            "type": "http",
+            "method": "GET",
+            "path": "/",
+            "query_string": b"",
+            "headers": [(b"origin", b"https://api.trusted.example")],
+        },
+    )
+    regex_headers = {
+        k.decode("latin-1"): v.decode("latin-1")
+        for k, v in next(
+            m for m in regex_allowed if m["type"] == "http.response.start"
+        )["headers"]
+    }
+    assert regex_headers["access-control-allow-origin"] == "https://api.trusted.example"

tigrbl_tests-0.3.9/tests/unit/test_system_docs_builders.py

@@ -0,0 +1,122 @@
+import pytest
+
+from tigrbl import TigrblApp
+from tigrbl.system import build_lens, build_openapi, build_openrpc_spec, build_swagger
+from tigrbl.types import Request
+
+
+@pytest.mark.unit
+def test_system_build_helpers_return_documents() -> None:
+    app = TigrblApp()
+    request = Request(
+        method="GET", path="/docs", headers={}, query={}, path_params={}, body=b""
+    )
+
+    openapi_doc = build_openapi(app)
+    openrpc_doc = build_openrpc_spec(app)
+    swagger_html = build_swagger(app, request)
+    lens_html = build_lens(app, request, spec_path="/openrpc.json")
+
+    assert openapi_doc["openapi"].startswith("3.")
+    assert openrpc_doc["openrpc"] == "1.2.6"
+    assert openrpc_doc["servers"] == [{"name": app.title, "url": "/rpc"}]
+    assert "swagger-ui" in swagger_html
+    assert "tigrbl-lens" in lens_html
+
+
+@pytest.mark.unit
+def test_openrpc_builder_uses_request_origin_and_jsonrpc_prefix() -> None:
+    app = TigrblApp(jsonrpc_prefix="/gateway/rpc")
+    request = Request(
+        method="GET",
+        path="/openrpc.json",
+        headers={"host": "api.example.com", "x-forwarded-proto": "https"},
+        query={},
+        path_params={},
+        body=b"",
+    )
+
+    openrpc_doc = build_openrpc_spec(app, request=request)
+
+    assert openrpc_doc["servers"] == [
+        {"name": app.title, "url": "https://api.example.com/gateway/rpc"}
+    ]
+
+
+@pytest.mark.unit
+def test_openrpc_builder_normalizes_forwarded_host_header_values() -> None:
+    app = TigrblApp(jsonrpc_prefix="/gateway/rpc")
+    request = Request(
+        method="GET",
+        path="/openrpc.json",
+        headers={
+            "x-forwarded-host": "api.example.com,edge.proxy.internal",
+            "x-forwarded-proto": "https, http",
+        },
+        query={},
+        path_params={},
+        body=b"",
+    )
+
+    openrpc_doc = build_openrpc_spec(app, request=request)
+
+    assert openrpc_doc["servers"] == [
+        {"name": app.title, "url": "https://api.example.com/gateway/rpc"}
+    ]
+
+
+@pytest.mark.unit
+def test_openrpc_builder_prefers_request_scheme_without_forwarded_proto() -> None:
+    app = TigrblApp(jsonrpc_prefix="/gateway/rpc")
+    request = Request(
+        method="GET",
+        path="/openrpc.json",
+        headers={"x-forwarded-host": "api.example.com"},
+        query={},
+        path_params={},
+        body=b"",
+        scope={"scheme": "https"},
+    )
+
+    openrpc_doc = build_openrpc_spec(app, request=request)
+
+    assert openrpc_doc["servers"] == [
+        {"name": app.title, "url": "https://api.example.com/gateway/rpc"}
+    ]
+
+
+@pytest.mark.unit
+def test_openrpc_builder_prefers_forwarded_proto_over_request_scheme() -> None:
+    app = TigrblApp(jsonrpc_prefix="/gateway/rpc")
+    request = Request(
+        method="GET",
+        path="/openrpc.json",
+        headers={"host": "api.example.com", "x-forwarded-proto": "https"},
+        query={},
+        path_params={},
+        body=b"",
+        scope={"scheme": "http"},
+    )
+
+    openrpc_doc = build_openrpc_spec(app, request=request)
+
+    assert openrpc_doc["servers"] == [
+        {"name": app.title, "url": "https://api.example.com/gateway/rpc"}
+    ]
+
+
+@pytest.mark.unit
+def test_openrpc_builder_keeps_relative_server_url_without_forwarding_headers() -> None:
+    app = TigrblApp(jsonrpc_prefix="/gateway/rpc")
+    request = Request(
+        method="GET",
+        path="/openrpc.json",
+        headers={"host": "api.example.com"},
+        query={},
+        path_params={},
+        body=b"",
+    )
+
+    openrpc_doc = build_openrpc_spec(app, request=request)
+
+    assert openrpc_doc["servers"] == [{"name": app.title, "url": "/gateway/rpc"}]

{tigrbl_tests-0.3.8.dev1 → tigrbl_tests-0.3.9}/tests/unit/test_tigrbl_api_configuration.py

@@ -45,3 +45,15 @@ def test_tigrbl_api_post_instantiation_set_auth_updates_state() -> None:
     assert "_allow_anon" in api_dir
     assert api._authn is _auth_dependency
     assert api._allow_anon is False
+
+
+@pytest.mark.unit
+def test_tigrbl_api_class_prefix_defaults() -> None:
+    assert TigrblApi.REST_PREFIX == "/api"
+    assert TigrblApi.RPC_PREFIX == "/rpc"
+    assert TigrblApi.SYSTEM_PREFIX == "/system"
+
+    api = TigrblApi(engine=mem(async_=False))
+    assert api.rest_prefix == "/api"
+    assert api.rpc_prefix == "/rpc"
+    assert api.system_prefix == "/system"