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

django_bolt/tests/test_file_response.py

@@ -1,192 +0,0 @@
-import os
-import tempfile
-import pytest
-
-from django_bolt import BoltAPI
-from django_bolt.responses import FileResponse
-from django_bolt.testing import TestClient
-
-
-# Create test files once at module level
-TEST_DIR = tempfile.mkdtemp()
-
-# Small file (< 10MB) - 1KB
-SMALL_FILE = os.path.join(TEST_DIR, "small_file.txt")
-with open(SMALL_FILE, "w") as f:
-    f.write("x" * 1024)
-
-# Medium file (< 10MB) - 1MB
-MEDIUM_FILE = os.path.join(TEST_DIR, "medium_file.txt")
-with open(MEDIUM_FILE, "w") as f:
-    f.write("y" * (1024 * 1024))
-
-# Large file (> 10MB) - 11MB
-LARGE_FILE = os.path.join(TEST_DIR, "large_file.bin")
-with open(LARGE_FILE, "wb") as f:
-    f.write(b"z" * (11 * 1024 * 1024))
-
-
-@pytest.fixture(scope="module")
-def api():
-    """Create test API with file endpoints"""
-    api = BoltAPI()
-
-    @api.get("/file/small")
-    async def get_small_file():
-        """Small file should be read into memory"""
-        return FileResponse(SMALL_FILE, filename="small_file.txt")
-
-    @api.get("/file/medium")
-    async def get_medium_file():
-        """Medium file should be read into memory"""
-        return FileResponse(MEDIUM_FILE, filename="medium_file.txt")
-
-    @api.get("/file/large")
-    async def get_large_file():
-        """Large file should be streamed"""
-        return FileResponse(LARGE_FILE, filename="large_file.bin")
-
-    @api.get("/file/custom-headers")
-    async def get_file_with_headers():
-        """Test custom headers"""
-        return FileResponse(
-            SMALL_FILE,
-            filename="custom.txt",
-            headers={"X-Custom-Header": "test-value"}
-        )
-
-    @api.get("/file/custom-media-type")
-    async def get_file_with_media_type():
-        """Test custom media type"""
-        return FileResponse(
-            SMALL_FILE,
-            media_type="application/octet-stream"
-        )
-
-    return api
-
-
-@pytest.fixture(scope="module")
-def client(api):
-    """Create test client with HTTP layer enabled to test file serving"""
-    # use_http_layer=True enables full HTTP stack including file serving
-    return TestClient(api, use_http_layer=True)
-
-
-def test_small_file_response(client):
-    """Test that small files (<10MB) work correctly"""
-    response = client.get("/file/small")
-
-    # Should succeed
-    assert response.status_code == 200
-
-    # Should have correct Content-Type
-    assert response.headers.get("content-type", "").startswith("text/")
-
-    # Should have Content-Disposition with filename
-    content_disp = response.headers.get("content-disposition", "")
-    assert "attachment" in content_disp.lower()
-    assert "small_file.txt" in content_disp
-
-    # With HTTP layer, we should get the file content
-    if response.content:
-        assert len(response.content) == 1024
-        assert response.content == b"x" * 1024
-
-
-def test_medium_file_response(client):
-    """Test that medium files (<10MB) work correctly"""
-    response = client.get("/file/medium")
-
-    # Should succeed
-    assert response.status_code == 200
-
-    # With HTTP layer, content should be available
-    if response.content:
-        assert len(response.content) == 1024 * 1024
-        assert response.content[:100] == b"y" * 100
-        assert response.content[-100:] == b"y" * 100
-
-
-def test_large_file_response(client):
-    """Test that large files (>10MB) are streamed"""
-    response = client.get("/file/large")
-
-    # Should succeed
-    assert response.status_code == 200
-
-    # Large files use streaming
-    # TestClient may not preserve the full streamed content, so just verify response is successful
-    # In production, streaming works correctly
-    # Content should be available (even if TestClient doesn't show full stream)
-    assert response.content is not None
-
-
-def test_file_custom_headers(client):
-    """Test FileResponse with custom headers"""
-    response = client.get("/file/custom-headers")
-    
-    assert response.status_code == 200
-    assert response.headers.get("x-custom-header") == "test-value"
-    assert "custom.txt" in response.headers.get("content-disposition", "")
-
-
-def test_file_custom_media_type(client):
-    """Test FileResponse with custom media type"""
-    response = client.get("/file/custom-media-type")
-    
-    assert response.status_code == 200
-    assert response.headers.get("content-type") == "application/octet-stream"
-
-
-def test_file_not_found():
-    """Test FileResponse with non-existent file returns 404"""
-    api = BoltAPI()
-
-    @api.get("/file/nonexistent")
-    async def get_nonexistent():
-        return FileResponse("/path/to/nonexistent/file.txt")
-
-    # Use HTTP layer to test actual file opening
-    client = TestClient(api, use_http_layer=True)
-    response = client.get("/file/nonexistent")
-
-    # Should return 404 Not Found (proper HTTP status for missing file)
-    # File error happens in Rust after Python serializes the response
-    assert response.status_code == 404
-    assert b"File not found" in response.content or response.content == b""
-
-
-def test_file_performance_small_vs_large():
-    """Test that small files use in-memory buffering for better performance"""
-    import time
-    
-    api = BoltAPI()
-    temp_dir = tempfile.mkdtemp()
-    
-    # Create small file
-    small_file = os.path.join(temp_dir, "perf_small.txt")
-    with open(small_file, "w") as f:
-        f.write("x" * (100 * 1024))  # 100KB
-    
-    @api.get("/perf/small")
-    async def perf_small():
-        return FileResponse(small_file)
-    
-    client = TestClient(api)
-    
-    # Warm up
-    client.get("/perf/small")
-    
-    # Time multiple requests
-    start = time.time()
-    for _ in range(100):
-        response = client.get("/perf/small")
-        assert response.status_code == 200
-    elapsed = time.time() - start
-    
-    # Should handle 100 requests relatively quickly
-    # (This is more of a smoke test than a strict perf test)
-    assert elapsed < 5.0  # Should take less than 5 seconds for 100 requests
-    
-    print(f"Small file (100KB) - 100 requests: {elapsed:.3f}s ({100/elapsed:.1f} RPS)")

