django-bolt 0.1.0__cp310-abi3-win_amd64.whl

django_bolt/tests/test_testing_utilities.py

@@ -0,0 +1,163 @@
+"""Tests for django-bolt testing utilities.
+
+This file tests the TestClient (V2) that routes through Rust with per-instance state.
+"""
+import pytest
+from django_bolt import BoltAPI
+from django_bolt.testing import TestClient, AsyncTestClient
+
+
+def test_simple_get_request():
+    """Test basic GET request with TestClient."""
+    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"}
+
+
+def test_path_parameters():
+    """Test path parameters extraction."""
+    api = BoltAPI()
+
+    @api.get("/users/{user_id}")
+    async def get_user(user_id: int):
+        return {"id": user_id, "name": f"User {user_id}"}
+
+    with TestClient(api) as client:
+        response = client.get("/users/123")
+        assert response.status_code == 200
+        data = response.json()
+        assert data["id"] == 123
+        assert data["name"] == "User 123"
+
+
+def test_query_parameters():
+    """Test query parameters extraction."""
+    api = BoltAPI()
+
+    @api.get("/search")
+    async def search(q: str, limit: int = 10):
+        return {"query": q, "limit": limit}
+
+    with TestClient(api) as client:
+        response = client.get("/search?q=test&limit=20")
+        assert response.status_code == 200
+        data = response.json()
+        assert data["query"] == "test"
+        assert data["limit"] == 20
+
+
+def test_post_with_body():
+    """Test POST with JSON body."""
+    import msgspec
+
+    class UserCreate(msgspec.Struct):
+        name: str
+        email: str
+
+    api = BoltAPI()
+
+    @api.post("/users")
+    async def create_user(user: UserCreate):
+        return {"id": 1, "name": user.name, "email": user.email}
+
+    with TestClient(api) as client:
+        response = client.post("/users", json={"name": "John", "email": "john@example.com"})
+        assert response.status_code == 200
+        data = response.json()
+        assert data["id"] == 1
+        assert data["name"] == "John"
+        assert data["email"] == "john@example.com"
+
+
+def test_404_not_found():
+    """Test 404 for non-existent route."""
+    api = BoltAPI()
+
+    @api.get("/hello")
+    async def hello():
+        return {"message": "world"}
+
+    with TestClient(api) as client:
+        response = client.get("/nonexistent")
+        assert response.status_code == 404
+
+
+def test_multiple_methods():
+    """Test different HTTP methods on same path."""
+    api = BoltAPI()
+
+    @api.get("/resource")
+    async def get_resource():
+        return {"method": "GET"}
+
+    @api.post("/resource")
+    async def create_resource():
+        return {"method": "POST"}
+
+    @api.put("/resource")
+    async def update_resource():
+        return {"method": "PUT"}
+
+    @api.delete("/resource")
+    async def delete_resource():
+        return {"method": "DELETE"}
+
+    with TestClient(api) as client:
+        assert client.get("/resource").json() == {"method": "GET"}
+        assert client.post("/resource").json() == {"method": "POST"}
+        assert client.put("/resource").json() == {"method": "PUT"}
+        assert client.delete("/resource").json() == {"method": "DELETE"}
+
+
+@pytest.mark.skip(reason="AsyncTestClient has event loop conflict - needs refactoring for nested event loops")
+@pytest.mark.asyncio
+async def test_async_client():
+    """Test AsyncTestClient."""
+    api = BoltAPI()
+
+    @api.get("/hello")
+    async def hello():
+        return {"message": "async world"}
+
+    async with AsyncTestClient(api) as client:
+        response = await client.get("/hello")
+        assert response.status_code == 200
+        assert response.json() == {"message": "async world"}
+
+
+def test_headers():
+    """Test request headers."""
+    from django_bolt.param_functions import Header
+    from typing import Annotated
+
+    api = BoltAPI()
+
+    @api.get("/with-header")
+    async def with_header(x_custom: Annotated[str, Header()]):
+        return {"header_value": x_custom}
+
+    with TestClient(api) as client:
+        response = client.get("/with-header", headers={"X-Custom": "test-value"})
+        assert response.status_code == 200
+        assert response.json() == {"header_value": "test-value"}
+
+
+def test_status_code():
+    """Test custom status codes."""
+    api = BoltAPI()
+
+    @api.post("/created", status_code=201)
+    async def create():
+        return {"created": True}
+
+    with TestClient(api) as client:
+        response = client.post("/created")
+        assert response.status_code == 201
+        assert response.json() == {"created": True}

