django-bolt 0.1.0__cp310-abi3-win_amd64.whl → 0.1.1__cp310-abi3-win_amd64.whl

django_bolt/tests/test_guards_integration.py

@@ -1,303 +0,0 @@
-"""
-Integration tests for guards and authentication with TestClient.
-
-Tests the full request flow including Rust-side authentication and guard evaluation.
-"""
-import jwt
-import time
-import pytest
-from django_bolt import BoltAPI
-from django_bolt.auth import JWTAuthentication, APIKeyAuthentication
-from django_bolt.auth import (
-    AllowAny, IsAuthenticated, IsAdminUser, IsStaff,
-    HasPermission, HasAnyPermission
-)
-from django_bolt.testing import TestClient
-
-
-def create_token(user_id="user123", is_staff=False, is_admin=False, permissions=None):
-    """Helper to create JWT tokens"""
-    payload = {
-        "sub": user_id,
-        "exp": int(time.time()) + 3600,
-        "iat": int(time.time()),
-        "is_staff": is_staff,
-        "is_superuser": is_admin,
-        "permissions": permissions or []
-    }
-    return jwt.encode(payload, "test-secret", algorithm="HS256")
-
-
-@pytest.fixture(scope="module")
-def api():
-    """Create test API with guards and authentication"""
-    # Setup Django
-    import django
-    from django.conf import settings
-    from django.core.management import call_command
-
-    if not settings.configured:
-        settings.configure(
-            DEBUG=True,
-            SECRET_KEY='test-secret-key-for-guards',
-            INSTALLED_APPS=[
-                'django.contrib.contenttypes',
-                'django.contrib.auth',
-                'django_bolt',
-            ],
-            DATABASES={
-                'default': {
-                    'ENGINE': 'django.db.backends.sqlite3',
-                    'NAME': ':memory:',
-                }
-            },
-            USE_TZ=True,
-        )
-        django.setup()
-        # Run migrations to create tables
-        call_command('migrate', '--run-syncdb', verbosity=0)
-
-    api = BoltAPI()
-
-    # Public endpoint with AllowAny
-    @api.get("/public", guards=[AllowAny()])
-    async def public_endpoint():
-        return {"message": "public", "auth": "not required"}
-
-    # Protected endpoint requiring authentication
-    @api.get(
-        "/protected",
-        auth=[JWTAuthentication(secret="test-secret")],
-        guards=[IsAuthenticated()]
-    )
-    async def protected_endpoint(request: dict):
-        context = request.get("context", {})
-        return {
-            "message": "protected",
-            "user_id": context.get("user_id"),
-            "is_staff": context.get("is_staff", False),
-            "is_admin": context.get("is_admin", False),
-        }
-
-    # Admin-only endpoint
-    @api.get(
-        "/admin",
-        auth=[JWTAuthentication(secret="test-secret")],
-        guards=[IsAdminUser()]
-    )
-    async def admin_endpoint(request: dict):
-        context = request["context"]
-        return {
-            "message": "admin area",
-            "user_id": context["user_id"],
-            "is_admin": context["is_admin"],
-        }
-
-    # Staff-only endpoint
-    @api.get(
-        "/staff",
-        auth=[JWTAuthentication(secret="test-secret")],
-        guards=[IsStaff()]
-    )
-    async def staff_endpoint(request: dict):
-        return {
-            "message": "staff area",
-            "user_id": request["context"]["user_id"],
-        }
-
-    # Permission-required endpoint
-    @api.get(
-        "/delete-users",
-        auth=[JWTAuthentication(secret="test-secret")],
-        guards=[HasPermission("users.delete")]
-    )
-    async def delete_users_endpoint():
-        return {"message": "deleting users"}
-
-    # Multiple permissions (any)
-    @api.get(
-        "/moderate",
-        auth=[JWTAuthentication(secret="test-secret")],
-        guards=[HasAnyPermission("users.moderate", "posts.moderate")]
-    )
-    async def moderate_endpoint():
-        return {"message": "moderating content"}
-
-    # API key authentication
-    @api.get(
-        "/api-endpoint",
-        auth=[APIKeyAuthentication(api_keys={"valid-key-123", "valid-key-456"})],
-        guards=[IsAuthenticated()]
-    )
-    async def api_key_endpoint(request: dict):
-        return {
-            "message": "API key valid",
-            "user_id": request["context"].get("user_id"),
-            "backend": request["context"].get("auth_backend"),
-        }
-
-    # Full context inspection endpoint
-    @api.get(
-        "/context",
-        auth=[JWTAuthentication(secret="test-secret")],
-        guards=[IsAuthenticated()]
-    )
-    async def context_endpoint(request: dict):
-        context = request.get("context", {})
-        return {
-            "context_keys": list(context.keys()) if hasattr(context, 'keys') else [],
-            "user_id": context.get("user_id"),
-            "is_staff": context.get("is_staff"),
-            "is_admin": context.get("is_admin"),
-            "auth_backend": context.get("auth_backend"),
-            "has_claims": "auth_claims" in context,
-            "has_permissions": "permissions" in context,
-        }
-
-    return api
-
-
-@pytest.fixture(scope="module")
-def client(api):
-    """Create TestClient for the API"""
-    with TestClient(api) as client:
-        yield client
-
-
-def test_public_endpoint(client):
-    """Test public endpoint (AllowAny)"""
-    response = client.get("/public")
-    assert response.status_code == 200
-    assert response.json()["auth"] == "not required"
-
-
-def test_protected_endpoint_without_token(client):
-    """Test protected endpoint without token (should fail with 401)"""
-    response = client.get("/protected")
-    assert response.status_code == 401
-
-
-def test_protected_endpoint_with_valid_token(client):
-    """Test protected endpoint with valid token"""
-    token = create_token(user_id="user123")
-    response = client.get("/protected", headers={"Authorization": f"Bearer {token}"})
-    assert response.status_code == 200
-    data = response.json()
-    assert data["message"] == "protected"
-    assert data["user_id"] == "user123"
-
-
-def test_admin_endpoint_with_non_admin_token(client):
-    """Test admin endpoint with non-admin token (should fail with 403)"""
-    token = create_token(user_id="regular-user", is_admin=False)
-    response = client.get("/admin", headers={"Authorization": f"Bearer {token}"})
-    assert response.status_code == 403
-
-
-def test_admin_endpoint_with_admin_token(client):
-    """Test admin endpoint with admin token"""
-    token = create_token(user_id="admin-user", is_admin=True)
-    response = client.get("/admin", headers={"Authorization": f"Bearer {token}"})
-    assert response.status_code == 200
-    data = response.json()
-    assert data["message"] == "admin area"
-    assert data["is_admin"] is True
-
-
-def test_staff_endpoint_with_non_staff_token(client):
-    """Test staff endpoint with non-staff token"""
-    token = create_token(user_id="regular-user", is_staff=False)
-    response = client.get("/staff", headers={"Authorization": f"Bearer {token}"})
-    assert response.status_code == 403
-
-
-def test_staff_endpoint_with_staff_token(client):
-    """Test staff endpoint with staff token"""
-    token = create_token(user_id="staff-user", is_staff=True)
-    response = client.get("/staff", headers={"Authorization": f"Bearer {token}"})
-    assert response.status_code == 200
-    data = response.json()
-    assert data["message"] == "staff area"
-
-
-def test_permission_based_endpoint_without_permission(client):
-    """Test permission-based endpoint without required permission"""
-    token = create_token(user_id="user-no-perms", permissions=[])
-    response = client.get("/delete-users", headers={"Authorization": f"Bearer {token}"})
-    assert response.status_code == 403
-
-
-def test_permission_based_endpoint_with_permission(client):
-    """Test permission-based endpoint with required permission"""
-    token = create_token(user_id="user-with-perms", permissions=["users.delete"])
-    response = client.get("/delete-users", headers={"Authorization": f"Bearer {token}"})
-    assert response.status_code == 200
-    assert response.json()["message"] == "deleting users"
-
-
-def test_has_any_permission_with_one_match(client):
-    """Test HasAnyPermission guard with one matching permission"""
-    token = create_token(user_id="moderator", permissions=["users.moderate"])
-    response = client.get("/moderate", headers={"Authorization": f"Bearer {token}"})
-    assert response.status_code == 200
-    assert response.json()["message"] == "moderating content"
-
-
-def test_has_any_permission_without_match(client):
-    """Test HasAnyPermission guard without any matching permission"""
-    token = create_token(user_id="user", permissions=["other.permission"])
-    response = client.get("/moderate", headers={"Authorization": f"Bearer {token}"})
-    assert response.status_code == 403
-
-
-def test_api_key_authentication_without_key(client):
-    """Test API key authentication without key"""
-    response = client.get("/api-endpoint")
-    assert response.status_code == 401
-
-
-def test_api_key_authentication_with_valid_key(client):
-    """Test API key authentication with valid key"""
-    response = client.get("/api-endpoint", headers={"X-API-Key": "valid-key-123"})
-    assert response.status_code == 200
-    data = response.json()
-    assert data["message"] == "API key valid"
-
-
-def test_api_key_authentication_with_invalid_key(client):
-    """Test API key authentication with invalid key"""
-    response = client.get("/api-endpoint", headers={"X-API-Key": "invalid-key"})
-    assert response.status_code == 401
-
-
-def test_context_population(client):
-    """Test that context is properly populated"""
-    token = create_token(user_id="context-user", is_staff=True, permissions=["test.permission"])
-    response = client.get("/context", headers={"Authorization": f"Bearer {token}"})
-    assert response.status_code == 200
-    data = response.json()
-    assert data["user_id"] == "context-user"
-    assert data["is_staff"] is True
-    assert "context_keys" in data
-
-
-def test_invalid_jwt_signature(client):
-    """Test invalid JWT signature"""
-    token = jwt.encode(
-        {"sub": "user123", "exp": int(time.time()) + 3600},
-        "wrong-secret",  # Different secret
-        algorithm="HS256"
-    )
-    response = client.get("/protected", headers={"Authorization": f"Bearer {token}"})
-    assert response.status_code == 401
-
-
-def test_expired_jwt_token(client):
-    """Test expired JWT token"""
-    token = jwt.encode(
-        {"sub": "user123", "exp": int(time.time()) - 3600},  # Expired
-        "test-secret",
-        algorithm="HS256"
-    )
-    response = client.get("/protected", headers={"Authorization": f"Bearer {token}"})
-    assert response.status_code == 401

