tigrbl_tests 0.3.6.dev1__tar.gz → 0.3.7__tar.gz

{tigrbl_tests-0.3.6.dev1 → tigrbl_tests-0.3.7}/PKG-INFO

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

{tigrbl_tests-0.3.6.dev1 → tigrbl_tests-0.3.7}/pyproject.toml

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

tigrbl_tests-0.3.7/tests/request/test_request_dot_notation.py

@@ -0,0 +1,29 @@
+from __future__ import annotations
+
+from tigrbl.headers import Headers
+from tigrbl.requests import Request
+
+
+def test_request_headers_support_dot_notation_access_and_assignment() -> None:
+    headers = Headers({"X-Trace-Id": "abc123"})
+
+    assert headers.x_trace_id == "abc123"
+
+    headers.authorization = "Bearer token"
+    assert headers["authorization"] == "Bearer token"
+
+
+def test_request_exposes_dot_notation_attributes_without_getattr_helpers() -> None:
+    request = Request(
+        method="GET",
+        path="/health",
+        headers={"Cookie": "session=abc123"},
+        query={"page": ["1"]},
+        path_params={},
+        body=b"",
+    )
+
+    assert request.path == "/health"
+    assert request.url.path == "/health"
+    assert request.query_params["page"] == "1"
+    assert request.cookies["session"] == "abc123"

{tigrbl_tests-0.3.6.dev1 → tigrbl_tests-0.3.7}/tests/request/test_request_response_conveniences.py

@@ -4,8 +4,8 @@ import json
 
 import pytest
 