django_bolt/tests/test_testing_utilities_simple.py

@@ -0,0 +1,123 @@
+"""Simple test for django-bolt testing utilities.
+
+Tests the new TestClient in a single comprehensive test to avoid
+router re-initialization issues (the Rust global router can only be set once).
+"""
+import msgspec
+from typing import Annotated
+from django_bolt import BoltAPI
+from django_bolt.testing import TestClient
+from django_bolt.param_functions import Header
+
+
+def test_test_client_comprehensive():
+    """Comprehensive test of TestClient functionality."""
+    api = BoltAPI()
+
+    # Test 1: Simple GET
+    @api.get("/hello")
+    async def hello():
+        return {"message": "world"}
+
+    # Test 2: Path parameters
+    @api.get("/users/{user_id}")
+    async def get_user(user_id: int):
+        return {"id": user_id, "name": f"User {user_id}"}
+
+    # Test 3: Query parameters
+    @api.get("/search")
+    async def search(q: str, limit: int = 10):
+        return {"query": q, "limit": limit}
+
+    # Test 4: POST with body
+    class UserCreate(msgspec.Struct):
+        name: str
+        email: str
+
+    @api.post("/users")
+    async def create_user(user: UserCreate):
+        return {"id": 1, "name": user.name, "email": user.email}
+
+    # Test 5: Headers
+    @api.get("/with-header")
+    async def with_header(x_custom: Annotated[str, Header()]):
+        return {"header_value": x_custom}
+
+    # Test 6: Custom status code
+    @api.post("/created", status_code=201)
+    async def create():
+        return {"created": True}
+
+    # Test 7: Different methods on same path
+    @api.get("/resource")
+    async def get_resource():
+        return {"method": "GET"}
+
+    @api.post("/resource")
+    async def create_resource():
+        return {"method": "POST"}
+
+    # Now run all tests using one client
+    with TestClient(api) as client:
+        # Test 1: Simple GET
+        response = client.get("/hello")
+        assert response.status_code == 200
+        assert response.json() == {"message": "world"}
+        print("✓ Simple GET works")
+
+        # Test 2: Path parameters
+        response = client.get("/users/123")
+        assert response.status_code == 200
+        data = response.json()
+        assert data["id"] == 123
+        assert data["name"] == "User 123"
+        print("✓ Path parameters work")
+
+        # Test 3: Query parameters
+        response = client.get("/search?q=test&limit=20")
+        assert response.status_code == 200
+        data = response.json()
+        assert data["query"] == "test"
+        assert data["limit"] == 20
+        print("✓ Query parameters work")
+
+        # Test 3b: Query parameters with defaults
+        response = client.get("/search?q=test2")
+        assert response.status_code == 200
+        data = response.json()
+        assert data["query"] == "test2"
+        assert data["limit"] == 10
+        print("✓ Query parameters with defaults work")
+
+        # Test 4: POST with JSON body
+        response = client.post("/users", json={"name": "John", "email": "john@example.com"})
+        assert response.status_code == 200
+        data = response.json()
+        assert data["id"] == 1
+        assert data["name"] == "John"
+        assert data["email"] == "john@example.com"
+        print("✓ POST with JSON body works")
+
+        # Test 5: Headers
+        response = client.get("/with-header", headers={"X-Custom": "test-value"})
+        assert response.status_code == 200
+        assert response.json() == {"header_value": "test-value"}
+        print("✓ Headers work")
+
+        # Test 6: Custom status code
+        response = client.post("/created")
+        assert response.status_code == 201
+        assert response.json() == {"created": True}
+        print("✓ Custom status codes work")
+
+        # Test 7: Different methods
+        assert client.get("/resource").json() == {"method": "GET"}
+        assert client.post("/resource").json() == {"method": "POST"}
+        print("✓ Multiple HTTP methods work")
+
+        # Test 8: 404
+        response = client.get("/nonexistent")
+        assert response.status_code == 404
+        print("✓ 404 for non-existent routes works")
+
+    print("\n✅ All test client features working correctly!")