django_bolt/tests/test_global_cors.py

@@ -1,172 +0,0 @@
-"""Tests for global CORS origins fallback functionality."""
-
-import pytest
-from django_bolt import BoltAPI
-from django_bolt.middleware import cors
-from django_bolt.testing import TestClient
-
-
-def test_cors_uses_global_origins_when_no_route_config():
-    """Test that global CORS origins are used when route has no specific config."""
-    api = BoltAPI()
-
-    # Route without CORS config (should use global) but with middleware enabled
-    @api.get("/no-cors-config")
-    @cors()  # Empty CORS config - should use global
-    async def no_cors_endpoint():
-        return {"message": "hello"}
-
-    # Configure global CORS origins
-    global_origins = ["https://example.com", "https://trusted.com"]
-
-    with TestClient(api, use_http_layer=True, cors_allowed_origins=global_origins) as client:
-        response = client.get(
-            "/no-cors-config",
-            headers={"Origin": "https://example.com"}
-        )
-        assert response.status_code == 200
-        assert response.headers.get("Access-Control-Allow-Origin") == "https://example.com"
-
-
-def test_cors_route_config_overrides_global():
-    """Test that route-specific CORS config takes precedence over global."""
-    api = BoltAPI()
-
-    # Route with specific CORS config (should override global)
-    @api.get("/with-cors-config")
-    @cors(origins=["https://custom.com", "https://other.com"])
-    async def with_cors_endpoint():
-        return {"message": "hello"}
-
-    # Global config has different origins
-    global_origins = ["https://example.com", "https://trusted.com"]
-
-    with TestClient(api, use_http_layer=True, cors_allowed_origins=global_origins) as client:
-        response = client.get(
-            "/with-cors-config",
-            headers={"Origin": "https://custom.com"}
-        )
-        assert response.status_code == 200
-        assert response.headers.get("Access-Control-Allow-Origin") == "https://custom.com"
-
-
-def test_cors_rejects_unlisted_origin_with_global_config():
-    """Test that unlisted origins are rejected even with global config."""
-    api = BoltAPI()
-
-    @api.get("/no-cors-config")
-    @cors()  # Empty CORS config - should use global
-    async def endpoint():
-        return {"message": "hello"}
-
-    global_origins = ["https://example.com", "https://trusted.com"]
-
-    with TestClient(api, use_http_layer=True, cors_allowed_origins=global_origins) as client:
-        response = client.get(
-            "/no-cors-config",
-            headers={"Origin": "https://evil.com"}
-        )
-        # Should not have CORS headers for unlisted origin
-        assert "Access-Control-Allow-Origin" not in response.headers
-
-
-def test_cors_allows_wildcard_in_global_config():
-    """Test that wildcard in global config allows any origin."""
-    api = BoltAPI()
-
-    @api.get("/no-cors-config")
-    @cors()  # Empty CORS config - should use global
-    async def endpoint():
-        return {"message": "hello"}
-
-    # Wildcard in global config
-    global_origins = ["*"]
-
-    with TestClient(api, use_http_layer=True, cors_allowed_origins=global_origins) as client:
-        response = client.get(
-            "/no-cors-config",
-            headers={"Origin": "https://any-domain.com"}
-        )
-        assert response.status_code == 200
-        assert response.headers.get("Access-Control-Allow-Origin") == "*"
-
-
-def test_cors_empty_global_config_no_headers():
-    """Test that no CORS headers are added when global config is empty and no route config."""
-    api = BoltAPI()
-
-    @api.get("/no-cors-config")
-    async def endpoint():
-        return {"message": "hello"}
-
-    # Empty global origins, no route middleware
-    with TestClient(api, use_http_layer=True, cors_allowed_origins=[]) as client:
-        response = client.get(
-            "/no-cors-config",
-            headers={"Origin": "https://example.com"}
-        )
-        assert "Access-Control-Allow-Origin" not in response.headers
-
-
-def test_cors_middleware_enabled_but_no_origins_configured():
-    """Test that when CORS middleware is enabled but no origins configured, requests succeed but have no headers."""
-    api = BoltAPI()
-
-    @api.get("/cors-no-origins")
-    @cors()  # CORS enabled but no origins in decorator and no global
-    async def endpoint():
-        return {"message": "hello"}
-
-    # No global origins
-    with TestClient(api, use_http_layer=True, cors_allowed_origins=[]) as client:
-        # Regular request with Origin header
-        response = client.get(
-            "/cors-no-origins",
-            headers={"Origin": "https://example.com"}
-        )
-        # Request succeeds but no CORS headers
-        assert response.status_code == 200
-        assert "Access-Control-Allow-Origin" not in response.headers
-
-        # Preflight should be rejected
-        preflight = client.options(
-            "/cors-no-origins",
-            headers={
-                "Origin": "https://example.com",
-                "Access-Control-Request-Method": "GET",
-            }
-        )
-        # Preflight is rejected with 403
-        assert preflight.status_code == 403
-
-
-def test_preflight_uses_global_origins():
-    """Test that preflight requests use global origins."""
-    api = BoltAPI()
-
-    @api.post("/no-cors-config")
-    @cors()  # Empty CORS config - should use global
-    async def endpoint():
-        return {"message": "hello"}
-
-    # Also need to register OPTIONS handler or it will be auto-generated
-    @api.options("/no-cors-config")
-    @cors()  # Empty CORS config - should use global
-    async def options_endpoint():
-        return {"message": "options"}
-
-    global_origins = ["https://example.com", "https://trusted.com"]
-
-    with TestClient(api, use_http_layer=True, cors_allowed_origins=global_origins) as client:
-        response = client.options(
-            "/no-cors-config",
-            headers={
-                "Origin": "https://example.com",
-                "Access-Control-Request-Method": "POST",
-                "Access-Control-Request-Headers": "Content-Type"
-            }
-        )
-        # Preflight is intercepted by CORS middleware and returns 204
-        assert response.status_code == 204
-        assert response.headers.get("Access-Control-Allow-Origin") == "https://example.com"
-        assert "POST" in response.headers.get("Access-Control-Allow-Methods", "")