fastapi-fullstack 0.1.7__py3-none-any.whl

fastapi_gen/template/{{cookiecutter.project_slug}}/backend/tests/api/test_items.py

@@ -0,0 +1,310 @@
+{%- if cookiecutter.include_example_crud and cookiecutter.use_database %}
+"""Tests for items CRUD routes.
+
+This module demonstrates testing patterns for CRUD endpoints.
+You can use it as a template for testing your own endpoints.
+"""
+
+from datetime import UTC, datetime
+from unittest.mock import AsyncMock, MagicMock
+from uuid import uuid4
+
+import pytest
+from httpx import AsyncClient
+
+from app.core.config import settings
+from app.main import app
+
+
+class MockItem:
+    """Mock item for testing."""
+
+    def __init__(
+        self,
+        id=None,
+        title="Test Item",
+        description="Test Description",
+        is_active=True,
+    ):
+{%- if cookiecutter.use_postgresql %}
+        self.id = id or uuid4()
+{%- else %}
+        self.id = id or str(uuid4())
+{%- endif %}
+        self.title = title
+        self.description = description
+        self.is_active = is_active
+        self.created_at = datetime.now(UTC)
+        self.updated_at = None
+
+
+@pytest.fixture
+def mock_item() -> MockItem:
+    """Create a mock item."""
+    return MockItem()
+
+
+@pytest.fixture
+def mock_items() -> list[MockItem]:
+    """Create multiple mock items."""
+    return [
+        MockItem(title="Item 1", description="First item"),
+        MockItem(title="Item 2", description="Second item"),
+        MockItem(title="Item 3", description="Third item"),
+    ]
+
+
+@pytest.fixture
+def mock_item_service(mock_item: MockItem, mock_items: list[MockItem]) -> MagicMock:
+    """Create a mock item service."""
+    service = MagicMock()
+{%- if cookiecutter.use_postgresql or cookiecutter.use_mongodb %}
+    service.get_by_id = AsyncMock(return_value=mock_item)
+    service.get_multi = AsyncMock(return_value=mock_items)
+    service.create = AsyncMock(return_value=mock_item)
+    service.update = AsyncMock(return_value=mock_item)
+    service.delete = AsyncMock(return_value=mock_item)
+{%- elif cookiecutter.use_sqlite %}
+    service.get_by_id = MagicMock(return_value=mock_item)
+    service.get_multi = MagicMock(return_value=mock_items)
+    service.create = MagicMock(return_value=mock_item)
+    service.update = MagicMock(return_value=mock_item)
+    service.delete = MagicMock(return_value=mock_item)
+{%- endif %}
+    return service
+
+
+@pytest.fixture
+async def client_with_mock_service(
+    mock_item_service: MagicMock,
+{%- if cookiecutter.use_database %}
+    mock_db_session,
+{%- endif %}
+) -> AsyncClient:
+    """Client with mocked item service."""
+    from httpx import ASGITransport
+
+    from app.api.deps import get_item_service
+{%- if cookiecutter.use_database %}
+    from app.db.session import get_db_session
+{%- endif %}
+
+    app.dependency_overrides[get_item_service] = lambda db=None: mock_item_service
+{%- if cookiecutter.use_database %}
+    app.dependency_overrides[get_db_session] = lambda: mock_db_session
+{%- endif %}
+
+    async with AsyncClient(
+        transport=ASGITransport(app=app),
+        base_url="http://test",
+    ) as ac:
+        yield ac
+
+    app.dependency_overrides.clear()
+
+
+@pytest.mark.anyio
+async def test_create_item_success(client_with_mock_service: AsyncClient):
+    """Test successful item creation."""
+    response = await client_with_mock_service.post(
+        f"{settings.API_V1_STR}/items",
+        json={"title": "New Item", "description": "A new item"},
+    )
+    assert response.status_code == 201
+    data = response.json()
+    assert data["title"] == "Test Item"  # From mock
+
+
+@pytest.mark.anyio
+async def test_create_item_minimal(client_with_mock_service: AsyncClient):
+    """Test item creation with minimal data (only required fields)."""
+    response = await client_with_mock_service.post(
+        f"{settings.API_V1_STR}/items",
+        json={"title": "Minimal Item"},
+    )
+    assert response.status_code == 201
+
+
+@pytest.mark.anyio
+async def test_create_item_validation_error(client_with_mock_service: AsyncClient):
+    """Test item creation with invalid data."""
+    response = await client_with_mock_service.post(
+        f"{settings.API_V1_STR}/items",
+        json={},  # Missing required 'title' field
+    )
+    assert response.status_code == 422
+
+
+@pytest.mark.anyio
+async def test_get_item_success(
+    client_with_mock_service: AsyncClient,
+    mock_item: MockItem,
+):
+    """Test successful item retrieval."""
+    response = await client_with_mock_service.get(
+        f"{settings.API_V1_STR}/items/{mock_item.id}",
+    )
+    assert response.status_code == 200
+    data = response.json()
+    assert data["title"] == mock_item.title
+    assert data["description"] == mock_item.description
+
+
+@pytest.mark.anyio
+async def test_get_item_not_found(
+    client_with_mock_service: AsyncClient,
+    mock_item_service: MagicMock,
+):
+    """Test item retrieval when item doesn't exist."""
+    from app.core.exceptions import NotFoundError
+
+{%- if cookiecutter.use_postgresql or cookiecutter.use_mongodb %}
+    mock_item_service.get_by_id = AsyncMock(
+        side_effect=NotFoundError(message="Item not found")
+    )
+{%- elif cookiecutter.use_sqlite %}
+    mock_item_service.get_by_id = MagicMock(
+        side_effect=NotFoundError(message="Item not found")
+    )
+{%- endif %}
+
+{%- if cookiecutter.use_postgresql %}
+    response = await client_with_mock_service.get(
+        f"{settings.API_V1_STR}/items/{uuid4()}",
+    )
+{%- else %}
+    response = await client_with_mock_service.get(
+        f"{settings.API_V1_STR}/items/nonexistent-id",
+    )
+{%- endif %}
+    assert response.status_code == 404
+
+
+{%- if not cookiecutter.enable_pagination %}
+
+
+@pytest.mark.anyio
+async def test_list_items_success(
+    client_with_mock_service: AsyncClient,
+    mock_items: list[MockItem],
+):
+    """Test successful item listing."""
+    response = await client_with_mock_service.get(
+        f"{settings.API_V1_STR}/items",
+    )
+    assert response.status_code == 200
+    data = response.json()
+    assert len(data) == len(mock_items)
+
+
+@pytest.mark.anyio
+async def test_list_items_pagination(client_with_mock_service: AsyncClient):
+    """Test item listing with pagination parameters."""
+    response = await client_with_mock_service.get(
+        f"{settings.API_V1_STR}/items?skip=0&limit=10",
+    )
+    assert response.status_code == 200
+{%- endif %}
+
+
+@pytest.mark.anyio
+async def test_update_item_success(
+    client_with_mock_service: AsyncClient,
+    mock_item: MockItem,
+):
+    """Test successful item update."""
+    response = await client_with_mock_service.patch(
+        f"{settings.API_V1_STR}/items/{mock_item.id}",
+        json={"title": "Updated Title"},
+    )
+    assert response.status_code == 200
+
+
+@pytest.mark.anyio
+async def test_update_item_partial(
+    client_with_mock_service: AsyncClient,
+    mock_item: MockItem,
+):
+    """Test partial item update (only some fields)."""
+    response = await client_with_mock_service.patch(
+        f"{settings.API_V1_STR}/items/{mock_item.id}",
+        json={"is_active": False},
+    )
+    assert response.status_code == 200
+
+
+@pytest.mark.anyio
+async def test_update_item_not_found(
+    client_with_mock_service: AsyncClient,
+    mock_item_service: MagicMock,
+):
+    """Test item update when item doesn't exist."""
+    from app.core.exceptions import NotFoundError
+
+{%- if cookiecutter.use_postgresql or cookiecutter.use_mongodb %}
+    mock_item_service.update = AsyncMock(
+        side_effect=NotFoundError(message="Item not found")
+    )
+{%- elif cookiecutter.use_sqlite %}
+    mock_item_service.update = MagicMock(
+        side_effect=NotFoundError(message="Item not found")
+    )
+{%- endif %}
+
+{%- if cookiecutter.use_postgresql %}
+    response = await client_with_mock_service.patch(
+        f"{settings.API_V1_STR}/items/{uuid4()}",
+        json={"title": "Updated"},
+    )
+{%- else %}
+    response = await client_with_mock_service.patch(
+        f"{settings.API_V1_STR}/items/nonexistent-id",
+        json={"title": "Updated"},
+    )
+{%- endif %}
+    assert response.status_code == 404
+
+
+@pytest.mark.anyio
+async def test_delete_item_success(
+    client_with_mock_service: AsyncClient,
+    mock_item: MockItem,
+):
+    """Test successful item deletion."""
+    response = await client_with_mock_service.delete(
+        f"{settings.API_V1_STR}/items/{mock_item.id}",
+    )
+    assert response.status_code == 204
+
+
+@pytest.mark.anyio
+async def test_delete_item_not_found(
+    client_with_mock_service: AsyncClient,
+    mock_item_service: MagicMock,
+):
+    """Test item deletion when item doesn't exist."""
+    from app.core.exceptions import NotFoundError
+
+{%- if cookiecutter.use_postgresql or cookiecutter.use_mongodb %}
+    mock_item_service.delete = AsyncMock(
+        side_effect=NotFoundError(message="Item not found")
+    )
+{%- elif cookiecutter.use_sqlite %}
+    mock_item_service.delete = MagicMock(
+        side_effect=NotFoundError(message="Item not found")
+    )
+{%- endif %}
+
+{%- if cookiecutter.use_postgresql %}
+    response = await client_with_mock_service.delete(
+        f"{settings.API_V1_STR}/items/{uuid4()}",
+    )
+{%- else %}
+    response = await client_with_mock_service.delete(
+        f"{settings.API_V1_STR}/items/nonexistent-id",
+    )
+{%- endif %}
+    assert response.status_code == 404
+{%- else %}
+"""Item tests - not configured (example CRUD disabled or no database)."""
+{%- endif %}

