fastapi-fullstack 0.1.7__py3-none-any.whl

fastapi_gen/template/{{cookiecutter.project_slug}}/backend/pyproject.toml

@@ -0,0 +1,180 @@
+[project]
+name = "{{ cookiecutter.project_slug }}"
+version = "0.1.0"
+description = "{{ cookiecutter.project_description }}"
+requires-python = ">={{ cookiecutter.python_version }}"
+license = { text = "MIT" }
+authors = [{ name = "{{ cookiecutter.author_name }}", email = "{{ cookiecutter.author_email }}" }]
+
+dependencies = [
+    "fastapi>=0.115.0",
+    "uvicorn[standard]>=0.32.0",
+    "pydantic[email]>=2.10.0",
+    "pydantic-settings>=2.6.0",
+{%- if cookiecutter.enable_orjson %}
+    "orjson>=3.10.0",
+{%- endif %}
+{%- if cookiecutter.enable_logfire %}
+{%- set logfire_extras = ['fastapi'] %}
+{%- if cookiecutter.use_postgresql and cookiecutter.logfire_database %}
+{%- set _ = logfire_extras.append('asyncpg') %}
+{%- endif %}
+{%- if cookiecutter.enable_redis and cookiecutter.logfire_redis %}
+{%- set _ = logfire_extras.append('redis') %}
+{%- endif %}
+{%- if cookiecutter.use_celery and cookiecutter.logfire_celery %}
+{%- set _ = logfire_extras.append('celery') %}
+{%- endif %}
+{%- if cookiecutter.logfire_httpx %}
+{%- set _ = logfire_extras.append('httpx') %}
+{%- endif %}
+    "logfire[{{ logfire_extras | join(',') }}]>=2.0.0",
+{%- endif %}
+{%- if cookiecutter.use_postgresql %}
+    "sqlalchemy[asyncio]>=2.0.0",
+    "asyncpg>=0.30.0",
+    "psycopg2-binary>=2.9.0",
+    "alembic>=1.14.0",
+    "greenlet>=3.0.0",
+{%- endif %}
+{%- if cookiecutter.use_mongodb %}
+    "motor>=3.6.0",
+    "beanie>=1.27.0",
+{%- endif %}
+{%- if cookiecutter.use_sqlite %}
+    "sqlalchemy>=2.0.0",
+    "alembic>=1.14.0",
+{%- endif %}
+{%- if cookiecutter.use_jwt %}
+    "pyjwt>=2.9.0",
+    "bcrypt>=4.0.0",
+    "python-multipart>=0.0.12",
+{%- endif %}
+{%- if cookiecutter.enable_oauth %}
+    "authlib>=1.3.0",
+    "httpx>=0.27.0",
+{%- endif %}
+{%- if cookiecutter.enable_redis %}
+    "redis>=5.2.0",
+{%- endif %}
+{%- if cookiecutter.enable_caching %}
+    "fastapi-cache2>=0.2.2",
+{%- endif %}
+{%- if cookiecutter.enable_rate_limiting %}
+    "slowapi>=0.1.9",
+{%- endif %}
+{%- if cookiecutter.enable_pagination %}
+    "fastapi-pagination>=0.12.31",
+{%- endif %}
+{%- if cookiecutter.enable_sentry %}
+    "sentry-sdk[fastapi]>=2.18.0",
+{%- endif %}
+{%- if cookiecutter.enable_admin_panel %}
+    "sqladmin>=0.19.0",
+{%- if cookiecutter.admin_require_auth %}
+    "itsdangerous>=2.2.0",
+{%- endif %}
+{%- endif %}
+{%- if cookiecutter.use_celery %}
+    "celery[redis]>=5.4.0",
+    "flower>=2.0.0",
+{%- endif %}
+{%- if cookiecutter.use_taskiq %}
+    "taskiq>=0.11.0",
+    "taskiq-redis>=1.0.0",
+    "taskiq-dependencies>=0.1.0",
+{%- endif %}
+{%- if cookiecutter.use_arq %}
+    "arq>=0.26.0",
+{%- endif %}
+{%- if cookiecutter.enable_file_storage %}
+    "boto3>=1.35.0",
+{%- endif %}
+{%- if cookiecutter.enable_ai_agent and cookiecutter.use_pydantic_ai %}
+{%- if cookiecutter.use_openai %}
+    "pydantic-ai>=0.0.39",
+{%- endif %}
+{%- if cookiecutter.use_anthropic %}
+    "pydantic-ai-slim[anthropic]>=0.0.39",
+{%- endif %}
+{%- if cookiecutter.use_openrouter %}
+    "pydantic-ai-slim[openrouter]>=0.0.39",
+{%- endif %}
+{%- endif %}
+{%- if cookiecutter.enable_ai_agent and cookiecutter.use_langchain %}
+    "langchain>=0.3.0",
+{%- if cookiecutter.use_openai %}
+    "langchain-openai>=0.3.0",
+{%- endif %}
+{%- if cookiecutter.use_anthropic %}
+    "langchain-anthropic>=0.3.0",
+{%- endif %}
+    "langgraph>=0.2.0",
+{%- endif %}
+{%- if cookiecutter.logfire_httpx or cookiecutter.enable_file_storage %}
+    "httpx>=0.27.0",
+{%- endif %}
+    "click>=8.1.0",
+    "tabulate>=0.9.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=8.3.0",
+    "anyio[trio]>=4.0.0",
+    "pytest-cov>=6.0.0",
+    "httpx>=0.27.0",
+    "ruff>=0.8.0",
+    "mypy>=1.13.0",
+{%- if cookiecutter.enable_precommit %}
+    "pre-commit>=4.0.0",
+{%- endif %}
+]
+
+[project.scripts]
+{{ cookiecutter.project_slug }} = "cli.commands:main"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["app", "cli"]
+
+[tool.ruff]
+target-version = "py311"
+line-length = 100
+
+[tool.ruff.lint]
+select = [
+    "E",      # pycodestyle errors
+    "W",      # pycodestyle warnings
+    "F",      # pyflakes
+    "I",      # isort
+    "B",      # flake8-bugbear
+    "C4",     # flake8-comprehensions
+    "UP",     # pyupgrade
+    "SIM",    # flake8-simplify
+    "RUF",    # ruff-specific rules
+]
+ignore = [
+    "E501",   # line too long (handled by formatter)
+    "B008",   # function call in default argument (needed for FastAPI Depends)
+]
+
+[tool.ruff.lint.isort]
+known-first-party = ["app", "cli"]
+
+[tool.mypy]
+python_version = "3.11"
+strict = true
+warn_return_any = true
+warn_unused_configs = true
+ignore_missing_imports = true
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+
+[tool.{{ cookiecutter.generator_name }}]
+generator_version = "{{ cookiecutter.generator_version }}"
+generated_at = "{{ cookiecutter.generated_at }}"

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

