django-bolt 0.1.0__cp310-abi3-win_amd64.whl

django_bolt/testing/client.py

@@ -0,0 +1,274 @@
+"""Test clients for django-bolt using per-instance test state.
+
+This version uses the test_state.rs infrastructure which provides:
+- Per-instance routers (no global state conflicts)
+- Per-instance event loops (proper async handling)
+"""
+from __future__ import annotations
+
+from typing import Any
+
+import httpx
+from httpx import Response
+
+from django_bolt import BoltAPI
+
+
+class BoltTestTransport(httpx.BaseTransport):
+    """HTTP transport that routes requests through django-bolt's per-instance test handler.
+
+    Args:
+        app_id: Test app instance ID
+        raise_server_exceptions: If True, raise exceptions from handlers
+        use_http_layer: If True, route through Actix HTTP layer (enables testing of
+                        middleware like CORS, rate limiting, compression). If False (default),
+                        use fast direct dispatch for unit tests.
+    """
+
+    def __init__(self, app_id: int, raise_server_exceptions: bool = True, use_http_layer: bool = False):
+        self.app_id = app_id
+        self.raise_server_exceptions = raise_server_exceptions
+        self.use_http_layer = use_http_layer
+
+    def handle_request(self, request: httpx.Request) -> httpx.Response:
+        """Handle a request by routing it through Rust."""
+        from django_bolt import _core
+
+        # Parse URL
+        url = request.url
+        path = url.path
+        query_string = url.query.decode('utf-8') if url.query else None
+
+        # Extract headers
+        headers = [(k.decode('utf-8'), v.decode('utf-8')) for k, v in request.headers.raw]
+
+        # Get body
+        # Check if content has been read already
+        if hasattr(request, "_content"):
+            body_bytes = request.content
+        else:
+            # For streaming/multipart requests, need to read the content first
+            try:
+                # Try to read the request stream
+                if hasattr(request.stream, 'read'):
+                    body_bytes = request.stream.read()
+                else:
+                    # Fall back to iterating the stream
+                    body_bytes = b''.join(request.stream)
+            except Exception:
+                # Last resort: try to get content directly
+                body_bytes = request.content if hasattr(request, "_content") else b''
+
+        # Get method
+        method = request.method
+
+        try:
+            # Choose handler based on mode
+            if self.use_http_layer:
+                # Route through Actix HTTP layer (for middleware testing)
+                status_code, resp_headers, resp_body = _core.handle_actix_http_request(
+                    app_id=self.app_id,
+                    method=method,
+                    path=path,
+                    headers=headers,
+                    body=body_bytes,
+                    query_string=query_string,
+                )
+            else:
+                # Fast direct dispatch (for unit tests)
+                status_code, resp_headers, resp_body = _core.handle_test_request_for(
+                    app_id=self.app_id,
+                    method=method,
+                    path=path,
+                    headers=headers,
+                    body=body_bytes,
+                    query_string=query_string,
+                )
+
+            # Build httpx Response
+            return Response(
+                status_code=status_code,
+                headers=resp_headers,
+                content=resp_body,
+                request=request,
+            )
+
+        except Exception as e:
+            if self.raise_server_exceptions:
+                raise
+            # Return 500 error
+            return Response(
+                status_code=500,
+                headers=[('content-type', 'text/plain')],
+                content=f"Test client error: {e}".encode('utf-8'),
+                request=request,
+            )
+
+
+class TestClient(httpx.Client):
+    """Synchronous test client for django-bolt using per-instance test state.
+
+    This client:
+    - Creates an isolated test app instance (no global state conflicts)
+    - Manages its own event loop for async handlers
+    - Routes through full Rust pipeline (auth, middleware, compression)
+    - Can run multiple tests in parallel without conflicts
+
+    Usage:
+        api = BoltAPI()
+
+        @api.get("/hello")
+        async def hello():
+            return {"message": "world"}
+
+        with TestClient(api) as client:
+            response = client.get("/hello")
+            assert response.status_code == 200
+            assert response.json() == {"message": "world"}
+    """
+
+    __test__ = False  # Tell pytest this is not a test class
+
+    def __init__(
+        self,
+        api: BoltAPI,
+        base_url: str = "http://testserver.local",
+        raise_server_exceptions: bool = True,
+        use_http_layer: bool = False,
+        cors_allowed_origins: list[str] | None = None,
+        **kwargs: Any,
+    ):
+        """Initialize test client.
+
+        Args:
+            api: BoltAPI instance to test
+            base_url: Base URL for requests
+            raise_server_exceptions: If True, raise exceptions from handlers
+            use_http_layer: If True, route through Actix HTTP layer (enables testing
+                           CORS, rate limiting, compression). Default False for fast tests.
+            cors_allowed_origins: Global CORS allowed origins for testing
+            **kwargs: Additional arguments passed to httpx.Client
+        """
+        from django_bolt import _core
+
+        # Create test app instance
+        self.app_id = _core.create_test_app(api._dispatch, False, cors_allowed_origins)
+
+        # Register routes
+        rust_routes = [
+            (method, path, handler_id, handler)
+            for method, path, handler_id, handler in api._routes
+        ]
+        _core.register_test_routes(self.app_id, rust_routes)
+
+        # Register middleware metadata if any exists
+        if api._handler_middleware:
+            middleware_data = [
+                (handler_id, meta)
+                for handler_id, meta in api._handler_middleware.items()
+            ]
+            _core.register_test_middleware_metadata(self.app_id, middleware_data)
+
+        # Ensure runtime is ready
+        _core.ensure_test_runtime(self.app_id)
+
+        super().__init__(
+            base_url=base_url,
+            transport=BoltTestTransport(self.app_id, raise_server_exceptions, use_http_layer),
+            follow_redirects=True,
+            **kwargs,
+        )
+        self.api = api
+
+    def __enter__(self):
+        """Enter context manager."""
+        return super().__enter__()
+
+    def __exit__(self, *args):
+        """Exit context manager and cleanup test app."""
+        from django_bolt import _core
+
+        try:
+            _core.destroy_test_app(self.app_id)
+        except:
+            pass
+        return super().__exit__(*args)
+
+
+class AsyncTestClient(httpx.AsyncClient):
+    """Asynchronous test client for django-bolt using per-instance test state."""
+
+    __test__ = False  # Tell pytest this is not a test class
+
+    def __init__(
+        self,
+        api: BoltAPI,
+        base_url: str = "http://testserver.local",
+        raise_server_exceptions: bool = True,
+        use_http_layer: bool = False,
+        cors_allowed_origins: list[str] | None = None,
+        **kwargs: Any,
+    ):
+        """Initialize async test client.
+
+        Args:
+            api: BoltAPI instance to test
+            base_url: Base URL for requests
+            raise_server_exceptions: If True, raise exceptions from handlers
+            use_http_layer: If True, route through Actix HTTP layer (enables testing
+                           CORS, rate limiting, compression). Default False for fast tests.
+            cors_allowed_origins: Global CORS allowed origins for testing
+            **kwargs: Additional arguments passed to httpx.AsyncClient
+        """
+        from django_bolt import _core
+
+        # Create test app instance
+        self.app_id = _core.create_test_app(api._dispatch, False, cors_allowed_origins)
+
+        # Register routes
+        rust_routes = [
+            (method, path, handler_id, handler)
+            for method, path, handler_id, handler in api._routes
+        ]
+        _core.register_test_routes(self.app_id, rust_routes)
+
+        # Register middleware metadata if any exists
+        if api._handler_middleware:
+            middleware_data = [
+                (handler_id, meta)
+                for handler_id, meta in api._handler_middleware.items()
+            ]
+            _core.register_test_middleware_metadata(self.app_id, middleware_data)
+
+        # Ensure runtime is ready
+        _core.ensure_test_runtime(self.app_id)
+
+        # Create async transport
+        class AsyncTransport(httpx.AsyncBaseTransport):
+            def __init__(self, app_id: int, raise_exceptions: bool, use_http_layer: bool):
+                self._sync_transport = BoltTestTransport(app_id, raise_exceptions, use_http_layer)
+
+            async def handle_async_request(self, request: httpx.Request) -> httpx.Response:
+                return self._sync_transport.handle_request(request)
+
+        super().__init__(
+            base_url=base_url,
+            transport=AsyncTransport(self.app_id, raise_server_exceptions, use_http_layer),
+            follow_redirects=True,
+            **kwargs,
+        )
+        self.api = api
+
+    async def __aenter__(self):
+        """Enter async context manager."""
+        return await super().__aenter__()
+
+    async def __aexit__(self, *args):
+        """Exit async context manager and cleanup test app."""
+        from django_bolt import _core
+
+        try:
+            _core.destroy_test_app(self.app_id)
+        except:
+            pass
+        return await super().__aexit__(*args)