fastapi_gen/template/{{cookiecutter.project_slug}}/backend/tests/api/test_users.py

@@ -0,0 +1,253 @@
+{%- if cookiecutter.use_jwt %}
+"""Tests for user routes."""
+{%- if cookiecutter.use_database or cookiecutter.enable_redis %}
+# ruff: noqa: I001 - Imports structured for Jinja2 template conditionals
+{%- endif %}
+
+from datetime import UTC, datetime
+from unittest.mock import AsyncMock, MagicMock
+from uuid import uuid4
+
+import pytest
+from httpx import ASGITransport, AsyncClient
+
+from app.api.deps import get_current_active_superuser, get_current_user, get_user_service
+{%- if cookiecutter.use_database %}
+from app.api.deps import get_db_session
+{%- endif %}
+{%- if cookiecutter.enable_redis %}
+from app.api.deps import get_redis
+{%- endif %}
+from app.core.config import settings
+from app.main import app
+
+
+class MockUser:
+    """Mock user for testing."""
+
+    def __init__(
+        self,
+        id=None,
+        email="test@example.com",
+        full_name="Test User",
+        is_active=True,
+        is_superuser=False,
+        role="admin",
+    ):
+{%- if cookiecutter.use_postgresql %}
+        self.id = id or uuid4()
+{%- else %}
+        self.id = id or str(uuid4())
+{%- endif %}
+        self.email = email
+        self.full_name = full_name
+        self.is_active = is_active
+        self.is_superuser = is_superuser
+        self.role = role
+        self.hashed_password = "hashed"
+        self.created_at = datetime.now(UTC)
+        self.updated_at = datetime.now(UTC)
+
+    def has_role(self, role) -> bool:
+        """Check if user has the specified role."""
+        if hasattr(role, "value"):
+            return self.role == role.value
+        return self.role == role
+
+
+@pytest.fixture
+def mock_user() -> MockUser:
+    """Create a mock regular user."""
+    return MockUser()
+
+
+@pytest.fixture
+def mock_superuser() -> MockUser:
+    """Create a mock superuser."""
+    return MockUser(is_superuser=True, email="admin@example.com")
+
+
+@pytest.fixture
+def mock_user_service(mock_user: MockUser) -> MagicMock:
+    """Create a mock user service."""
+    service = MagicMock()
+    service.get_by_id = AsyncMock(return_value=mock_user)
+    service.get_multi = AsyncMock(return_value=[mock_user])
+    service.update = AsyncMock(return_value=mock_user)
+    service.delete = AsyncMock(return_value=mock_user)
+    return service
+
+
+@pytest.fixture
+async def auth_client(
+    mock_user: MockUser,
+    mock_user_service: MagicMock,
+{%- if cookiecutter.enable_redis %}
+    mock_redis: MagicMock,
+{%- endif %}
+{%- if cookiecutter.use_database %}
+    mock_db_session,
+{%- endif %}
+) -> AsyncClient:
+    """Client with authenticated regular user."""
+    app.dependency_overrides[get_current_user] = lambda: mock_user
+    app.dependency_overrides[get_user_service] = lambda: mock_user_service
+{%- if cookiecutter.enable_redis %}
+    app.dependency_overrides[get_redis] = lambda: mock_redis
+{%- endif %}
+{%- if cookiecutter.use_database %}
+    app.dependency_overrides[get_db_session] = lambda: mock_db_session
+{%- endif %}
+
+    async with AsyncClient(
+        transport=ASGITransport(app=app),
+        base_url="http://test",
+    ) as ac:
+        yield ac
+
+    app.dependency_overrides.clear()
+
+
+@pytest.fixture
+async def superuser_client(
+    mock_superuser: MockUser,
+    mock_user_service: MagicMock,
+{%- if cookiecutter.enable_redis %}
+    mock_redis: MagicMock,
+{%- endif %}
+{%- if cookiecutter.use_database %}
+    mock_db_session,
+{%- endif %}
+) -> AsyncClient:
+    """Client with authenticated superuser."""
+    app.dependency_overrides[get_current_user] = lambda: mock_superuser
+    app.dependency_overrides[get_current_active_superuser] = lambda: mock_superuser
+    app.dependency_overrides[get_user_service] = lambda: mock_user_service
+{%- if cookiecutter.enable_redis %}
+    app.dependency_overrides[get_redis] = lambda: mock_redis
+{%- endif %}
+{%- if cookiecutter.use_database %}
+    app.dependency_overrides[get_db_session] = lambda: mock_db_session
+{%- endif %}
+
+    async with AsyncClient(
+        transport=ASGITransport(app=app),
+        base_url="http://test",
+    ) as ac:
+        yield ac
+
+    app.dependency_overrides.clear()
+
+
+@pytest.mark.anyio
+async def test_read_current_user(auth_client: AsyncClient, mock_user: MockUser):
+    """Test getting current user."""
+    response = await auth_client.get(f"{settings.API_V1_STR}/users/me")
+    assert response.status_code == 200
+    data = response.json()
+    assert data["email"] == mock_user.email
+
+
+@pytest.mark.anyio
+async def test_update_current_user(auth_client: AsyncClient, mock_user_service: MagicMock):
+    """Test updating current user."""
+    response = await auth_client.patch(
+        f"{settings.API_V1_STR}/users/me",
+        json={"full_name": "Updated Name"},
+    )
+    assert response.status_code == 200
+    mock_user_service.update.assert_called_once()
+
+
+{%- if not cookiecutter.enable_pagination %}
+
+
+@pytest.mark.anyio
+async def test_read_users_superuser(superuser_client: AsyncClient, mock_user_service: MagicMock):
+    """Test getting all users as superuser."""
+    response = await superuser_client.get(f"{settings.API_V1_STR}/users")
+    assert response.status_code == 200
+    data = response.json()
+    assert isinstance(data, list)
+{%- endif %}
+
+
+@pytest.mark.anyio
+async def test_read_user_by_id(
+    superuser_client: AsyncClient,
+    mock_user: MockUser,
+    mock_user_service: MagicMock,
+):
+    """Test getting user by ID as superuser."""
+    response = await superuser_client.get(
+        f"{settings.API_V1_STR}/users/{mock_user.id}"
+    )
+    assert response.status_code == 200
+    data = response.json()
+    assert data["email"] == mock_user.email
+
+
+@pytest.mark.anyio
+async def test_read_user_by_id_not_found(
+    superuser_client: AsyncClient,
+    mock_user_service: MagicMock,
+):
+    """Test getting non-existent user."""
+    from app.core.exceptions import NotFoundError
+
+    mock_user_service.get_by_id = AsyncMock(
+        side_effect=NotFoundError(message="User not found")
+    )
+
+    response = await superuser_client.get(
+        f"{settings.API_V1_STR}/users/{uuid4()}"
+    )
+    assert response.status_code == 404
+
+
+@pytest.mark.anyio
+async def test_update_user_by_id(
+    superuser_client: AsyncClient,
+    mock_user: MockUser,
+    mock_user_service: MagicMock,
+):
+    """Test updating user by ID as superuser."""
+    response = await superuser_client.patch(
+        f"{settings.API_V1_STR}/users/{mock_user.id}",
+        json={"full_name": "Admin Updated"},
+    )
+    assert response.status_code == 200
+    mock_user_service.update.assert_called_once()
+
+
+@pytest.mark.anyio
+async def test_delete_user_by_id(
+    superuser_client: AsyncClient,
+    mock_user: MockUser,
+    mock_user_service: MagicMock,
+):
+    """Test deleting user by ID as superuser."""
+    response = await superuser_client.delete(
+        f"{settings.API_V1_STR}/users/{mock_user.id}"
+    )
+    assert response.status_code == 204
+    mock_user_service.delete.assert_called_once()
+
+
+@pytest.mark.anyio
+async def test_delete_user_by_id_not_found(
+    superuser_client: AsyncClient,
+    mock_user_service: MagicMock,
+):
+    """Test deleting non-existent user."""
+    from app.core.exceptions import NotFoundError
+
+    mock_user_service.delete = AsyncMock(
+        side_effect=NotFoundError(message="User not found")
+    )
+
+    response = await superuser_client.delete(
+        f"{settings.API_V1_STR}/users/{uuid4()}"
+    )
+    assert response.status_code == 404
+{%- endif %}

