Contributing Guide¶

async def get_user_by_email(
    session: AsyncSession,
    email: str,
) -> User | None:
    """
    Get a user by their email address.

    Args:
        session: Database session.
        email: Email to search for.

    Returns:
        User if found, None otherwise.
    """
    result = await session.execute(
        select(User).where(User.email == email)
    )
    return result.scalar_one_or_none()

async def get_user_by_email(session, email):  # Missing type hints
    result = await session.execute(select(User).where(User.email == email))
    return result.scalar_one_or_none()

# 1. Standard library
import json
from datetime import datetime

# 2. Third-party
from fastapi import APIRouter, HTTPException
from sqlmodel import select

# 3. Local imports
from app.core.config import settings
from app.models.user import User

# tests/unit/test_project_service.py

import pytest
from unittest.mock import AsyncMock, MagicMock

from app.business.project_service import project_service
from app.models.project import Project
from app.schemas.project import ProjectCreate


@pytest.fixture
def mock_session():
    """Create a mock database session."""
    session = AsyncMock()
    return session


@pytest.fixture
def sample_project():
    """Create a sample project."""
    return Project(
        id="test-id",
        name="Test Project",
        description="A test project",
        owner_id="user-123",
    )


class TestProjectService:
    async def test_create_with_owner(self, mock_session):
        """Test creating a project with owner."""
        # Arrange
        create_data = ProjectCreate(name="New Project", description="Description")
        mock_session.flush = AsyncMock()
        mock_session.refresh = AsyncMock()

        # Act
        result = await project_service.create_with_owner(
            mock_session,
            obj_in=create_data,
            owner_id="user-123",
        )

        # Assert
        assert result.name == "New Project"
        assert result.owner_id == "user-123"
        mock_session.add.assert_called_once()


    async def test_get_not_found(self, mock_session):
        """Test getting a non-existent project."""
        # Arrange
        mock_result = MagicMock()
        mock_result.scalar_one_or_none.return_value = None
        mock_session.execute.return_value = mock_result

        # Act
        result = await project_service.get(mock_session, id="non-existent")

        # Assert
        assert result is None

# tests/integration/test_api_projects.py

import pytest
from httpx import AsyncClient


@pytest.fixture
async def auth_headers(client: AsyncClient) -> dict:
    """Get authentication headers with a valid token."""
    # Create test token
    return {"Authorization": "Bearer test-token"}


class TestProjectsAPI:
    async def test_create_project(self, client: AsyncClient, auth_headers: dict):
        """Test creating a new project."""
        response = await client.post(
            "/api/v1/app/projects",
            json={"name": "Test Project", "description": "A test"},
            headers=auth_headers,
        )

        assert response.status_code == 201
        data = response.json()
        assert data["name"] == "Test Project"
        assert "id" in data


    async def test_list_projects_pagination(
        self, client: AsyncClient, auth_headers: dict
    ):
        """Test listing projects with pagination."""
        # Create multiple projects first
        for i in range(25):
            await client.post(
                "/api/v1/app/projects",
                json={"name": f"Project {i}"},
                headers=auth_headers,
            )

        # Test first page
        response = await client.get(
            "/api/v1/app/projects",
            params={"skip": 0, "limit": 10},
            headers=auth_headers,
        )

        assert response.status_code == 200
        data = response.json()
        assert len(data["items"]) == 10
        assert data["total"] >= 25
        assert data["skip"] == 0
        assert data["limit"] == 10


    async def test_create_project_unauthenticated(self, client: AsyncClient):
        """Test that unauthenticated requests are rejected."""
        response = await client.post(
            "/api/v1/app/projects",
            json={"name": "Test"},
        )

        assert response.status_code == 401

# Use Python debugger
import pdb; pdb.set_trace()

# Or better, use ipdb
import ipdb; ipdb.set_trace()

# Print SQL queries
# Add to .env: SQLALCHEMY_ECHO=true