-from tigrbl.response.stdapi import Response
-from tigrbl.transport.request import Request
+from tigrbl.responses import Response
+from tigrbl.requests import Request
 
 
 def _make_request(

tigrbl_tests-0.3.7/tests/request/test_request_transport_convenience_dot_notation.py

@@ -0,0 +1,61 @@
+from __future__ import annotations
+
+import json
+
+import pytest
+
+from tigrbl.requests import Request
+
+
+def _make_request(*, headers: dict[str, str], body: bytes = b"") -> Request:
+    return Request(
+        method="POST",
+        path="/session",
+        headers=headers,
+        query={},
+        path_params={},
+        body=body,
+        scope={"client": ("203.0.113.10", 443)},
+    )
+
+
+def test_request_headers_and_cookies_support_nested_dot_notation_access() -> None:
+    request = _make_request(
+        headers={
+            "Authorization": "Bearer access-token",
+            "Cookie": "sid=session-token; tenant=acme",
+        }
+    )
+
+    assert request.headers.authorization == "Bearer access-token"
+    assert request.headers.cookie.sid == "session-token"
+    assert request.headers.cookie.tenant == "acme"
+
+
+@pytest.mark.asyncio()
+async def test_request_exposes_json_and_dot_notation_bearer_conveniences() -> None:
+    request = _make_request(
+        headers={"Authorization": "Bearer access-token"},
+        body=json.dumps({"ok": True}).encode("utf-8"),
+    )
+
+    assert request.json() == {"ok": True}
+    assert await request.json() == {"ok": True}
+    assert request.bearer_token == "access-token"
+    assert request.session_token == "access-token"
+
+
+def test_request_session_token_falls_back_to_cookie_and_client_ip_attribute() -> None:
+    request = _make_request(headers={"Cookie": "sid=session-token"})
+
+    assert request.session_token == "session-token"
+    assert request.client.ip == "203.0.113.10"
+
+
+def test_request_exposes_b64url_helpers_via_dot_notation() -> None:
+    request = _make_request(headers={})
+
+    token = request.b64url_encode(b'{"alg":"HS256"}')
+
+    assert token == "eyJhbGciOiJIUzI1NiJ9"
+    assert request.b64url_decode(token) == b'{"alg":"HS256"}'

tigrbl_tests-0.3.7/tests/requests/test_request_json_modes.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+
+import json
+
+import pytest
+
+from tigrbl.requests import Request
+
+
+def _make_request(path: str, body: bytes | None = None) -> Request:
+    return Request(
+        method="POST",
+        path=path,
+        headers={"content-type": "application/json"},
+        query={},
+        path_params={},
+        body=body or b"",
+    )
+
+
+@pytest.mark.asyncio()
+async def test_request_supports_request_url_path_and_body_and_async_json() -> None:
+    req = _make_request("/users/42", json.dumps({"id": 42}).encode("utf-8"))
+
+    assert req.url.path == "/users/42"
+    assert req.body == b'{"id": 42}'
+    assert await req.json() == {"id": 42}
+
+
+def test_request_json_is_usable_without_await_for_blocking_style() -> None:
+    req = _make_request("/users", json.dumps({"ok": True, "id": 1}).encode("utf-8"))
+
+    payload = req.json()
+
+    assert payload["ok"] is True
+    assert payload.get("id") == 1
+    assert dict(payload) == {"ok": True, "id": 1}

tigrbl_tests-0.3.7/tests/response/test_response_dot_notation.py

@@ -0,0 +1,21 @@
+from __future__ import annotations
+
+from tigrbl.headers import Headers
+from tigrbl.responses import Response
+
+
+def test_response_headers_support_dot_notation_access_and_assignment() -> None:
+    headers = Headers({"Content-Type": "application/json"})
+
+    assert headers.content_type == "application/json"
+
+    headers.x_trace_id = "trace-123"
+    assert headers["x-trace-id"] == "trace-123"
+
+
+def test_response_exposes_dot_notation_attributes_without_getattr_helpers() -> None:
+    response = Response.text("ok", headers={"X-Request-Id": "req-1"})
+
+    assert response.status_code == 200
+    assert response.body_text == "ok"
+    assert response.headers_map.x_request_id == "req-1"

tigrbl_tests-0.3.7/tests/response/test_response_transport_convenience_dot_notation.py

@@ -0,0 +1,27 @@
+from __future__ import annotations
+
+from tigrbl.responses import Response
+
+
+def test_response_supports_instance_json_method_for_body_payload() -> None:
+    response = Response(
+        status_code=200,
+        headers=[("content-type", "application/json; charset=utf-8")],
+        body=b'{"ok":true,"count":1}',
+    )
+
+    assert response.json() == {"ok": True, "count": 1}
+
+
+def test_response_headers_and_cookies_support_dot_notation() -> None:
+    response = Response(
+        status_code=200,
+        headers=[
+            ("x-request-id", "req-123"),
+            ("set-cookie", "sid=session-token; Path=/"),
+        ],
+        body=b"",
+    )
+
+    assert response.headers_map.x_request_id == "req-123"
+    assert response.cookies.sid == "session-token"

tigrbl_tests-0.3.7/tests/security/test_dot_notation_schemes.py

@@ -0,0 +1,35 @@
+from __future__ import annotations
+
+from tigrbl.security import APIKey, HTTPBearer
+from tigrbl.requests import Request
+
+
+def test_http_bearer_reads_authorization_from_request_headers_attribute() -> None:
+    request = Request(
+        method="GET",
+        path="/secure",
+        headers={"Authorization": "bearer token-123"},
+        query={},
+        path_params={},
+        body=b"",
+    )
+
+    creds = HTTPBearer()(request)
+
+    assert creds is not None
+    assert creds.credentials == "token-123"
+
+
+def test_api_key_reads_query_value_from_request_query_params_attribute() -> None:
+    request = Request(
+        method="GET",
+        path="/secure",
+        headers={},
+        query={"api_key": ["secret-value"]},
+        path_params={},
+        body=b"",
+    )
+
+    value = APIKey(name="api_key", in_="query")(request)
+
+    assert value == "secret-value"

{tigrbl_tests-0.3.6.dev1 → tigrbl_tests-0.3.7}/tests/unit/decorators/test_response_ctx_bindings.py

@@ -1,5 +1,5 @@
 from tigrbl import response_ctx
-from tigrbl.response.types import ResponseSpec
+from tigrbl.responses.types import ResponseSpec
 
 
 def test_response_ctx_internal_binding_on_function():

{tigrbl_tests-0.3.6.dev1 → tigrbl_tests-0.3.7}/tests/unit/response_utils.py

@@ -8,8 +8,8 @@ from tigrbl.bindings import (
     register_rpc,
 )
 from tigrbl.op.mro_collect import mro_collect_decorated_ops
-from tigrbl.response import response_ctx, render_template
-from tigrbl.response.shortcuts import (
+from tigrbl.responses import response_ctx, render_template
+from tigrbl.responses.shortcuts import (
     as_file,
     as_html,
     as_json,
@@ -19,7 +19,7 @@ from tigrbl.response.shortcuts import (
 )
 from pydantic import BaseModel
 from typing import get_args
-from tigrbl.response.types import ResponseKind
+from tigrbl.responses.types import ResponseKind
 
 
 RESPONSE_KINDS = get_args(ResponseKind)

{tigrbl_tests-0.3.6.dev1 → tigrbl_tests-0.3.7}/tests/unit/test_file_response.py

@@ -5,7 +5,7 @@ from httpx import ASGITransport, Client
 
 from tigrbl.op.mro_collect import mro_collect_decorated_ops
 from tigrbl.op import op_ctx
-from tigrbl.response.shortcuts import as_file
+from tigrbl.responses.shortcuts import as_file
 from tigrbl.bindings import (
     build_hooks,
     build_handlers,

{tigrbl_tests-0.3.6.dev1 → tigrbl_tests-0.3.7}/tests/unit/test_response_alias_table_rpc.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 import pytest
 from tigrbl import alias_ctx
-from tigrbl.response import response_ctx
+from tigrbl.responses import response_ctx
 from tigrbl.engine.shortcuts import engine as build_engine, mem
 from tigrbl.orm.mixins import GUIDPk
 from tigrbl.orm.tables import Base

{tigrbl_tests-0.3.6.dev1 → tigrbl_tests-0.3.7}/tests/unit/test_response_ctx_precedence.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 from types import SimpleNamespace
 
-from tigrbl.response import (
+from tigrbl.responses import (
     ResponseSpec,
     get_attached_response_spec,
     infer_hints,

{tigrbl_tests-0.3.6.dev1 → tigrbl_tests-0.3.7}/tests/unit/test_response_diagnostics_kernelz.py

@@ -3,7 +3,7 @@ from types import SimpleNamespace
 import pytest
 
 from tigrbl.op.types import OpSpec
-from tigrbl.response.types import ResponseSpec, TemplateSpec
+from tigrbl.responses.types import ResponseSpec, TemplateSpec
 from tigrbl.system.diagnostics import _build_kernelz_endpoint
 
 from .response_utils import RESPONSE_KINDS

{tigrbl_tests-0.3.6.dev1 → tigrbl_tests-0.3.7}/tests/unit/test_response_html_jinja_behavior.py

@@ -9,7 +9,7 @@ from tigrbl import TigrblApp
 from tigrbl.bindings import rpc_call
 from tigrbl.system.diagnostics import _build_kernelz_endpoint
 from tigrbl.runtime.kernel import _default_kernel as K
-from tigrbl.response import render_template
+from tigrbl.responses import render_template
 
 from .response_utils import build_model_for_response, build_model_for_jinja_response
 

{tigrbl_tests-0.3.6.dev1 → tigrbl_tests-0.3.7}/tests/unit/test_response_template.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 import pytest
 
-from tigrbl.response import render_template
+from tigrbl.responses import render_template
 
 pytest.importorskip("jinja2")
 

{tigrbl_tests-0.3.6.dev1 → tigrbl_tests-0.3.7}/tests/unit/test_response_uuid.py

@@ -8,7 +8,7 @@ import types
 from uuid import uuid4
 
 
-from tigrbl.response.shortcuts import as_json
+from tigrbl.responses.shortcuts import as_json
 
 
 def test_as_json_serializes_uuid() -> None:
@@ -27,7 +27,7 @@ def test_as_json_serializes_bytes() -> None:
 
 
 def test_as_json_fallbacks_when_orjson_unsupported(monkeypatch) -> None:
-    import tigrbl.response.shortcuts as shortcuts
+    import tigrbl.responses.shortcuts as shortcuts
 
     original_orjson = sys.modules.get("orjson")
     fake_orjson = types.SimpleNamespace(

tigrbl_tests-0.3.7/tests/unit/test_stdapi_transport_asgi_wsgi.py

@@ -0,0 +1,269 @@
+from __future__ import annotations
+
+import io
+
+import pytest
+
+from tigrbl.types import APIRouter, Request, Response
+
+
+@pytest.mark.asyncio()
+async def test_asgi_http_scope_dispatches_with_query_and_body() -> None:
+    app = APIRouter()
+
+    @app.post("/echo")
+    async def echo(request: Request) -> dict[str, object]:
+        return {
+            "method": request.method,
+            "query": request.query,
+            "body": request.body.decode("utf-8"),
+        }
+
+    messages: list[dict[str, object]] = []
+
+    request_messages = iter(
+        [
+            {
+                "type": "http.request",
+                "body": b'{"hello":"world"}',
+                "more_body": False,
+            }
+        ]
+    )
+
+    async def receive() -> dict[str, object]:
+        return next(request_messages)
+
+    async def send(message: dict[str, object]) -> None:
+        messages.append(message)
+
+    await app._asgi_app(
+        {
+            "type": "http",
+            "method": "POST",
+            "path": "/echo",
+            "query_string": b"x=1&x=2",
+            "headers": [(b"content-type", b"application/json")],
+        },
+        receive,
+        send,
+    )
+
+    assert messages[0]["type"] == "http.response.start"
+    assert messages[0]["status"] == 200
+    assert messages[1]["type"] == "http.response.body"
+    assert (
+        messages[1]["body"]
+        == b'{"method":"POST","query":{"x":["1","2"]},"body":"{\\"hello\\":\\"world\\"}"}'
+    )
+
+
+@pytest.mark.asyncio()
+async def test_asgi_non_http_scope_returns_500() -> None:
+    app = APIRouter()
+    messages: list[dict[str, object]] = []
+
+    async def receive() -> dict[str, object]:
+        return {"type": "websocket.receive", "text": "ignored"}
+
+    async def send(message: dict[str, object]) -> None:
+        messages.append(message)
+
+    await app._asgi_app({"type": "websocket"}, receive, send)
+
+    assert messages == [
+        {"type": "http.response.start", "status": 500, "headers": []},
+        {"type": "http.response.body", "body": b""},
+    ]
+
+
+@pytest.mark.asyncio()
+async def test_asgi_204_response_omits_body_and_content_length() -> None:
+    app = APIRouter()
+
+    @app.delete("/items/{item_id}", status_code=204)
+    def delete_item(item_id: str) -> None:
+        assert item_id == "1"
+        return None
+
+    messages: list[dict[str, object]] = []
+
+    request_messages = iter([{"type": "http.request", "body": b"", "more_body": False}])
+
+    async def receive() -> dict[str, object]:
+        return next(request_messages)
+
+    async def send(message: dict[str, object]) -> None:
+        messages.append(message)
+
+    await app._asgi_app(
+        {
+            "type": "http",
+            "method": "DELETE",
+            "path": "/items/1",
+            "query_string": b"",
+            "headers": [],
+        },
+        receive,
+        send,
+    )
+
+    assert messages[0]["type"] == "http.response.start"
+    assert messages[0]["status"] == 204
+    assert (b"content-length", b"0") not in messages[0]["headers"]
+    assert messages[1] == {
+        "type": "http.response.body",
+        "body": b"",
+        "more_body": False,
+    }
+
+
+@pytest.mark.asyncio()
+async def test_asgi_head_response_strips_body_and_entity_headers() -> None:
+    app = APIRouter()
+
+    @app.get("/items")
+    def list_items() -> dict[str, str]:
+        return {"ok": "yes"}
+
+    messages: list[dict[str, object]] = []
+
+    request_messages = iter([{"type": "http.request", "body": b"", "more_body": False}])
+
+    async def receive() -> dict[str, object]:
+        return next(request_messages)
+
+    async def send(message: dict[str, object]) -> None:
+        messages.append(message)
+
+    await app._asgi_app(
+        {
+            "type": "http",
+            "method": "HEAD",
+            "path": "/items",
+            "query_string": b"",
+            "headers": [],
+        },
+        receive,
+        send,
+    )
+
+    assert messages[0]["type"] == "http.response.start"
+    start_headers = dict(messages[0]["headers"])
+    assert b"content-length" not in start_headers
+    assert b"content-type" not in start_headers
+    assert b"transfer-encoding" not in start_headers
+    assert messages[1] == {
+        "type": "http.response.body",
+        "body": b"",
+        "more_body": False,
+    }
+
+
+def test_wsgi_205_response_strips_body_and_entity_headers() -> None:
+    app = APIRouter()
+
+    @app.get("/reset", status_code=205)
+    def reset() -> dict[str, str]:
+        return {"reset": "ok"}
+
+    called: dict[str, object] = {}
+
+    def start_response(status: str, headers: list[tuple[str, str]]) -> None:
+        called["status"] = status
+        called["headers"] = headers
+
+    response_chunks = app._wsgi_app(
+        {
+            "REQUEST_METHOD": "GET",
+            "PATH_INFO": "/reset",
+            "QUERY_STRING": "",
+            "CONTENT_LENGTH": "0",
+            "wsgi.input": io.BytesIO(b""),
+        },
+        start_response,
+    )
+
+    headers = dict(called["headers"])
+    assert called["status"] == "205 Reset Content"
+    assert "content-length" not in headers
+    assert "content-type" not in headers
+    assert "transfer-encoding" not in headers
+    assert response_chunks == [b""]
+
+
+def test_wsgi_recomputes_stale_content_length() -> None:
+    app = APIRouter()
+
+    @app.get("/raw")
+    def raw() -> object:
+        return Response(
+            body=b"hello",
+            headers=[("content-type", "text/plain"), ("content-length", "999")],
+        )
+
+    called: dict[str, object] = {}
+
+    def start_response(status: str, headers: list[tuple[str, str]]) -> None:
+        called["status"] = status
+        called["headers"] = headers
+
+    response_chunks = app._wsgi_app(
+        {
+            "REQUEST_METHOD": "GET",
+            "PATH_INFO": "/raw",
+            "QUERY_STRING": "",
+            "CONTENT_LENGTH": "0",
+            "wsgi.input": io.BytesIO(b""),
+        },
+        start_response,
+    )
+
+    headers = dict(called["headers"])
+    assert called["status"] == "200 OK"
+    assert headers["content-length"] == "5"
+    assert response_chunks == [b"hello"]
+
+
+def test_wsgi_dispatch_reads_body_and_query() -> None:
+    app = APIRouter()
+
+    @app.post("/echo")
+    def echo(request: Request) -> dict[str, object]:
+        return {
+            "path": request.path,
+            "query": request.query,
+            "body": request.body.decode("utf-8"),
+            "script_name": request.script_name,
+        }
+
+    called: dict[str, object] = {}
+
+    def start_response(status: str, headers: list[tuple[str, str]]) -> None:
+        called["status"] = status
+        called["headers"] = headers
+
+    response_chunks = app._wsgi_app(
+        {
+            "REQUEST_METHOD": "POST",
+            "PATH_INFO": "/echo",
+            "SCRIPT_NAME": "/v1",
+            "QUERY_STRING": "a=1&a=2",
+            "CONTENT_TYPE": "application/json",
+            "CONTENT_LENGTH": "7",
+            "wsgi.input": io.BytesIO(b'{"a":1}'),
+        },
+        start_response,
+    )
+
+    assert called["status"] == "200 OK"
+    assert response_chunks == [
+        b'{"path":"/echo","query":{"a":["1","2"]},"body":"{\\"a\\":1}","script_name":"/v1"}'
+    ]
+
+
+def test_invalid_asgi_wsgi_invocation_raises_type_error() -> None:
+    app = APIRouter()
+
+    with pytest.raises(TypeError, match="Invalid ASGI/WSGI invocation"):
+        app("not-a-scope")