fastapi_gen/template/{{cookiecutter.project_slug}}/backend/tests/conftest.py

@@ -0,0 +1,151 @@
+"""Test configuration and fixtures.
+
+Uses anyio for async testing instead of pytest-asyncio.
+This allows using the same async primitives that Starlette uses internally.
+See: https://anyio.readthedocs.io/en/stable/testing.html
+"""
+{%- if cookiecutter.enable_redis or cookiecutter.use_database or cookiecutter.use_api_key %}
+# ruff: noqa: I001 - Imports structured for Jinja2 template conditionals
+{%- endif %}
+
+from collections.abc import AsyncGenerator
+{%- if cookiecutter.enable_redis %}
+from unittest.mock import AsyncMock, MagicMock
+{%- elif cookiecutter.use_postgresql or cookiecutter.use_mongodb %}
+from unittest.mock import AsyncMock
+{%- elif cookiecutter.use_sqlite %}
+from unittest.mock import MagicMock
+{%- endif %}
+
+import pytest
+from httpx import ASGITransport, AsyncClient
+
+from app.main import app
+{%- if cookiecutter.use_api_key %}
+from app.core.config import settings
+{%- endif %}
+{%- if cookiecutter.enable_redis %}
+from app.api.deps import get_redis
+from app.clients.redis import RedisClient
+{%- endif %}
+{%- if cookiecutter.use_database %}
+from app.api.deps import get_db_session
+{%- endif %}
+
+
+@pytest.fixture
+def anyio_backend() -> str:
+    """Specify the async backend for anyio tests.
+
+    Options: "asyncio" or "trio". We use asyncio since that's what uvicorn uses.
+    """
+    return "asyncio"
+
+
+{%- if cookiecutter.enable_redis %}
+
+
+@pytest.fixture
+def mock_redis() -> MagicMock:
+    """Create a mock Redis client for testing."""
+    mock = MagicMock(spec=RedisClient)
+    mock.ping = AsyncMock(return_value=True)
+    mock.get = AsyncMock(return_value=None)
+    mock.set = AsyncMock(return_value=True)
+    mock.delete = AsyncMock(return_value=1)
+    mock.exists = AsyncMock(return_value=0)
+    mock.incr = AsyncMock(return_value=1)
+    mock.expire = AsyncMock(return_value=True)
+    return mock
+{%- endif %}
+
+
+{%- if cookiecutter.use_postgresql %}
+
+
+@pytest.fixture
+async def mock_db_session() -> AsyncGenerator[AsyncMock, None]:
+    """Create a mock database session for testing."""
+    mock = AsyncMock()
+    mock.execute = AsyncMock()
+    mock.commit = AsyncMock()
+    mock.rollback = AsyncMock()
+    mock.close = AsyncMock()
+    yield mock
+{%- endif %}
+
+
+{%- if cookiecutter.use_sqlite %}
+
+
+@pytest.fixture
+def mock_db_session() -> MagicMock:
+    """Create a mock database session for testing."""
+    mock = MagicMock()
+    mock.execute = MagicMock()
+    mock.commit = MagicMock()
+    mock.rollback = MagicMock()
+    mock.close = MagicMock()
+    return mock
+{%- endif %}
+
+
+{%- if cookiecutter.use_mongodb %}
+
+
+@pytest.fixture
+async def mock_db_session() -> AsyncMock:
+    """Create a mock MongoDB session for testing."""
+    mock = AsyncMock()
+    mock.command = AsyncMock(return_value={"ok": 1})
+    return mock
+{%- endif %}
+
+
+@pytest.fixture
+async def client(
+{%- if cookiecutter.enable_redis %}
+    mock_redis: MagicMock,
+{%- endif %}
+{%- if cookiecutter.use_database %}
+    mock_db_session,
+{%- endif %}
+) -> AsyncGenerator[AsyncClient, None]:
+    """Async HTTP client for testing.
+
+    Uses HTTPX AsyncClient with ASGITransport instead of Starlette's TestClient.
+    This allows proper async testing without thread pool overhead.
+    """
+    # Override dependencies for testing
+{%- if cookiecutter.enable_redis %}
+    app.dependency_overrides[get_redis] = lambda: mock_redis
+{%- endif %}
+{%- if cookiecutter.use_database %}
+    app.dependency_overrides[get_db_session] = lambda: mock_db_session
+{%- endif %}
+
+    async with AsyncClient(
+        transport=ASGITransport(app=app),
+        base_url="http://test",
+    ) as ac:
+        yield ac
+
+    # Clear overrides after test
+    app.dependency_overrides.clear()
+
+
+{%- if cookiecutter.use_api_key %}
+
+
+@pytest.fixture
+def api_key_headers() -> dict[str, str]:
+    """Headers with valid API key."""
+    return {settings.API_KEY_HEADER: settings.API_KEY}
+{%- endif %}
+
+
+{%- if cookiecutter.use_jwt %}
+# Note: For integration tests requiring authenticated users,
+# use dependency overrides with mock users instead of test_user fixture.
+# See tests/api/test_auth.py and tests/api/test_users.py for examples.
+{%- endif %}