django_bolt/testing/helpers.py

@@ -0,0 +1,93 @@
+"""Helper functions for creating test clients."""
+from __future__ import annotations
+
+from typing import Any
+
+from django_bolt import BoltAPI
+from django_bolt.testing.client import AsyncTestClient, TestClient
+
+
+def create_test_client(
+    api: BoltAPI,
+    base_url: str = "http://testserver.local",
+    raise_server_exceptions: bool = True,
+    bootstrap_django: bool = True,
+    **kwargs: Any,
+) -> TestClient:
+    """Create a synchronous test client.
+
+    Args:
+        api: BoltAPI instance to test
+        base_url: Base URL for requests
+        raise_server_exceptions: If True, raise handler exceptions instead of 500 responses
+        **kwargs: Additional httpx.Client arguments
+
+    Returns:
+        TestClient instance
+
+    Example:
+        from django_bolt import BoltAPI
+        from django_bolt.testing import create_test_client
+
+        api = BoltAPI()
+
+        @api.get("/users/{user_id}")
+        async def get_user(user_id: int):
+            return {"id": user_id, "name": "Test User"}
+
+        def test_get_user():
+            with create_test_client(api) as client:
+                response = client.get("/users/123")
+                assert response.status_code == 200
+                assert response.json()["id"] == 123
+    """
+    return TestClient(
+        api=api,
+        base_url=base_url,
+        raise_server_exceptions=raise_server_exceptions,
+        bootstrap_django=bootstrap_django,
+        **kwargs,
+    )
+
+
+def create_async_test_client(
+    api: BoltAPI,
+    base_url: str = "http://testserver.local",
+    raise_server_exceptions: bool = True,
+    bootstrap_django: bool = True,
+    **kwargs: Any,
+) -> AsyncTestClient:
+    """Create an asynchronous test client.
+
+    Args:
+        api: BoltAPI instance to test
+        base_url: Base URL for requests
+        raise_server_exceptions: If True, raise handler exceptions instead of 500 responses
+        **kwargs: Additional httpx.AsyncClient arguments
+
+    Returns:
+        AsyncTestClient instance
+
+    Example:
+        from django_bolt import BoltAPI
+        from django_bolt.testing import create_async_test_client
+
+        api = BoltAPI()
+
+        @api.get("/users/{user_id}")
+        async def get_user(user_id: int):
+            return {"id": user_id, "name": "Test User"}
+
+        async def test_get_user():
+            async with create_async_test_client(api) as client:
+                response = await client.get("/users/123")
+                assert response.status_code == 200
+                assert response.json()["id"] == 123
+    """
+    return AsyncTestClient(
+        api=api,
+        base_url=base_url,
+        raise_server_exceptions=raise_server_exceptions,
+        bootstrap_django=bootstrap_django,
+        **kwargs,
+    )

