claude-code-templates 1.21.1 → 1.21.2

package/cli-tool/templates/python/examples/fastapi-app/.claude/commands/testing.md

@@ -1,927 +0,0 @@
-# FastAPI Testing Framework
-
-Comprehensive testing setup for FastAPI applications with pytest and async support.
-
-## Usage
-
-```bash
-# Run all tests
-pytest
-
-# Run with coverage
-pytest --cov=app --cov-report=html
-
-# Run specific test file
-pytest tests/test_api.py
-
-# Run with verbose output
-pytest -v -s
-```
-
-## Test Configuration
-
-```python
-# pytest.ini
-[tool:pytest]
-testpaths = tests
-python_files = test_*.py
-python_classes = Test*
-python_functions = test_*
-addopts = 
-    --cov=app
-    --cov-report=term-missing
-    --cov-report=html:htmlcov
-    --asyncio-mode=auto
-    --strict-markers
-    --disable-warnings
-markers =
-    unit: Unit tests
-    integration: Integration tests
-    e2e: End-to-end tests
-    slow: Slow running tests
-    auth: Authentication tests
-    api: API tests
-asyncio_mode = auto
-```
-
-## Test Dependencies
-
-```python
-# requirements/test.txt
-pytest>=7.0.0
-pytest-asyncio>=0.21.0
-pytest-cov>=4.0.0
-httpx>=0.24.0
-factory-boy>=3.2.0
-faker>=18.0.0
-respx>=0.20.0
-pytest-mock>=3.10.0
-```
-
-## Test Fixtures
-
-```python
-# tests/conftest.py
-import pytest
-import asyncio
-from typing import AsyncGenerator, Generator
-from fastapi.testclient import TestClient
-from httpx import AsyncClient
-from sqlalchemy.ext.asyncio import create_async_engine, AsyncSession
-from sqlalchemy.orm import sessionmaker
-from app.main import app
-from app.db.database import get_db, Base
-from app.models.user import User
-from app.core.security import get_password_hash
-from tests.factories import UserFactory
-
-# Test database URL
-TEST_DATABASE_URL = "sqlite+aiosqlite:///./test.db"
-
-@pytest.fixture(scope="session")
-def event_loop() -> Generator[asyncio.AbstractEventLoop, None, None]:
-    """Create event loop for the test session."""
-    loop = asyncio.get_event_loop_policy().new_event_loop()
-    yield loop
-    loop.close()
-
-@pytest.fixture(scope="session")
-async def test_engine():
-    """Create test database engine."""
-    engine = create_async_engine(
-        TEST_DATABASE_URL,
-        echo=False,
-        future=True
-    )
-    
-    # Create tables
-    async with engine.begin() as conn:
-        await conn.run_sync(Base.metadata.create_all)
-    
-    yield engine
-    
-    # Drop tables and dispose engine
-    async with engine.begin() as conn:
-        await conn.run_sync(Base.metadata.drop_all)
-    
-    await engine.dispose()
-
-@pytest.fixture
-async def db_session(test_engine) -> AsyncGenerator[AsyncSession, None]:
-    """Create database session for testing."""
-    TestSessionLocal = sessionmaker(
-        test_engine, 
-        class_=AsyncSession, 
-        expire_on_commit=False
-    )
-    
-    async with TestSessionLocal() as session:
-        yield session
-
-@pytest.fixture
-def override_get_db(db_session: AsyncSession) -> Generator:
-    """Override database dependency."""
-    async def _override_get_db():
-        yield db_session
-    
-    app.dependency_overrides[get_db] = _override_get_db
-    yield
-    app.dependency_overrides = {}
-
-@pytest.fixture
-def client(override_get_db) -> Generator[TestClient, None, None]:
-    """Create test client."""
-    with TestClient(app) as test_client:
-        yield test_client
-
-@pytest.fixture
-async def async_client(override_get_db) -> AsyncGenerator[AsyncClient, None]:
-    """Create async test client."""
-    async with AsyncClient(app=app, base_url="http://test") as ac:
-        yield ac
-
-@pytest.fixture
-async def test_user(db_session: AsyncSession) -> User:
-    """Create test user."""
-    user_data = {
-        "username": "testuser",
-        "email": "test@example.com",
-        "hashed_password": get_password_hash("testpass123"),
-        "first_name": "Test",
-        "last_name": "User",
-        "is_active": True,
-        "is_superuser": False
-    }
-    
-    user = User(**user_data)
-    db_session.add(user)
-    await db_session.commit()
-    await db_session.refresh(user)
-    return user
-
-@pytest.fixture
-async def superuser(db_session: AsyncSession) -> User:
-    """Create superuser."""
-    user_data = {
-        "username": "admin",
-        "email": "admin@example.com",
-        "hashed_password": get_password_hash("adminpass123"),
-        "first_name": "Admin",
-        "last_name": "User",
-        "is_active": True,
-        "is_superuser": True
-    }
-    
-    user = User(**user_data)
-    db_session.add(user)
-    await db_session.commit()
-    await db_session.refresh(user)
-    return user
-
-@pytest.fixture
-def user_token(test_user: User) -> str:
-    """Create authentication token for test user."""
-    from app.core.security import create_access_token
-    return create_access_token(subject=test_user.id)
-
-@pytest.fixture
-def superuser_token(superuser: User) -> str:
-    """Create authentication token for superuser."""
-    from app.core.security import create_access_token
-    return create_access_token(subject=superuser.id)
-
-@pytest.fixture
-def auth_headers(user_token: str) -> dict[str, str]:
-    """Create authorization headers."""
-    return {"Authorization": f"Bearer {user_token}"}
-
-@pytest.fixture
-def superuser_headers(superuser_token: str) -> dict[str, str]:
-    """Create superuser authorization headers."""
-    return {"Authorization": f"Bearer {superuser_token}"}
-```
-
-## Test Factories
-
-```python
-# tests/factories.py
-import factory
-from factory import Faker, SubFactory
-from app.models.user import User
-from app.models.post import Post
-from app.core.security import get_password_hash
-
-class UserFactory(factory.Factory):
-    """Factory for User model."""
-    
-    class Meta:
-        model = User
-    
-    username = Faker('user_name')
-    email = Faker('email')
-    first_name = Faker('first_name')
-    last_name = Faker('last_name')
-    hashed_password = factory.LazyAttribute(lambda obj: get_password_hash('testpass123'))
-    is_active = True
-    is_superuser = False
-    bio = Faker('text', max_nb_chars=200)
-
-class SuperUserFactory(UserFactory):
-    """Factory for superuser."""
-    username = 'admin'
-    email = 'admin@example.com'
-    first_name = 'Admin'
-    last_name = 'User'
-    is_superuser = True
-
-class PostFactory(factory.Factory):
-    """Factory for Post model."""
-    
-    class Meta:
-        model = Post
-    
-    title = Faker('sentence', nb_words=4)
-    content = Faker('text', max_nb_chars=1000)
-    slug = Faker('slug')
-    is_published = True
-    author = SubFactory(UserFactory)
-
-class InactiveUserFactory(UserFactory):
-    """Factory for inactive user."""
-    is_active = False
-```
-
-## API Testing
-
-```python
-# tests/test_api/test_users.py
-import pytest
-from httpx import AsyncClient
-from app.models.user import User
-from tests.factories import UserFactory
-
-class TestUserAPI:
-    """Test User API endpoints."""
-    
-    @pytest.mark.asyncio
-    async def test_create_user(
-        self, 
-        async_client: AsyncClient, 
-        superuser_headers: dict
-    ):
-        """Test POST /api/v1/users/."""
-        user_data = {
-            "username": "newuser",
-            "email": "new@example.com",
-            "password": "newpass123",
-            "first_name": "New",
-            "last_name": "User"
-        }
-        
-        response = await async_client.post(
-            "/api/v1/users/",
-            json=user_data,
-            headers=superuser_headers
-        )
-        
-        assert response.status_code == 201
-        data = response.json()
-        assert data["username"] == user_data["username"]
-        assert data["email"] == user_data["email"]
-        assert "password" not in data
-        assert "hashed_password" not in data
-    
-    @pytest.mark.asyncio
-    async def test_get_users(
-        self, 
-        async_client: AsyncClient, 
-        test_user: User,
-        auth_headers: dict
-    ):
-        """Test GET /api/v1/users/."""
-        response = await async_client.get(
-            "/api/v1/users/",
-            headers=auth_headers
-        )
-        
-        assert response.status_code == 200
-        data = response.json()
-        assert "items" in data
-        assert "total" in data
-        assert "page" in data
-        assert "size" in data
-        assert len(data["items"]) >= 1
-    
-    @pytest.mark.asyncio
-    async def test_get_user(
-        self, 
-        async_client: AsyncClient, 
-        test_user: User,
-        auth_headers: dict
-    ):
-        """Test GET /api/v1/users/{id}."""
-        response = await async_client.get(
-            f"/api/v1/users/{test_user.id}",
-            headers=auth_headers
-        )
-        
-        assert response.status_code == 200
-        data = response.json()
-        assert data["id"] == test_user.id
-        assert data["username"] == test_user.username
-        assert data["email"] == test_user.email
-    
-    @pytest.mark.asyncio
-    async def test_update_user(
-        self, 
-        async_client: AsyncClient, 
-        test_user: User,
-        auth_headers: dict
-    ):
-        """Test PUT /api/v1/users/{id}."""
-        update_data = {
-            "first_name": "Updated",
-            "last_name": "Name",
-            "bio": "Updated bio"
-        }
-        
-        response = await async_client.put(
-            f"/api/v1/users/{test_user.id}",
-            json=update_data,
-            headers=auth_headers
-        )
-        
-        assert response.status_code == 200
-        data = response.json()
-        assert data["first_name"] == update_data["first_name"]
-        assert data["last_name"] == update_data["last_name"]
-        assert data["bio"] == update_data["bio"]
-    
-    @pytest.mark.asyncio
-    async def test_delete_user(
-        self, 
-        async_client: AsyncClient, 
-        test_user: User,
-        superuser_headers: dict
-    ):
-        """Test DELETE /api/v1/users/{id}."""
-        response = await async_client.delete(
-            f"/api/v1/users/{test_user.id}",
-            headers=superuser_headers
-        )
-        
-        assert response.status_code == 204
-        
-        # Verify user is deleted
-        get_response = await async_client.get(
-            f"/api/v1/users/{test_user.id}",
-            headers=superuser_headers
-        )
-        assert get_response.status_code == 404
-    
-    @pytest.mark.asyncio
-    async def test_unauthorized_access(self, async_client: AsyncClient):
-        """Test unauthorized access to protected endpoints."""
-        response = await async_client.get("/api/v1/users/")
-        assert response.status_code == 401
-    
-    @pytest.mark.asyncio
-    async def test_forbidden_access(
-        self, 
-        async_client: AsyncClient, 
-        auth_headers: dict
-    ):
-        """Test forbidden access to admin endpoints."""
-        user_data = {
-            "username": "unauthorized",
-            "email": "unauthorized@example.com",
-            "password": "pass123"
-        }
-        
-        response = await async_client.post(
-            "/api/v1/users/",
-            json=user_data,
-            headers=auth_headers  # Regular user, not superuser
-        )
-        
-        assert response.status_code == 403
-```
-
-## Authentication Testing
-
-```python
-# tests/test_api/test_auth.py
-import pytest
-from httpx import AsyncClient
-from app.models.user import User
-from app.core.security import create_access_token, decode_token
-
-class TestAuthAPI:
-    """Test authentication API endpoints."""
-    
-    @pytest.mark.asyncio
-    async def test_register(
-        self, 
-        async_client: AsyncClient
-    ):
-        """Test user registration."""
-        user_data = {
-            "username": "newuser",
-            "email": "new@example.com",
-            "password": "newpass123",
-            "first_name": "New",
-            "last_name": "User"
-        }
-        
-        response = await async_client.post(
-            "/api/v1/auth/register",
-            json=user_data
-        )
-        
-        assert response.status_code == 201
-        data = response.json()
-        assert data["username"] == user_data["username"]
-        assert data["email"] == user_data["email"]
-        assert "password" not in data
-    
-    @pytest.mark.asyncio
-    async def test_register_duplicate_email(
-        self, 
-        async_client: AsyncClient, 
-        test_user: User
-    ):
-        """Test registration with duplicate email."""
-        user_data = {
-            "username": "different",
-            "email": test_user.email,  # Duplicate email
-            "password": "pass123",
-            "first_name": "Test",
-            "last_name": "User"
-        }
-        
-        response = await async_client.post(
-            "/api/v1/auth/register",
-            json=user_data
-        )
-        
-        assert response.status_code == 400
-        assert "Email already registered" in response.json()["detail"]
-    
-    @pytest.mark.asyncio
-    async def test_login(
-        self, 
-        async_client: AsyncClient, 
-        test_user: User
-    ):
-        """Test user login."""
-        login_data = {
-            "username": test_user.username,
-            "password": "testpass123"
-        }
-        
-        response = await async_client.post(
-            "/api/v1/auth/login",
-            data=login_data,
-            headers={"Content-Type": "application/x-www-form-urlencoded"}
-        )
-        
-        assert response.status_code == 200
-        data = response.json()
-        assert "access_token" in data
-        assert "refresh_token" in data
-        assert data["token_type"] == "bearer"
-        assert "expires_in" in data
-        
-        # Verify token is valid
-        payload = decode_token(data["access_token"])
-        assert payload is not None
-        assert payload["sub"] == str(test_user.id)
-    
-    @pytest.mark.asyncio
-    async def test_login_invalid_credentials(
-        self, 
-        async_client: AsyncClient, 
-        test_user: User
-    ):
-        """Test login with invalid credentials."""
-        login_data = {
-            "username": test_user.username,
-            "password": "wrongpassword"
-        }
-        
-        response = await async_client.post(
-            "/api/v1/auth/login",
-            data=login_data,
-            headers={"Content-Type": "application/x-www-form-urlencoded"}
-        )
-        
-        assert response.status_code == 401
-        assert "Incorrect username or password" in response.json()["detail"]
-    
-    @pytest.mark.asyncio
-    async def test_get_current_user(
-        self, 
-        async_client: AsyncClient, 
-        test_user: User,
-        auth_headers: dict
-    ):
-        """Test get current user endpoint."""
-        response = await async_client.get(
-            "/api/v1/auth/me",
-            headers=auth_headers
-        )
-        
-        assert response.status_code == 200
-        data = response.json()
-        assert data["id"] == test_user.id
-        assert data["username"] == test_user.username
-        assert data["email"] == test_user.email
-    
-    @pytest.mark.asyncio
-    async def test_refresh_token(
-        self, 
-        async_client: AsyncClient, 
-        test_user: User
-    ):
-        """Test token refresh."""
-        from app.core.security import create_refresh_token
-        
-        refresh_token = create_refresh_token(subject=test_user.id)
-        
-        response = await async_client.post(
-            "/api/v1/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
-        assert data["token_type"] == "bearer"
-    
-    @pytest.mark.asyncio
-    async def test_change_password(
-        self, 
-        async_client: AsyncClient, 
-        test_user: User,
-        auth_headers: dict
-    ):
-        """Test password change."""
-        password_data = {
-            "current_password": "testpass123",
-            "new_password": "newpass123"
-        }
-        
-        response = await async_client.post(
-            "/api/v1/auth/change-password",
-            json=password_data,
-            headers=auth_headers
-        )
-        
-        assert response.status_code == 200
-        assert "Password changed successfully" in response.json()["message"]
-```
-
-## Model Testing
-
-```python
-# tests/test_models/test_user.py
-import pytest
-from sqlalchemy.ext.asyncio import AsyncSession
-from app.models.user import User
-from app.core.security import verify_password, get_password_hash
-
-class TestUserModel:
-    """Test User model."""
-    
-    @pytest.mark.asyncio
-    async def test_create_user(self, db_session: AsyncSession):
-        """Test user creation."""
-        user_data = {
-            "username": "testuser",
-            "email": "test@example.com",
-            "hashed_password": get_password_hash("password123"),
-            "first_name": "Test",
-            "last_name": "User"
-        }
-        
-        user = User(**user_data)
-        db_session.add(user)
-        await db_session.commit()
-        await db_session.refresh(user)
-        
-        assert user.id is not None
-        assert user.username == "testuser"
-        assert user.email == "test@example.com"
-        assert user.full_name == "Test User"
-        assert user.is_active is True
-        assert user.is_superuser is False
-        assert user.created_at is not None
-        assert user.updated_at is not None
-    
-    def test_password_verification(self):
-        """Test password verification."""
-        password = "testpassword123"
-        hashed = get_password_hash(password)
-        
-        user = User(
-            username="test",
-            email="test@example.com",
-            hashed_password=hashed,
-            first_name="Test",
-            last_name="User"
-        )
-        
-        assert user.verify_password(password)
-        assert not user.verify_password("wrongpassword")
-    
-    def test_user_dict_excludes_password(self):
-        """Test that dict() method excludes password."""
-        user = User(
-            username="test",
-            email="test@example.com",
-            hashed_password="hashed_password",
-            first_name="Test",
-            last_name="User"
-        )
-        
-        user_dict = user.dict()
-        assert "hashed_password" not in user_dict
-        assert "username" in user_dict
-        assert "email" in user_dict
-    
-    def test_user_repr(self):
-        """Test user string representation."""
-        user = User(
-            id=1,
-            username="test",
-            email="test@example.com",
-            hashed_password="hash",
-            first_name="Test",
-            last_name="User"
-        )
-        
-        assert repr(user) == "<User(id=1)>"
-```
-
-## Repository Testing
-
-```python
-# tests/test_repositories/test_user.py
-import pytest
-from sqlalchemy.ext.asyncio import AsyncSession
-from app.models.user import User
-from app.repositories.user import UserRepository
-from app.core.security import get_password_hash
-
-class TestUserRepository:
-    """Test UserRepository."""
-    
-    @pytest.mark.asyncio
-    async def test_create_user(self, db_session: AsyncSession):
-        """Test user creation through repository."""
-        repo = UserRepository(User, db_session)
-        
-        user_data = {
-            "username": "repouser",
-            "email": "repo@example.com",
-            "hashed_password": get_password_hash("password123"),
-            "first_name": "Repo",
-            "last_name": "User"
-        }
-        
-        user = await repo.create(user_data)
-        
-        assert user.id is not None
-        assert user.username == "repouser"
-        assert user.email == "repo@example.com"
-    
-    @pytest.mark.asyncio
-    async def test_get_by_email(self, db_session: AsyncSession, test_user: User):
-        """Test get user by email."""
-        repo = UserRepository(User, db_session)
-        
-        found_user = await repo.get_by_email(test_user.email)
-        
-        assert found_user is not None
-        assert found_user.id == test_user.id
-        assert found_user.email == test_user.email
-    
-    @pytest.mark.asyncio
-    async def test_get_by_username(self, db_session: AsyncSession, test_user: User):
-        """Test get user by username."""
-        repo = UserRepository(User, db_session)
-        
-        found_user = await repo.get_by_username(test_user.username)
-        
-        assert found_user is not None
-        assert found_user.id == test_user.id
-        assert found_user.username == test_user.username
-    
-    @pytest.mark.asyncio
-    async def test_get_multi_with_pagination(
-        self, 
-        db_session: AsyncSession, 
-        test_user: User
-    ):
-        """Test get multiple users with pagination."""
-        repo = UserRepository(User, db_session)
-        
-        # Create additional users
-        for i in range(5):
-            user_data = {
-                "username": f"user{i}",
-                "email": f"user{i}@example.com",
-                "hashed_password": get_password_hash("password123"),
-                "first_name": f"User{i}",
-                "last_name": "Test"
-            }
-            await repo.create(user_data)
-        
-        # Test pagination
-        users = await repo.get_multi(skip=0, limit=3)
-        assert len(users) == 3
-        
-        users_page_2 = await repo.get_multi(skip=3, limit=3)
-        assert len(users_page_2) >= 1  # At least test_user
-    
-    @pytest.mark.asyncio
-    async def test_update_user(self, db_session: AsyncSession, test_user: User):
-        """Test user update."""
-        repo = UserRepository(User, db_session)
-        
-        updated_user = await repo.update(test_user.id, {
-            "first_name": "Updated",
-            "bio": "Updated bio"
-        })
-        
-        assert updated_user is not None
-        assert updated_user.first_name == "Updated"
-        assert updated_user.bio == "Updated bio"
-    
-    @pytest.mark.asyncio
-    async def test_delete_user(self, db_session: AsyncSession, test_user: User):
-        """Test user deletion."""
-        repo = UserRepository(User, db_session)
-        
-        result = await repo.delete(test_user.id)
-        assert result is True
-        
-        # Verify user is deleted
-        deleted_user = await repo.get(test_user.id)
-        assert deleted_user is None
-```
-
-## Performance Testing
-
-```python
-# tests/test_performance.py
-import pytest
-import time
-import asyncio
-from httpx import AsyncClient
-from app.models.user import User
-from tests.factories import UserFactory
-
-@pytest.mark.slow
-class TestPerformance:
-    """Test application performance."""
-    
-    @pytest.mark.asyncio
-    async def test_concurrent_requests(
-        self, 
-        async_client: AsyncClient,
-        auth_headers: dict
-    ):
-        """Test concurrent API requests."""
-        
-        async def make_request():
-            response = await async_client.get(
-                "/api/v1/users/",
-                headers=auth_headers
-            )
-            return response.status_code
-        
-        # Make 10 concurrent requests
-        start_time = time.time()
-        tasks = [make_request() for _ in range(10)]
-        results = await asyncio.gather(*tasks)
-        end_time = time.time()
-        
-        # All requests should succeed
-        assert all(status == 200 for status in results)
-        
-        # Should complete within reasonable time
-        assert (end_time - start_time) < 5.0
-    
-    @pytest.mark.asyncio
-    async def test_large_dataset_pagination(
-        self, 
-        async_client: AsyncClient,
-        db_session,
-        auth_headers: dict
-    ):
-        """Test pagination with large dataset."""
-        # Create 100 users
-        users = []
-        for i in range(100):
-            user = UserFactory.build()
-            users.append(user)
-        
-        db_session.add_all(users)
-        await db_session.commit()
-        
-        # Test pagination performance
-        start_time = time.time()
-        response = await async_client.get(
-            "/api/v1/users/?skip=0&limit=50",
-            headers=auth_headers
-        )
-        end_time = time.time()
-        
-        assert response.status_code == 200
-        data = response.json()
-        assert len(data["items"]) == 50
-        
-        # Should complete quickly
-        assert (end_time - start_time) < 1.0
-```
-
-## Mocking External Services
-
-```python
-# tests/test_external.py
-import pytest
-import respx
-import httpx
-from app.services.email import EmailService
-
-class TestExternalServices:
-    """Test external service integrations."""
-    
-    @pytest.mark.asyncio
-    @respx.mock
-    async def test_email_service(
-        self, 
-        async_client: AsyncClient
-    ):
-        """Test email service with mocked external API."""
-        # Mock email service API
-        respx.post("https://api.emailservice.com/send").mock(
-            return_value=httpx.Response(
-                200, 
-                json={"message": "Email sent successfully"}
-            )
-        )
-        
-        email_service = EmailService()
-        result = await email_service.send_email(
-            to="test@example.com",
-            subject="Test",
-            body="Test email"
-        )
-        
-        assert result["success"] is True
-```
-
-## Test Utilities
-
-```python
-# tests/utils.py
-from typing import Dict, Any
-from httpx import Response
-import json
-
-def assert_response_status(response: Response, expected_status: int = 200):
-    """Assert response status code."""
-    assert response.status_code == expected_status, f"Expected {expected_status}, got {response.status_code}. Response: {response.text}"
-
-def assert_response_json(response: Response, expected_keys: list[str] = None):
-    """Assert response is valid JSON with expected keys."""
-    assert response.headers.get("content-type") == "application/json"
-    data = response.json()
-    
-    if expected_keys:
-        for key in expected_keys:
-            assert key in data, f"Missing key '{key}' in response"
-    
-    return data
-
-def create_auth_headers(token: str) -> Dict[str, str]:
-    """Create authorization headers with token."""
-    return {"Authorization": f"Bearer {token}"}
-
-async def create_test_users(db_session, count: int = 5) -> list:
-    """Create multiple test users."""
-    from tests.factories import UserFactory
-    
-    users = []
-    for i in range(count):
-        user = UserFactory.build()
-        users.append(user)
-    
-    db_session.add_all(users)
-    await db_session.commit()
-    
-    return users
-```