django_bolt/tests/test_viewset_unified.py

@@ -0,0 +1,346 @@
+"""
+Tests for unified ViewSet pattern with api.viewset() (Litestar/DRF-inspired).
+
+This test suite verifies that the new unified ViewSet pattern works correctly:
+- Single ViewSet for both list and detail views
+- DRF-style action methods (list, retrieve, create, update, partial_update, destroy)
+- Automatic route generation with api.viewset()
+- Different serializers for list vs detail (list_serializer_class)
+- Type-driven serialization
+"""
+import pytest
+import msgspec
+from django_bolt import BoltAPI, ViewSet, action
+from django_bolt.testing import TestClient
+from .test_models import Article
+
+
+# --- Schemas ---
+
+class ArticleFullSchema(msgspec.Struct):
+    """Full article schema for detail views."""
+    id: int
+    title: str
+    content: str
+    author: str
+    is_published: bool
+
+    @classmethod
+    def from_model(cls, obj):
+        return cls(
+            id=obj.id,
+            title=obj.title,
+            content=obj.content,
+            author=obj.author,
+            is_published=obj.is_published,
+        )
+
+
+class ArticleMiniSchema(msgspec.Struct):
+    """Minimal article schema for list views."""
+    id: int
+    title: str
+
+    @classmethod
+    def from_model(cls, obj):
+        return cls(id=obj.id, title=obj.title)
+
+
+class ArticleCreateSchema(msgspec.Struct):
+    """Schema for creating articles."""
+    title: str
+    content: str
+    author: str
+
+
+class ArticleUpdateSchema(msgspec.Struct):
+    """Schema for updating articles."""
+    title: str | None = None
+    content: str | None = None
+    author: str | None = None
+
+
+# --- Tests ---
+
+@pytest.mark.django_db(transaction=True)
+def test_unified_viewset_basic_crud(api):
+    """Test unified ViewSet with basic CRUD operations."""
+
+    class ArticleViewSet(ViewSet):
+        """Unified ViewSet for articles."""
+        queryset = Article.objects.all()
+        serializer_class = ArticleFullSchema
+        list_serializer_class = ArticleMiniSchema
+        lookup_field = 'pk'
+
+        async def list(self, request):
+            """List articles."""
+            articles = []
+            async for article in await self.get_queryset():
+                articles.append(ArticleMiniSchema.from_model(article))
+            return articles
+
+        async def retrieve(self, request, pk: int):
+            """Retrieve a single article."""
+            article = await self.get_object(pk)
+            return ArticleFullSchema.from_model(article)
+
+        async def create(self, request, data: ArticleCreateSchema):
+            """Create a new article."""
+            article = await Article.objects.acreate(
+                title=data.title,
+                content=data.content,
+                author=data.author,
+            )
+            return ArticleFullSchema.from_model(article)
+
+        async def update(self, request, pk: int, data: ArticleUpdateSchema):
+            """Update an article."""
+            article = await self.get_object(pk)
+            if data.title:
+                article.title = data.title
+            if data.content:
+                article.content = data.content
+            if data.author:
+                article.author = data.author
+            await article.asave()
+            return ArticleFullSchema.from_model(article)
+
+        async def partial_update(self, request, pk: int, data: ArticleUpdateSchema):
+            """Partially update an article."""
+            article = await self.get_object(pk)
+            if data.title:
+                article.title = data.title
+            if data.content:
+                article.content = data.content
+            if data.author:
+                article.author = data.author
+            await article.asave()
+            return ArticleFullSchema.from_model(article)
+
+        async def destroy(self, request, pk: int):
+            """Delete an article."""
+            article = await self.get_object(pk)
+            await article.adelete()
+            return {"deleted": True, "id": pk}
+
+    # Register with api.viewset() - automatic route generation
+    @api.viewset("/articles")
+    class ArticleViewSetRegistered(ArticleViewSet):
+        pass
+
+    with TestClient(api) as client:
+        # List (empty)
+        response = client.get("/articles")
+        assert response.status_code == 200
+        assert response.json() == []
+
+        # Create
+        response = client.post(
+            "/articles",
+            json={"title": "Test Article", "content": "Test Content", "author": "Test Author"},
+        )
+        assert response.status_code == 201  # HTTP 201 Created
+        data = response.json()
+        assert data["title"] == "Test Article"
+        assert data["content"] == "Test Content"
+        article_id = data["id"]
+
+        # List (with data)
+        response = client.get("/articles")
+        assert response.status_code == 200
+        articles = response.json()
+        assert len(articles) == 1
+        assert articles[0]["title"] == "Test Article"
+        # List returns mini schema (id, title only)
+        assert "content" not in articles[0]
+
+        # Retrieve (detail view)
+        response = client.get(f"/articles/{article_id}")
+        assert response.status_code == 200
+        data = response.json()
+        assert data["title"] == "Test Article"
+        assert data["content"] == "Test Content"  # Detail view includes content
+
+        # Update
+        response = client.put(
+            f"/articles/{article_id}",
+            json={"title": "Updated Title", "content": "Updated Content", "author": "Updated Author"},
+        )
+        assert response.status_code == 200
+        assert response.json()["title"] == "Updated Title"
+
+        # Partial update
+        response = client.patch(
+            f"/articles/{article_id}",
+            json={"title": "Patched Title"},
+        )
+        assert response.status_code == 200
+        assert response.json()["title"] == "Patched Title"
+
+        # Delete
+        response = client.delete(f"/articles/{article_id}")
+        assert response.status_code == 204  # HTTP 204 No Content
+        assert response.json()["deleted"] is True
+
+        # Verify deletion
+        response = client.get(f"/articles/{article_id}")
+        assert response.status_code == 404
+
+
+@pytest.mark.django_db(transaction=True)
+def test_unified_viewset_custom_lookup_field(api):
+    """Test unified ViewSet with custom lookup_field."""
+    from asgiref.sync import async_to_sync
+
+    # Create article
+    article = async_to_sync(Article.objects.acreate)(
+        title="Test Article",
+        content="Test Content",
+        author="test-author-slug",
+    )
+
+    class ArticleViewSet(ViewSet):
+        """Unified ViewSet with custom lookup field."""
+        queryset = Article.objects.all()
+        serializer_class = ArticleFullSchema
+        lookup_field = 'author'  # Use author as lookup field
+
+        async def retrieve(self, request, author: str):
+            """Retrieve article by author."""
+            article = await self.get_object(author=author)
+            return ArticleFullSchema.from_model(article)
+
+    # Register with api.viewset() - uses lookup_field from class
+    @api.viewset("/articles")
+    class ArticleViewSetRegistered(ArticleViewSet):
+        pass
+
+    with TestClient(api) as client:
+        # Lookup by author (using custom lookup_field)
+        response = client.get("/articles/test-author-slug")
+        assert response.status_code == 200
+        data = response.json()
+        assert data["author"] == "test-author-slug"
+        assert data["title"] == "Test Article"
+
+
+@pytest.mark.django_db(transaction=True)
+def test_unified_viewset_with_custom_actions(api):
+    """Test unified ViewSet with custom actions."""
+    from asgiref.sync import async_to_sync
+
+    # Create test data
+    async_to_sync(Article.objects.acreate)(
+        title="Published Article",
+        content="Content",
+        author="Author",
+        is_published=True,
+    )
+    async_to_sync(Article.objects.acreate)(
+        title="Draft Article",
+        content="Content",
+        author="Author",
+        is_published=False,
+    )
+
+    class ArticleViewSet(ViewSet):
+        """Unified ViewSet with custom actions."""
+        queryset = Article.objects.all()
+        serializer_class = ArticleFullSchema
+        list_serializer_class = ArticleMiniSchema
+
+        async def list(self, request):
+            """List all articles."""
+            articles = []
+            async for article in await self.get_queryset():
+                articles.append(ArticleMiniSchema.from_model(article))
+            return articles
+
+        # Custom action: search (using @action decorator)
+        @action(methods=["GET"], detail=False)
+        async def search(self, request, query: str):
+            """Search articles by title. GET /articles/search"""
+            results = []
+            async for article in Article.objects.filter(title__icontains=query):
+                results.append(ArticleMiniSchema.from_model(article))
+            return {"query": query, "results": results}
+
+        # Custom action: published only (using @action decorator)
+        @action(methods=["GET"], detail=False)
+        async def published(self, request):
+            """Get published articles only. GET /articles/published"""
+            articles = []
+            async for article in Article.objects.filter(is_published=True):
+                articles.append(ArticleMiniSchema.from_model(article))
+            return articles
+
+    # Register with api.viewset() - automatically discovers custom actions
+    @api.viewset("/articles")
+    class ArticleViewSetRegistered(ArticleViewSet):
+        pass
+
+    with TestClient(api) as client:
+        # List all articles
+        response = client.get("/articles")
+        assert response.status_code == 200
+        assert len(response.json()) == 2
+
+        # Search
+        response = client.get("/articles/search?query=Published")
+        assert response.status_code == 200
+        data = response.json()
+        assert data["query"] == "Published"
+        assert len(data["results"]) == 1
+        assert data["results"][0]["title"] == "Published Article"
+
+        # Published only
+        response = client.get("/articles/published")
+        assert response.status_code == 200
+        articles = response.json()
+        assert len(articles) == 1
+        assert articles[0]["title"] == "Published Article"
+
+
+@pytest.mark.django_db(transaction=True)
+def test_unified_viewset_partial_implementation(api):
+    """Test unified ViewSet with only some actions implemented."""
+
+    class ReadOnlyArticleViewSet(ViewSet):
+        """Read-only ViewSet (only list and retrieve)."""
+        queryset = Article.objects.all()
+        serializer_class = ArticleFullSchema
+
+        async def list(self, request):
+            """List articles."""
+            articles = []
+            async for article in await self.get_queryset():
+                articles.append(ArticleFullSchema.from_model(article))
+            return articles
+
+        async def retrieve(self, request, pk: int):
+            """Retrieve a single article."""
+            article = await self.get_object(pk)
+            return ArticleFullSchema.from_model(article)
+
+        # Note: create, update, partial_update, destroy not implemented
+
+    # Register with api.viewset() - only generates routes for implemented actions
+    @api.viewset("/articles")
+    class ReadOnlyArticleViewSetRegistered(ReadOnlyArticleViewSet):
+        pass
+
+    with TestClient(api) as client:
+        # List works
+        response = client.get("/articles")
+        assert response.status_code == 200
+
+        # POST not registered (create not implemented)
+        response = client.post("/articles", json={"title": "Test", "content": "Test", "author": "Test"})
+        assert response.status_code == 404
+
+
+@pytest.fixture
+def api():
+    """Create a fresh BoltAPI instance for each test."""
+    return BoltAPI()