django_bolt/tests/admin_tests/__init__.py

@@ -0,0 +1 @@
+# Admin integration tests

django_bolt/tests/admin_tests/conftest.py

@@ -0,0 +1,6 @@
+"""
+Pytest configuration for admin integration tests.
+
+The parent conftest will auto-detect admin_tests in the path
+and configure Django with admin apps enabled.
+"""

django_bolt/tests/admin_tests/test_admin_with_django.py

@@ -0,0 +1,278 @@
+"""
+Tests for Django admin integration that actually use a Django project.
+
+These tests configure Django properly and will FAIL if ASGI bridge is broken.
+"""
+
+import pytest
+from django_bolt.api import BoltAPI
+from django_bolt.testing import TestClient
+
+
+@pytest.fixture(scope="module")
+def api_with_admin():
+    """Create API with admin enabled using real Django project."""
+    api = BoltAPI()
+    api._register_admin_routes('127.0.0.1', 8000)
+
+    @api.get("/test")
+    async def test_route():
+        return {"test": "ok"}
+
+    return api
+
+
+@pytest.fixture(scope="module")
+def client(api_with_admin):
+    """Create test client with HTTP layer."""
+    with TestClient(api_with_admin, use_http_layer=True) as client:
+        yield client
+
+
+def test_admin_root_redirect(client):
+    """Test /admin/ returns content (redirect or login page)."""
+    response = client.get("/admin/")
+
+    print(f"\n[Admin Root Test]")
+    print(f"Status: {response.status_code}")
+    print(f"Headers: {dict(response.headers)}")
+    print(f"Body length: {len(response.content)}")
+    print(f"Body preview: {response.text[:300] if response.text else 'N/A'}")
+
+    # Should return a valid response (redirect or login page)
+    assert response.status_code in (200, 301, 302), f"Expected valid response, got {response.status_code}"
+
+    # CRITICAL: Body should NOT be empty
+    assert len(response.content) > 0, f"Response body is EMPTY! Got {len(response.content)} bytes. ASGI bridge is BROKEN!"
+
+
+def test_admin_login_page(client):
+    """Test /admin/login/ returns HTML page (not empty body)."""
+    response = client.get("/admin/login/")
+
+    print(f"\n[Admin Login Test]")
+    print(f"Status: {response.status_code}")
+    print(f"Headers: {dict(response.headers)}")
+    print(f"Body length: {len(response.content)}")
+    print(f"Body preview: {response.text[:300]}")
+
+    # Should return 200 OK
+    assert response.status_code == 200, f"Expected 200, got {response.status_code}"
+
+    # CRITICAL: Body should NOT be empty - THIS IS THE BUG
+    assert len(response.content) > 0, f"Admin login page body is EMPTY! Got {len(response.content)} bytes. ASGI bridge is BROKEN!"
+
+    # Should be HTML
+    content_type = response.headers.get('content-type', '')
+    assert 'html' in content_type.lower(), f"Expected HTML, got {content_type}"
+
+    # Should contain login form
+    body_text = response.text.lower()
+    assert 'login' in body_text or 'django' in body_text, f"Expected login content, got: {body_text[:200]}"
+
+
+@pytest.mark.django_db
+def test_asgi_bridge_direct_with_real_django():
+    """Test ASGI bridge directly with real Django configuration."""
+    from django_bolt.admin.asgi_bridge import ASGIFallbackHandler
+    import asyncio
+
+    # Database is already set up by pytest-django
+    handler = ASGIFallbackHandler(server_host="127.0.0.1", server_port=8000)
+
+    request = {
+        "method": "GET",
+        "path": "/admin/login/",
+        "body": b"",
+        "params": {},
+        "query": {},
+        "headers": {"host": "127.0.0.1:8000"},
+        "cookies": {},
+        "context": None,
+    }
+
+    status, headers, body = asyncio.run(handler.handle_request(request))
+
+    print(f"\n[ASGI Bridge Direct Test]")
+    print(f"Status: {status}")
+    print(f"Headers: {dict(headers)}")
+    print(f"Body length: {len(body)}")
+    print(f"Body preview: {body[:300]}")
+
+    # Validate structure
+    assert isinstance(status, int), f"Status should be int, got {type(status)}"
+    assert isinstance(headers, list), f"Headers should be list, got {type(headers)}"
+    assert isinstance(body, bytes), f"Body should be bytes, got {type(body)}"
+
+    # Should return 200 OK
+    assert status == 200, f"Expected 200, got {status}"
+
+    # CRITICAL TEST: Body should NOT be empty - THIS WILL FAIL IF BUG EXISTS
+    assert len(body) > 0, f"ASGI bridge returned EMPTY body! Expected HTML content. Body length: {len(body)}"
+
+    # Should be HTML content
+    body_text = body.decode('utf-8', errors='ignore')
+    assert 'html' in body_text.lower(), f"Expected HTML content, got: {body_text[:100]}"
+    assert 'django' in body_text.lower() or 'login' in body_text.lower(), f"Expected Django admin content"
+
+
+@pytest.mark.django_db
+def test_asgi_bridge_admin_root():
+    """Test ASGI bridge handles /admin/ root correctly."""
+    from django_bolt.admin.asgi_bridge import ASGIFallbackHandler
+    import asyncio
+
+    handler = ASGIFallbackHandler(server_host="127.0.0.1", server_port=8000)
+
+    request = {
+        "method": "GET",
+        "path": "/admin/",
+        "body": b"",
+        "params": {},
+        "query": {},
+        "headers": {"host": "127.0.0.1:8000"},
+        "cookies": {},
+        "context": None,
+    }
+
+    status, headers, body = asyncio.run(handler.handle_request(request))
+
+    # Should redirect to login
+    assert status in (301, 302), f"Expected redirect, got {status}"
+
+    # Should have location header
+    location = None
+    for name, value in headers:
+        if name.lower() == 'location':
+            location = value
+            break
+
+    assert location is not None, "Redirect should have Location header"
+    assert '/admin/login/' in location, f"Should redirect to login, got {location}"
+
+
+@pytest.mark.django_db
+def test_asgi_bridge_with_query_params():
+    """Test ASGI bridge handles query parameters correctly."""
+    from django_bolt.admin.asgi_bridge import ASGIFallbackHandler
+    import asyncio
+
+    handler = ASGIFallbackHandler(server_host="127.0.0.1", server_port=8000)
+
+    request = {
+        "method": "GET",
+        "path": "/admin/login/",
+        "body": b"",
+        "params": {},
+        "query": {"next": "/admin/"},
+        "headers": {"host": "127.0.0.1:8000"},
+        "cookies": {},
+        "context": None,
+    }
+
+    status, headers, body = asyncio.run(handler.handle_request(request))
+
+    # Should return 200 OK
+    assert status == 200, f"Expected 200, got {status}"
+    assert len(body) > 0, "Body should not be empty"
+
+
+@pytest.mark.django_db
+def test_asgi_bridge_post_request():
+    """Test ASGI bridge handles POST requests correctly."""
+    from django_bolt.admin.asgi_bridge import ASGIFallbackHandler
+    import asyncio
+
+    handler = ASGIFallbackHandler(server_host="127.0.0.1", server_port=8000)
+
+    # POST request with form data
+    form_data = b"username=admin&password=test123"
+
+    request = {
+        "method": "POST",
+        "path": "/admin/login/",
+        "body": form_data,
+        "params": {},
+        "query": {},
+        "headers": {
+            "host": "127.0.0.1:8000",
+            "content-type": "application/x-www-form-urlencoded",
+            "content-length": str(len(form_data)),
+        },
+        "cookies": {},
+        "context": None,
+    }
+
+    status, headers, body = asyncio.run(handler.handle_request(request))
+
+    # Should return response (even if login fails, it should process the request)
+    assert isinstance(status, int), f"Status should be int, got {type(status)}"
+    assert len(body) > 0, "Body should not be empty"
+
+
+@pytest.mark.django_db
+def test_asgi_bridge_404_path():
+    """Test ASGI bridge handles non-existent admin paths correctly."""
+    from django_bolt.admin.asgi_bridge import ASGIFallbackHandler
+    import asyncio
+
+    handler = ASGIFallbackHandler(server_host="127.0.0.1", server_port=8000)
+
+    request = {
+        "method": "GET",
+        "path": "/admin/nonexistent/path/",
+        "body": b"",
+        "params": {},
+        "query": {},
+        "headers": {"host": "127.0.0.1:8000"},
+        "cookies": {},
+        "context": None,
+    }
+
+    status, headers, body = asyncio.run(handler.handle_request(request))
+
+    # Django redirects unauthenticated users to login for non-existent admin paths
+    # This is expected Django admin behavior
+    assert status in (302, 404), f"Expected redirect or 404, got {status}"
+    assert len(body) >= 0, "Response should have structure"
+
+
+@pytest.mark.django_db
+def test_asgi_bridge_with_cookies():
+    """Test ASGI bridge handles cookies correctly."""
+    from django_bolt.admin.asgi_bridge import ASGIFallbackHandler
+    import asyncio
+
+    handler = ASGIFallbackHandler(server_host="127.0.0.1", server_port=8000)
+
+    request = {
+        "method": "GET",
+        "path": "/admin/login/",
+        "body": b"",
+        "params": {},
+        "query": {},
+        "headers": {
+            "host": "127.0.0.1:8000",
+            "cookie": "sessionid=abc123; csrftoken=xyz789",
+        },
+        "cookies": {
+            "sessionid": "abc123",
+            "csrftoken": "xyz789",
+        },
+        "context": None,
+    }
+
+    status, headers, body = asyncio.run(handler.handle_request(request))
+
+    # Should return 200 OK
+    assert status == 200, f"Expected 200, got {status}"
+    assert len(body) > 0, "Body should not be empty"
+
+    # Should set CSRF token cookie
+    has_csrf = False
+    for name, value in headers:
+        if name.lower() == 'set-cookie' and 'csrftoken' in value:
+            has_csrf = True
+            break
+
+    assert has_csrf, "Response should include CSRF token cookie"

django_bolt/tests/admin_tests/urls.py

@@ -0,0 +1,9 @@
+"""
+URL configuration for admin integration tests.
+"""
+from django.contrib import admin
+from django.urls import path
+
+urlpatterns = [
+    path('admin/', admin.site.urls),
+]