django_bolt/tests/test_health.py

@@ -1,283 +0,0 @@
-"""Tests for Django-Bolt health check system."""
-
-import pytest
-import asyncio
-from django_bolt.health import (
-    HealthCheck,
-    check_database,
-    health_handler,
-    ready_handler,
-    add_health_check,
-    register_health_checks,
-)
-
-
-class TestHealthCheck:
-    """Test HealthCheck class."""
-
-    def test_health_check_initialization(self):
-        """Test HealthCheck initialization."""
-        hc = HealthCheck()
-        assert hc._checks == []
-
-    def test_add_check(self):
-        """Test adding custom health checks."""
-        hc = HealthCheck()
-
-        async def custom_check():
-            return True, "OK"
-
-        hc.add_check(custom_check)
-        assert len(hc._checks) == 1
-        assert hc._checks[0] == custom_check
-
-    @pytest.mark.asyncio
-    async def test_run_checks_all_healthy(self):
-        """Test run_checks when all checks pass."""
-        hc = HealthCheck()
-
-        async def check1():
-            return True, "Check 1 OK"
-
-        async def check2():
-            return True, "Check 2 OK"
-
-        hc.add_check(check1)
-        hc.add_check(check2)
-
-        results = await hc.run_checks()
-        assert results["status"] == "healthy"
-        assert "check1" in results["checks"]
-        assert "check2" in results["checks"]
-        assert results["checks"]["check1"]["healthy"] is True
-        assert results["checks"]["check2"]["healthy"] is True
-
-    @pytest.mark.asyncio
-    async def test_run_checks_one_unhealthy(self):
-        """Test run_checks when one check fails."""
-        hc = HealthCheck()
-
-        async def check1():
-            return True, "Check 1 OK"
-
-        async def check2():
-            return False, "Check 2 failed"
-
-        hc.add_check(check1)
-        hc.add_check(check2)
-
-        results = await hc.run_checks()
-        assert results["status"] == "unhealthy"
-        assert results["checks"]["check1"]["healthy"] is True
-        assert results["checks"]["check2"]["healthy"] is False
-        assert "failed" in results["checks"]["check2"]["message"]
-
-    @pytest.mark.asyncio
-    async def test_run_checks_exception_handling(self):
-        """Test run_checks handles exceptions in checks."""
-        hc = HealthCheck()
-
-        async def failing_check():
-            raise RuntimeError("Check crashed")
-
-        hc.add_check(failing_check)
-
-        results = await hc.run_checks()
-        assert results["status"] == "unhealthy"
-        assert results["checks"]["failing_check"]["healthy"] is False
-        assert "Check crashed" in results["checks"]["failing_check"]["message"]
-
-
-class TestDatabaseCheck:
-    """Test database health check."""
-
-    @pytest.mark.asyncio
-    async def test_check_database_success(self):
-        """Test database check succeeds with valid connection."""
-        # This test requires Django to be configured
-        try:
-            from django.conf import settings
-            if not settings.configured:
-                pytest.skip("Django not configured")
-
-            healthy, message = await check_database()
-            # Should either succeed or fail gracefully
-            assert isinstance(healthy, bool)
-            assert isinstance(message, str)
-        except ImportError:
-            pytest.skip("Django not available")
-
-    @pytest.mark.asyncio
-    async def test_check_database_handles_error(self):
-        """Test database check handles connection errors."""
-        # Even if database is not available, check should not raise
-        try:
-            healthy, message = await check_database()
-            assert isinstance(healthy, bool)
-            assert isinstance(message, str)
-        except Exception:
-            pytest.fail("check_database should not raise exceptions")
-
-
-class TestHealthHandlers:
-    """Test health endpoint handlers."""
-
-    @pytest.mark.asyncio
-    async def test_health_handler(self):
-        """Test basic health endpoint."""
-        result = await health_handler()
-        assert isinstance(result, dict)
-        assert result["status"] == "ok"
-
-    @pytest.mark.asyncio
-    async def test_ready_handler(self):
-        """Test readiness endpoint."""
-        result = await ready_handler()
-        assert isinstance(result, dict)
-        assert "status" in result
-        assert "checks" in result
-        # Status should be healthy or unhealthy
-        assert result["status"] in ["healthy", "unhealthy"]
-
-
-class TestHealthIntegration:
-    """Integration tests for health checks."""
-
-    def test_register_health_checks(self):
-        """Test registering health checks on API."""
-        from django_bolt import BoltAPI
-
-        api = BoltAPI()
-        initial_route_count = len(api._routes)
-
-        register_health_checks(api)
-
-        # Check that routes were registered (should have 2 more routes)
-        assert len(api._routes) == initial_route_count + 2
-
-        # Check handler names contain health/ready
-        handlers = [api._handlers[route[2]] for route in api._routes[initial_route_count:]]
-        handler_names = [h.__name__ for h in handlers]
-        assert "health_handler" in handler_names
-        assert "ready_handler" in handler_names
-
-    def test_add_health_check_global(self):
-        """Test adding global health check."""
-        async def custom_check():
-            return True, "Custom check OK"
-
-        add_health_check(custom_check)
-
-        # Check should be added to global instance
-        from django_bolt.health import _health_check
-        assert custom_check in _health_check._checks
-
-        # Clean up
-        _health_check._checks.remove(custom_check)
-
-    @pytest.mark.asyncio
-    async def test_custom_health_check_integration(self):
-        """Test custom health check integration."""
-        from django_bolt.health import _health_check
-
-        # Clear existing checks
-        original_checks = _health_check._checks.copy()
-        _health_check._checks.clear()
-
-        # Add custom check
-        async def redis_check():
-            # Simulate Redis check
-            return True, "Redis OK"
-
-        add_health_check(redis_check)
-
-        # Run ready handler
-        result = await ready_handler()
-        assert result["status"] == "healthy"
-        assert "redis_check" in result["checks"]
-        assert result["checks"]["redis_check"]["healthy"] is True
-
-        # Restore original checks
-        _health_check._checks = original_checks
-
-
-class TestHealthCheckScenarios:
-    """Test real-world health check scenarios."""
-
-    @pytest.mark.asyncio
-    async def test_multiple_services_all_healthy(self):
-        """Test health check with multiple healthy services."""
-        hc = HealthCheck()
-
-        async def check_database():
-            return True, "Database OK"
-
-        async def check_redis():
-            return True, "Redis OK"
-
-        async def check_queue():
-            return True, "Queue OK"
-
-        hc.add_check(check_database)
-        hc.add_check(check_redis)
-        hc.add_check(check_queue)
-
-        results = await hc.run_checks()
-        assert results["status"] == "healthy"
-        assert len(results["checks"]) == 3
-
-    @pytest.mark.asyncio
-    async def test_multiple_services_one_degraded(self):
-        """Test health check with one degraded service."""
-        hc = HealthCheck()
-
-        async def check_database():
-            return True, "Database OK"
-
-        async def check_redis():
-            return False, "Redis connection timeout"
-
-        async def check_queue():
-            return True, "Queue OK"
-
-        hc.add_check(check_database)
-        hc.add_check(check_redis)
-        hc.add_check(check_queue)
-
-        results = await hc.run_checks()
-        assert results["status"] == "unhealthy"
-        assert results["checks"]["check_database"]["healthy"] is True
-        assert results["checks"]["check_redis"]["healthy"] is False
-        assert results["checks"]["check_queue"]["healthy"] is True
-
-    @pytest.mark.asyncio
-    async def test_async_check_performance(self):
-        """Test that async checks run concurrently."""
-        hc = HealthCheck()
-        import time
-
-        start_time = time.time()
-
-        async def slow_check1():
-            await asyncio.sleep(0.1)
-            return True, "Check 1 OK"
-
-        async def slow_check2():
-            await asyncio.sleep(0.1)
-            return True, "Check 2 OK"
-
-        hc.add_check(slow_check1)
-        hc.add_check(slow_check2)
-
-        results = await hc.run_checks()
-        elapsed = time.time() - start_time
-
-        # If checks run sequentially, would take ~0.2s
-        # If checks run concurrently, should take ~0.1s
-        # We're currently running sequentially, so this will be >0.15s
-        # TODO: Optimize to run checks concurrently
-        assert elapsed < 0.3  # Just check it completes reasonably fast
-
-
-if __name__ == "__main__":
-    pytest.main([__file__, "-v"])