@@ -0,0 +1 @@
+"""Tests package."""

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

@@ -0,0 +1 @@
+"""API tests package."""

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

@@ -0,0 +1,242 @@
+{%- if cookiecutter.use_jwt %}
+# ruff: noqa: I001 - Imports structured for Jinja2 template conditionals
+"""Tests for authentication routes."""
+
+from datetime import UTC, datetime
+from unittest.mock import AsyncMock, MagicMock
+from uuid import uuid4
+
+import pytest
+from httpx import AsyncClient
+
+from app.api.deps import get_user_service
+from app.core.config import settings
+from app.core.security import create_access_token, create_refresh_token
+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,
+    ):
+        self.id = id or uuid4()
+        self.email = email
+        self.full_name = full_name
+        self.is_active = is_active
+        self.is_superuser = is_superuser
+        self.hashed_password = "hashed"
+        self.created_at = datetime.now(UTC)
+        self.updated_at = datetime.now(UTC)
+
+
+@pytest.fixture
+def mock_user() -> MockUser:
+    """Create a mock user."""
+    return MockUser()
+
+
+@pytest.fixture
+def mock_user_service(mock_user: MockUser) -> MagicMock:
+    """Create a mock user service."""
+    service = MagicMock()
+    service.authenticate = AsyncMock(return_value=mock_user)
+    service.register = AsyncMock(return_value=mock_user)
+    service.get_by_id = AsyncMock(return_value=mock_user)
+    service.get_by_email = AsyncMock(return_value=mock_user)
+    return service
+
+
+@pytest.fixture
+async def client_with_mock_service(
+    mock_user_service: MagicMock,
+{%- if cookiecutter.enable_redis %}
+    mock_redis: MagicMock,
+{%- endif %}
+{%- if cookiecutter.use_database %}
+    mock_db_session,
+{%- endif %}
+) -> AsyncClient:
+    """Client with mocked user service."""
+{%- if cookiecutter.enable_redis %}
+    from app.api.deps import get_redis
+{%- endif %}
+{%- if cookiecutter.use_database %}
+    from app.api.deps import get_db_session
+{%- endif %}
+    from httpx import ASGITransport
+
+    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_login_success(client_with_mock_service: AsyncClient):
+    """Test successful login."""
+    response = await client_with_mock_service.post(
+        f"{settings.API_V1_STR}/auth/login",
+        data={"username": "test@example.com", "password": "password123"},
+    )
+    assert response.status_code == 200
+    data = response.json()
+    assert "access_token" in data
+    assert "refresh_token" in data
+    assert data["token_type"] == "bearer"
+
+
+@pytest.mark.anyio
+async def test_login_invalid_credentials(
+    client_with_mock_service: AsyncClient,
+    mock_user_service: MagicMock,
+):
+    """Test login with invalid credentials."""
+    from app.core.exceptions import AuthenticationError
+
+    mock_user_service.authenticate = AsyncMock(
+        side_effect=AuthenticationError(message="Invalid credentials")
+    )
+
+    response = await client_with_mock_service.post(
+        f"{settings.API_V1_STR}/auth/login",
+        data={"username": "test@example.com", "password": "wrongpassword"},
+    )
+    assert response.status_code == 401
+
+
+@pytest.mark.anyio
+async def test_register_success(client_with_mock_service: AsyncClient):
+    """Test successful registration."""
+    response = await client_with_mock_service.post(
+        f"{settings.API_V1_STR}/auth/register",
+        json={
+            "email": "new@example.com",
+            "password": "password123",
+            "full_name": "New User",
+        },
+    )
+    assert response.status_code == 201
+    data = response.json()
+    assert data["email"] == "test@example.com"  # From mock
+
+
+@pytest.mark.anyio
+async def test_register_duplicate_email(
+    client_with_mock_service: AsyncClient,
+    mock_user_service: MagicMock,
+):
+    """Test registration with duplicate email."""
+    from app.core.exceptions import AlreadyExistsError
+
+    mock_user_service.register = AsyncMock(
+        side_effect=AlreadyExistsError(message="Email already registered")
+    )
+
+    response = await client_with_mock_service.post(
+        f"{settings.API_V1_STR}/auth/register",
+        json={
+            "email": "existing@example.com",
+            "password": "password123",
+            "full_name": "Test User",
+        },
+    )
+    assert response.status_code == 409
+
+
+@pytest.mark.anyio
+async def test_refresh_token_success(
+    client_with_mock_service: AsyncClient,
+    mock_user: MockUser,
+):
+    """Test successful token refresh."""
+    refresh_token = create_refresh_token(subject=str(mock_user.id))
+
+    response = await client_with_mock_service.post(
+        f"{settings.API_V1_STR}/auth/refresh",
+        json={"refresh_token": refresh_token},
+    )
+    assert response.status_code == 200
+    data = response.json()
+    assert "access_token" in data
+    assert "refresh_token" in data
+
+
+@pytest.mark.anyio
+async def test_refresh_token_invalid(client_with_mock_service: AsyncClient):
+    """Test refresh with invalid token."""
+    response = await client_with_mock_service.post(
+        f"{settings.API_V1_STR}/auth/refresh",
+        json={"refresh_token": "invalid.token.here"},
+    )
+    assert response.status_code == 401
+
+
+@pytest.mark.anyio
+async def test_refresh_token_wrong_type(
+    client_with_mock_service: AsyncClient,
+    mock_user: MockUser,
+):
+    """Test refresh with access token instead of refresh token."""
+    access_token = create_access_token(subject=str(mock_user.id))
+
+    response = await client_with_mock_service.post(
+        f"{settings.API_V1_STR}/auth/refresh",
+        json={"refresh_token": access_token},
+    )
+    assert response.status_code == 401
+
+
+@pytest.mark.anyio
+async def test_refresh_token_inactive_user(
+    client_with_mock_service: AsyncClient,
+    mock_user_service: MagicMock,
+):
+    """Test refresh token for inactive user."""
+    inactive_user = MockUser(is_active=False)
+    mock_user_service.get_by_id = AsyncMock(return_value=inactive_user)
+    refresh_token = create_refresh_token(subject=str(inactive_user.id))
+
+    response = await client_with_mock_service.post(
+        f"{settings.API_V1_STR}/auth/refresh",
+        json={"refresh_token": refresh_token},
+    )
+    assert response.status_code == 401
+
+
+@pytest.mark.anyio
+async def test_get_current_user(
+    client_with_mock_service: AsyncClient,
+    mock_user: MockUser,
+    mock_user_service: MagicMock,
+):
+    """Test getting current user info."""
+    from app.api.deps import get_current_user
+
+    # Override get_current_user to return mock user
+    app.dependency_overrides[get_current_user] = lambda: mock_user
+
+    response = await client_with_mock_service.get(
+        f"{settings.API_V1_STR}/auth/me",
+    )
+    assert response.status_code == 200
+    data = response.json()
+    assert data["email"] == mock_user.email
+{%- endif %}

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

