Testing Strategy

import pytest
from httpx import AsyncClient, ASGITransport
from api.main import create_app
from api import dependencies
from infrastructure.database.adapters.inmemory.repositories.account_repository import InMemoryAccountRepository
from infrastructure.database.adapters.inmemory.unit_of_work import InMemoryUnitOfWork
from infrastructure.events.adapters.inmemory import InMemoryEventPublisher
from infrastructure.monitoring.adapters.inmemory import InMemoryPerformanceMonitor
from infrastructure.authentication.jwt_token import PyJWTService
from config.settings import Settings
 
 
@pytest.fixture
def test_settings() -> Settings:
    return Settings(
        environment="testing",
        database_adapter="inmemory",
        event_adapter="inmemory",
        monitoring_adapter="inmemory",
        auth_jwt_secret="test-secret-key",
        auth_jwt_access_token_expire_minutes=60,
    )
 
 
@pytest.fixture
def account_store() -> dict:
    """Shared in-memory store — passed to both repo and UoW."""
    return {}
 
 
@pytest.fixture
def account_repo(account_store):
    return InMemoryAccountRepository()
 
 
@pytest.fixture
def unit_of_work(account_store):
    return InMemoryUnitOfWork(account_store)
 
 
@pytest.fixture
def event_publisher():
    return InMemoryEventPublisher()
 
 
@pytest.fixture
def monitor():
    return InMemoryPerformanceMonitor()
 
 
@pytest.fixture
def jwt_service(test_settings):
    return PyJWTService(
        secret=test_settings.auth_jwt_secret,
        access_expire_minutes=test_settings.auth_jwt_access_token_expire_minutes,
    )
 
 
@pytest.fixture
async def client(
    account_repo, unit_of_work, event_publisher, monitor, jwt_service, test_settings
):
    """AsyncClient with all dependencies overridden to use in-memory adapters."""
    app = create_app(test_settings)
 
    app.dependency_overrides[dependencies.get_account_repository] = lambda: account_repo
    app.dependency_overrides[dependencies.get_unit_of_work] = lambda: unit_of_work
    app.dependency_overrides[dependencies.get_event_publisher] = lambda: event_publisher
    app.dependency_overrides[dependencies.get_performance_monitor] = lambda: monitor
    app.dependency_overrides[dependencies.get_jwt_service] = lambda: jwt_service
 
    async with AsyncClient(
        transport=ASGITransport(app=app), base_url="http://test"
    ) as c:
        yield c
 
 
@pytest.fixture
def auth_token(jwt_service) -> str:
    """A valid JWT for a test user."""
    from uuid import uuid4
    return jwt_service.generate_token(
        account_id=uuid4(),
        account_type="user",
        roles=["user"],
    )
 
 
@pytest.fixture
def auth_headers(auth_token) -> dict:
    return {"Authorization": f"Bearer {auth_token}"}

# tests/test_routes/test_accounts.py
import pytest
 
 
@pytest.mark.asyncio
async def test_create_account_returns_201(client):
    response = await client.post("/api/v1/accounts", json={
        "email": "[email protected]",
        "display_name": "Test User",
        "password": "securepassword123",
    })
    assert response.status_code == 201
    data = response.json()
    assert data["email"] == "[email protected]"
    assert "id" in data
 
 
@pytest.mark.asyncio
async def test_get_account_requires_auth(client):
    response = await client.get("/api/v1/accounts/some-id")
    assert response.status_code == 401
 
 
@pytest.mark.asyncio
async def test_get_account_not_found_returns_404(client, auth_headers):
    response = await client.get(
        "/api/v1/accounts/00000000-0000-0000-0000-000000000000",
        headers=auth_headers,
    )
    assert response.status_code == 404
    assert response.json()["error_code"] == "ACCOUNT_NOT_FOUND"

# tests/test_handlers/test_create_account.py
import pytest
from application.account.create import CreateAccountHandler, CreateAccountCommand
 
 
@pytest.mark.asyncio
async def test_create_account_publishes_event(account_repo, unit_of_work, event_publisher, monitor):
    handler = CreateAccountHandler(
        account_repository=account_repo,
        unit_of_work=unit_of_work,
        event_publisher=event_publisher,
        monitor=monitor,
    )
    command = CreateAccountCommand(email="[email protected]", display_name="Test")
    account = await handler.execute(command)
 
    assert account.email == "[email protected]"
    assert len(event_publisher.published) == 1
    assert event_publisher.published[0].event_type == "account.created"
 
 
@pytest.mark.asyncio
async def test_create_account_duplicate_email_raises_conflict(
    account_repo, unit_of_work, event_publisher, monitor
):
    handler = CreateAccountHandler(account_repo, unit_of_work, event_publisher, monitor)
    command = CreateAccountCommand(email="[email protected]", display_name="Test")
    await handler.execute(command)
 
    with pytest.raises(ConflictError):
        await handler.execute(command)

# pyproject.toml
[tool.pytest.ini_options]
asyncio_mode = "auto"
testpaths = ["tests"]
 
[tool.coverage.run]
source = ["api", "application", "domain", "infrastructure"]
omit = ["tests/*", "*/migrations/*"]