@@ -0,0 +1,151 @@
+"""Exception handler tests."""
+{%- if cookiecutter.use_jwt or cookiecutter.use_api_key %}
+# ruff: noqa: I001, E402 - Imports structured for Jinja2 template conditionals
+{%- endif %}
+
+import pytest
+from httpx import AsyncClient
+
+from app.core.config import settings
+
+
+@pytest.mark.anyio
+async def test_not_found_error_format(client: AsyncClient):
+    """Test that 404 errors return proper JSON format."""
+    response = await client.get(f"{settings.API_V1_STR}/nonexistent-endpoint")
+    assert response.status_code == 404
+    # FastAPI returns 404 for unknown routes
+
+
+{%- if cookiecutter.use_jwt %}
+
+from unittest.mock import AsyncMock, MagicMock
+
+from httpx import ASGITransport
+
+{%- if cookiecutter.enable_redis %}
+from app.api.deps import get_redis
+{%- endif %}
+{%- if cookiecutter.use_database %}
+from app.api.deps import get_db_session
+{%- endif %}
+from app.main import app
+
+
+@pytest.mark.anyio
+async def test_authentication_error_returns_401(client: AsyncClient):
+    """Test that authentication errors return 401 with proper headers."""
+    response = await client.get(
+        f"{settings.API_V1_STR}/users/me",
+        headers={"Authorization": "Bearer invalid-token"},
+    )
+    assert response.status_code == 401
+    assert "WWW-Authenticate" in response.headers
+
+
+@pytest.mark.anyio
+async def test_missing_auth_returns_401(client: AsyncClient):
+    """Test that missing authentication returns 401."""
+    response = await client.get(f"{settings.API_V1_STR}/users/me")
+    assert response.status_code == 401
+
+
+@pytest.fixture
+def mock_user_service_with_errors() -> MagicMock:
+    """Create mock user service that raises errors."""
+    from app.core.exceptions import AlreadyExistsError, AuthenticationError
+
+    service = MagicMock()
+    service.register = AsyncMock(
+        side_effect=AlreadyExistsError(message="Email already registered")
+    )
+    service.authenticate = AsyncMock(
+        side_effect=AuthenticationError(message="Invalid credentials")
+    )
+    return service
+
+
+@pytest.fixture
+async def error_client(
+    mock_user_service_with_errors: MagicMock,
+{%- if cookiecutter.enable_redis %}
+    mock_redis: MagicMock,
+{%- endif %}
+{%- if cookiecutter.use_database %}
+    mock_db_session,
+{%- endif %}
+) -> AsyncClient:
+    """Client with mocked services that raise errors."""
+    from app.api.deps import get_user_service
+
+    app.dependency_overrides[get_user_service] = lambda: mock_user_service_with_errors
+{%- 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_register_duplicate_email_returns_409(error_client: AsyncClient):
+    """Test that registering with existing email returns 409."""
+    response = await error_client.post(
+        f"{settings.API_V1_STR}/auth/register",
+        json={
+            "email": "existing@example.com",
+            "password": "password123",
+            "full_name": "Test User",
+        },
+    )
+    assert response.status_code == 409
+    data = response.json()
+    assert "error" in data
+    assert data["error"]["code"] == "ALREADY_EXISTS"
+
+
+@pytest.mark.anyio
+async def test_invalid_login_returns_401(error_client: AsyncClient):
+    """Test that invalid login credentials return 401."""
+    response = await error_client.post(
+        f"{settings.API_V1_STR}/auth/login",
+        data={
+            "username": "nonexistent@example.com",
+            "password": "wrongpassword",
+        },
+    )
+    assert response.status_code == 401
+    data = response.json()
+    assert "error" in data
+    assert data["error"]["code"] == "AUTHENTICATION_ERROR"
+{%- endif %}
+
+
+{%- if cookiecutter.use_api_key %}
+
+
+@pytest.mark.anyio
+async def test_missing_api_key_returns_401(client: AsyncClient):
+    """Test that missing API key returns 401."""
+    # Health endpoint might not require auth, but we test the middleware
+    # For endpoints that require API key, they should return 401
+    await client.get(f"{settings.API_V1_STR}/health")
+
+
+@pytest.mark.anyio
+async def test_invalid_api_key_returns_403(client: AsyncClient):
+    """Test that invalid API key returns 403."""
+    # Health endpoint might not require auth
+    await client.get(
+        f"{settings.API_V1_STR}/health",
+        headers={settings.API_KEY_HEADER: "invalid-key"},
+    )
+{%- endif %}

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

@@ -0,0 +1,113 @@
+"""Health endpoint tests."""
+{%- if cookiecutter.enable_redis or cookiecutter.use_postgresql or cookiecutter.use_mongodb %}
+
+from unittest.mock import AsyncMock
+{%- endif %}
+
+import pytest
+from httpx import AsyncClient
+
+from app.core.config import settings
+
+
+@pytest.mark.anyio
+async def test_health_check(client: AsyncClient):
+    """Test liveness probe."""
+    response = await client.get(f"{settings.API_V1_STR}/health")
+    assert response.status_code == 200
+    data = response.json()
+    assert data["status"] == "healthy"
+
+
+@pytest.mark.anyio
+async def test_readiness_check(client: AsyncClient):
+    """Test readiness probe with mocked dependencies."""
+    response = await client.get(f"{settings.API_V1_STR}/ready")
+    assert response.status_code == 200
+    data = response.json()
+    assert data["status"] in ["ready", "degraded"]
+    assert "checks" in data
+
+
+{%- if cookiecutter.enable_redis %}
+
+
+@pytest.mark.anyio
+async def test_readiness_check_redis_healthy(client: AsyncClient, mock_redis):
+    """Test readiness when Redis is healthy."""
+    mock_redis.ping = AsyncMock(return_value=True)
+
+    response = await client.get(f"{settings.API_V1_STR}/ready")
+    assert response.status_code == 200
+    data = response.json()
+    assert data["checks"]["redis"] is True
+
+
+@pytest.mark.anyio
+async def test_readiness_check_redis_unhealthy(client: AsyncClient, mock_redis):
+    """Test readiness when Redis is unhealthy."""
+    mock_redis.ping = AsyncMock(side_effect=Exception("Connection failed"))
+
+    response = await client.get(f"{settings.API_V1_STR}/ready")
+    # Should return 503 when Redis is down
+    assert response.status_code == 503
+    data = response.json()
+    assert data["status"] == "degraded"
+    assert data["checks"]["redis"] is False
+{%- endif %}
+
+
+{%- if cookiecutter.use_postgresql %}
+
+
+@pytest.mark.anyio
+async def test_readiness_check_db_healthy(client: AsyncClient, mock_db_session):
+    """Test readiness when database is healthy."""
+    # Mock successful DB query
+    mock_db_session.execute = AsyncMock()
+
+    response = await client.get(f"{settings.API_V1_STR}/ready")
+    assert response.status_code == 200
+    data = response.json()
+    assert data["checks"]["database"]["status"] == "healthy"
+
+
+@pytest.mark.anyio
+async def test_readiness_check_db_unhealthy(client: AsyncClient, mock_db_session):
+    """Test readiness when database is unhealthy."""
+    mock_db_session.execute = AsyncMock(side_effect=Exception("DB connection failed"))
+
+    response = await client.get(f"{settings.API_V1_STR}/ready")
+    # Should return 503 when DB is down
+    assert response.status_code == 503
+    data = response.json()
+    assert data["status"] == "not_ready"
+    assert data["checks"]["database"]["status"] == "unhealthy"
+{%- endif %}
+
+
+{%- if cookiecutter.use_mongodb %}
+
+
+@pytest.mark.anyio
+async def test_readiness_check_db_healthy(client: AsyncClient, mock_db_session):
+    """Test readiness when MongoDB is healthy."""
+    mock_db_session.command = AsyncMock(return_value={"ok": 1})
+
+    response = await client.get(f"{settings.API_V1_STR}/ready")
+    assert response.status_code == 200
+    data = response.json()
+    assert data["checks"]["database"] is True
+
+
+@pytest.mark.anyio
+async def test_readiness_check_db_unhealthy(client: AsyncClient, mock_db_session):
+    """Test readiness when MongoDB is unhealthy."""
+    mock_db_session.command = AsyncMock(side_effect=Exception("MongoDB connection failed"))
+
+    response = await client.get(f"{settings.API_V1_STR}/ready")
+    assert response.status_code == 503
+    data = response.json()
+    assert data["status"] == "degraded"
+    assert data["checks"]["database"] is False
+{%- endif %}