from datetime import datetime, date
from typing import Optional
from pydantic import BaseModel, Field, field_validator, model_validator

class TaskCreate(BaseModel):
    title: str = Field(..., min_length=3, max_length=100, description="Назва завдання")
    description: Optional[str] = Field(None, max_length=1000)
    due_date: Optional[date] = Field(None, description="Дедлайн виконання")
    priority: int = Field(default=1, ge=1, le=5, description="Пріоритет від 1 до 5")

    @field_validator("due_date")
    @classmethod
    def prevent_past_dates(cls, value: Optional[date]) -> Optional[date]:
        if value and value < date.today():
            raise ValueError("Дедлайн не може бути в минулому")
        return value

    @model_validator(mode="after")
    def validate_title_description(self) -> "TaskCreate":
        if self.title.lower() in (self.description or "").lower():
            raise ValueError("Опис завдання не повинен повністю містити назву завдання")
        return self

from datetime import date, timedelta
import pytest
from pydantic import ValidationError
from app.schemas.task import TaskCreate

@pytest.mark.unit
def test_task_create_valid_data():
    """Тест успішної валідації з коректними даними."""
    valid_data = {
        "title": "Learn FastAPI testing",
        "description": "Read article about pytest, fixtures and write unit tests.",
        "due_date": date.today() + timedelta(days=1),
        "priority": 3
    }

    task = TaskCreate(**valid_data)

    assert task.title == valid_data["title"]
    assert task.description == valid_data["description"]
    assert task.due_date == valid_data["due_date"]
    assert task.priority == valid_data["priority"]

@pytest.mark.unit
def test_task_create_title_too_short():
    """Перевірка помилки валідації, якщо назва занадто коротка."""
    invalid_data = {
        "title": "Ab",  # Менше 3 символів
        "priority": 1
    }

    # Контекстний менеджер очікує підняття вказаної помилки
    with pytest.raises(ValidationError) as exc_info:
        TaskCreate(**invalid_data)

    # exc_info.value містить екземпляр ValidationError
    errors = exc_info.value.errors()
    assert len(errors) == 1
    assert errors[0]["loc"] == ("title",)
    assert errors[0]["type"] == "string_too_short"

# Продовження файлу tests/unit/test_task_schemas.py

@pytest.mark.unit
@pytest.mark.parametrize(
    "invalid_priority",
    [0, 6, -1, 10]
)
def test_task_create_invalid_priority(invalid_priority):
    """Перевірка обмежень для поля priority (має бути від 1 до 5)."""
    invalid_data = {
        "title": "Learn pytest",
        "priority": invalid_priority
    }

    with pytest.raises(ValidationError) as exc_info:
        TaskCreate(**invalid_data)

    errors = exc_info.value.errors()
    assert errors[0]["loc"] == ("priority",)
    # Pydantic повертає детальний опис помилки обмеження
    assert "greater_than_equal" in errors[0]["type"] or "less_than_equal" in errors[0]["type"]

# Продовження файлу tests/unit/test_task_schemas.py

@pytest.mark.unit
@pytest.mark.parametrize(
    "due_date_value, should_be_valid",
    [
        (date.today(), True),  # Сьогодні — дозволено
        (date.today() + timedelta(days=1), True),  # Майбутнє — дозволено
        (date.today() - timedelta(days=1), False),  # Вчора — помилка
        (date.today() - timedelta(days=365), False),  # Рік тому — помилка
    ]
)
def test_task_due_date_validation(due_date_value, should_be_valid):
    """Тестування кастомного валідатора prevent_past_dates."""
    data = {
        "title": "Build a house",
        "due_date": due_date_value,
        "priority": 1
    }

    if should_be_valid:
        task = TaskCreate(**data)
        assert task.due_date == due_date_value
    else:
        with pytest.raises(ValidationError) as exc_info:
            TaskCreate(**data)
        errors = exc_info.value.errors()
        assert errors[0]["loc"] == ("due_date",)
        assert "Дедлайн не може бути в минулому" in errors[0]["msg"]

import pytest
from fastapi.testclient import TestClient
from httpx import AsyncClient
from app.main import app  # Імпорт вашого FastAPI застосунку

# 1. Синхронний клієнт для простих тестів
@pytest.fixture(scope="module")
def client():
    """Фікстура для створення синхронного тестового клієнта."""
    # Context manager гарантує спрацювання подій startup/shutdown застосунку
    with TestClient(app) as c:
        yield c

# 2. Асинхронний клієнт для тестування асинхронних ендпоінтів
@pytest.fixture(scope="module")
async def async_client():
    """Фікстура для створення асинхронного тестового клієнта."""
    # AsyncClient приймає наш app і base_url
    async with AsyncClient(app=app, base_url="http://test") as ac:
        yield ac

from fastapi import FastAPI

app = FastAPI()

@app.get("/health")
def health_check():
    return {"status": "healthy", "version": "1.0.0"}

import pytest

@pytest.mark.integration
def test_health_check_sync(client):
    """Синхронний тест ендпоінту /health."""
    response = client.get("/health")

    assert response.status_code == 200
    assert response.json() == {"status": "healthy", "version": "1.0.0"}

# Продовження файлу tests/integration/test_health.py

@pytest.mark.integration
async def test_health_check_async(async_client):
    """Асинхронний тест ендпоінту /health за допомогою AsyncClient."""
    response = await async_client.get("/health")

    assert response.status_code == 200
    assert response.json()["status"] == "healthy"

import pytest
from sqlalchemy.ext.asyncio import create_async_engine, async_sessionmaker, AsyncSession
from app.database import Base, get_db
from app.main import app

# Використовуємо окрему тестову базу даних (можна PostgreSQL або SQLite в пам'яті для швидкості)
TEST_DATABASE_URL = "postgresql+asyncpg://postgres:postgres@localhost:5432/test_taskforge"

# Створюємо тестовий Engine
engine = create_async_engine(TEST_DATABASE_URL, echo=False)
TestingSessionLocal = async_sessionmaker(autocommit=False, autoflush=False, bind=engine, expire_on_commit=False)

@pytest.fixture(scope="session", autouse=True)
async def setup_test_db():
    """Фікстура, що створює схему БД перед тестами та видаляє її після."""
    async with engine.begin() as conn:
        # Створюємо всі таблиці
        await conn.run_sync(Base.metadata.create_all)

    yield

    async with engine.begin() as conn:
        # Видаляємо всі таблиці після завершення тестової сесії
        await conn.run_sync(Base.metadata.drop_all)

@pytest.fixture(scope="function")
async def db_session() -> AsyncSession:
    """Фікстура, яка створює сесію БД для кожного тесту та робить rollback наприкінці."""
    connection = await engine.connect()
    # Починаємо зовнішню транзакцію
    transaction = await connection.begin()

    # Створюємо сесію, прив'язану до цього з'єднання
    session = TestingSessionLocal(bind=connection)

    yield session

    # Закриваємо сесію та відкочуємо транзакцію
    await session.close()
    await transaction.rollback()
    await connection.close()

// Перевизначення у WebApplicationFactory
builder.ConfigureServices(services => {
    var descriptor = services.SingleOrDefault(d => d.ServiceType == typeof(DbContextOptions<AppDbContext>));
    services.Remove(descriptor);
    services.AddDbContext<AppDbContext>(options => options.UseInMemoryDatabase("TestDb"));
});

# Продовження tests/conftest.py

from httpx import AsyncClient

# Наш реальний провайдер сесії БД, який використовується в ендпоінтах
# Наприклад:
# async def get_db():
#     async with SessionLocal() as session:
#         yield session

@pytest.fixture(scope="function")
async def client(db_session: AsyncSession):
    """Фікстура клієнта, яка підміняє робочу БД на тестову для кожного запиту."""

    # Створюємо функцію-заглушку, яка повертатиме нашу тестову сесію
    async def _override_get_db():
        yield db_session

    # Записуємо перевизначення в словник FastAPI
    app.dependency_overrides[get_db] = _override_get_db

    async with AsyncClient(app=app, base_url="http://test") as ac:
        yield ac

    # ВАЖЛИВО: Очищуємо перевизначення після тесту, щоб інші тести не постраждали
    app.dependency_overrides.clear()

import pytest
from datetime import date

@pytest.mark.integration
async def test_create_task_endpoint(client):
    """Перевірка успішного створення завдання через POST ендпоінт."""
    payload = {
        "title": "Write unit tests",
        "description": "Cover all endpoints with pytest",
        "due_date": str(date.today()),
        "priority": 2
    }

    response = await client.post("/api/tasks", json=payload)

    assert response.status_code == 201
    data = response.json()
    assert data["id"] is not None
    assert data["title"] == payload["title"]
    assert data["priority"] == payload["priority"]

@pytest.mark.integration
async def test_create_task_validation_error(client):
    """Перевірка обробки невалідних даних при створенні завдання."""
    # Пріоритет поза межами дозволеного [1..5]
    payload = {
        "title": "Invalid task",
        "priority": 99
    }

    response = await client.post("/api/tasks", json=payload)

    assert response.status_code == 422  # Unprocessable Entity
    data = response.json()
    assert "detail" in data
    # Перевіряємо локацію помилки валідації
    assert data["detail"][0]["loc"] == ["body", "priority"]

var emailMock = new Mock<IEmailService>();
emailMock.Setup(x => x.SendEmailAsync(It.IsAny<string>(), It.IsAny<string>()))
         .ReturnsAsync(true);

import asyncio

class EmailService:
    async def send_notification(self, email: str, subject: str, body: str) -> bool:
        # Симуляція мережевого запиту до SendGrid
        await asyncio.sleep(2)
        print(f"Email sent to {email}")
        return True

from fastapi import FastAPI, Depends
from app.services.email import EmailService

app = FastAPI()
email_service = EmailService()

@app.post("/tasks/assign")
async def assign_task(email: str):
    # Якась логіка...
    success = await email_service.send_notification(
        email=email,
        subject="Нове завдання",
        body="Вам призначено нове завдання у TaskForge"
    )
    return {"status": "assigned", "notified": success}

import pytest

@pytest.mark.integration
async def test_assign_task_with_mocked_email(client, mocker):
    """Тест ендпоінту assign з мокуванням EmailService."""

    # 1. Замінюємо реальний метод send_notification на Mock-об'єкт
    # Шлях вказується відносно того, ДЕ цей об'єкт використовується під час виконання
    mock_send = mocker.patch(
        "app.main.email_service.send_notification",
        return_value=True  # Що має повернути метод при виклику
    )

    # 2. Виконуємо запит через тестовий клієнт
    response = await client.post("/tasks/assign?email=student@kostyl.dev")

    # 3. Перевіряємо відповідь API
    assert response.status_code == 200
    assert response.json() == {"status": "assigned", "notified": True}

    # 4. Перевіряємо, чи був викликаний наш mock і з якими аргументами
    mock_send.assert_called_once_with(
        email="student@kostyl.dev",
        subject="Нове завдання",
        body="Вам призначено нове завдання у TaskForge"
    )

import factory
from factory import Faker
from app.models.task import Task  # Ваша SQLAlchemy модель завдання
from tests.conftest import TestingSessionLocal  # Тестова сесія

class TaskFactory(factory.alchemy.SQLAlchemyModelFactory):
    class Meta:
        model = Task
        # Вказуємо тестову сесію для збереження об'єктів у БД
        sqlalchemy_session = None  # будемо динамічно передавати в сесії
        sqlalchemy_session_persistence = "commit"

    # Декларуємо поля та правила їх генерації
    id = factory.Sequence(lambda n: n + 1)

    # Використовуємо Faker для генерації реалістичних назв
    title = Faker("sentence", nb_words=4)
    description = Faker("paragraph", nb_sentences=3)
    priority = factory.Iterator([1, 2, 3, 4, 5])
    due_date = factory.LazyFunction(date.today)

# Додаємо в tests/conftest.py
from tests.factories import TaskFactory

@pytest.fixture
def task_factory(db_session):
    """Фікстура для створення завдань у тестовій БД."""
    # Зв'язуємо фабрику з поточною тестовою сесією
    TaskFactory._meta.sqlalchemy_session = db_session
    return TaskFactory

import pytest

@pytest.mark.integration
async def test_get_all_tasks(client, task_factory):
    """Тест отримання списку завдань."""
    # Створюємо 3 завдання в тестовій БД одним рядком
    task_factory.create_batch(3)

    response = await client.get("/api/todos")

    assert response.status_code == 200
    data = response.json()
    assert len(data) == 3
    # Перевіряємо, що унікальні назви згенерувалися
    assert data[0]["title"] != data[1]["title"]

# Продовження файлу tests/integration/test_tasks_query.py

@pytest.mark.integration
async def test_get_task_by_id(client, task_factory):
    """Тест отримання конкретного завдання за ID."""
    # Створюємо завдання з фіксованою назвою
    task = task_factory.create(title="Specific Task Title")

    response = await client.get(f"/api/todos/{task.id}")

    assert response.status_code == 200
    data = response.json()
    assert data["id"] == task.id
    assert data["title"] == "Specific Task Title"

# Додаємо в конфігурацію pytest в pyproject.toml
[tool.pytest.ini_options]
addopts = "-v -ra --strict-markers --cov=app --cov-fail-under=80 --cov-report=term-missing"

name: CI Pipeline

on:
    push:
        branches: [main, develop]
    pull_request:
        branches: [main]

jobs:
    lint-and-test:
        runs-on: ubuntu-latest

        # Піднімаємо тестову базу даних PostgreSQL за допомогою Docker Compose у сервісах GitHub Actions
        services:
            postgres:
                image: postgres:16
                env:
                    POSTGRES_DB: test_taskforge
                    POSTGRES_USER: postgres
                    POSTGRES_PASSWORD: postgres
                ports:
                    - 5432:5432
                # Перевірка готовності БД
                options: >-
                    --health-cmd pg_isready
                    --health-interval 10s
                    --health-timeout 5s
                    --health-retries 5

        steps:
            - name: Checkout repository
              uses: actions/checkout@v4

            - name: Set up Python
              uses: actions/setup-python@v5
              with:
                  python-version: '3.12'
                  cache: 'pip' # Кешування залежностей для прискорення CI

            - name: Install dependencies
              run: |
                  python -m pip install --upgrade pip
                  pip install ruff mypy pytest pytest-asyncio pytest-cov pytest-mock httpx faker factory-boy sqlalchemy asyncpg pydantic python-multipart

            - name: Run Ruff Linter
              run: ruff check app/ tests/

            - name: Run Ruff Formatter check
              run: ruff format --check app/ tests/

            - name: Run Mypy Type Checker
              run: mypy app/

            - name: Run Tests with Coverage
              env:
                  # Передаємо рядок підключення до тестової БД в оточення CI
                  TEST_DATABASE_URL: postgresql+asyncpg://postgres:postgres@localhost:5432/test_taskforge
              run: pytest

[project]
name = "taskforge-demo"
version = "1.0.0"
description = "A demo app to show FastAPI testing from A to Z"
requires-python = ">=3.11"
dependencies = [
    "fastapi>=0.110.0",
    "uvicorn>=0.28.0",
    "sqlalchemy>=2.0.28",
    "aiosqlite>=0.20.0",  # Асинхронний SQLite для тестів та локальної розробки
    "pydantic[email]>=2.6.4",
    "python-jose[cryptography]>=3.3.0",
    "bcrypt>=4.0.0",
    "python-multipart>=0.0.32",
]

[dependency-groups]
dev = [
    "pytest>=8.1.1",
    "pytest-asyncio>=0.23.6",
    "pytest-cov>=5.0.0",
    "pytest-mock>=3.14.0",
    "httpx>=0.27.0",
    "faker>=24.3.0",
    "factory-boy>=3.3.0",
]

[tool.pytest.ini_options]
testpaths = ["tests"]
python_files = "test_*.py"
python_classes = "Test*"
python_functions = "test_*"
pythonpath = ["."]
addopts = "-v -ra --cov=app --cov-report=term-missing"
asyncio_mode = "auto"
asyncio_default_fixture_loop_scope = "function"

from sqlalchemy import event
from sqlalchemy.engine import Engine
from sqlalchemy.ext.asyncio import create_async_engine, async_sessionmaker, AsyncSession
from sqlalchemy.orm import declarative_base

# Локальна SQLite база даних
DATABASE_URL = "sqlite+aiosqlite:///./taskforge.db"

engine = create_async_engine(DATABASE_URL, connect_args={"check_same_thread": False})
SessionLocal = async_sessionmaker(autocommit=False, autoflush=False, bind=engine, expire_on_commit=False)

Base = declarative_base()

# Активація підтримки Foreign Keys для SQLite
@event.listens_for(Engine, "connect")
def set_sqlite_pragma(dbapi_connection, connection_record):
    cursor = dbapi_connection.cursor()
    cursor.execute("PRAGMA foreign_keys=ON")
    cursor.close()

# Залежність (Dependency Injection) для ендпоінтів
async def get_db() -> AsyncSession:
    async with SessionLocal() as session:
        try:
            yield session
        finally:
            await session.close()

from sqlalchemy import Column, Integer, String, ForeignKey, Date
from sqlalchemy.orm import relationship
from app.database import Base

class User(Base):
    __tablename__ = "users"

    id = Column(Integer, primary_key=True, index=True)
    email = Column(String, unique=True, index=True, nullable=False)
    username = Column(String, unique=True, index=True, nullable=False)
    hashed_password = Column(String, nullable=False)

    tasks = relationship("Task", back_populates="owner", cascade="all, delete-orphan")

class Task(Base):
    __tablename__ = "tasks"

    id = Column(Integer, primary_key=True, index=True)
    title = Column(String, nullable=False)
    description = Column(String, nullable=True)
    priority = Column(Integer, default=1)
    due_date = Column(Date, nullable=True)
    owner_id = Column(Integer, ForeignKey("users.id", ondelete="CASCADE"), nullable=False)

    owner = relationship("User", back_populates="tasks")

from datetime import date
from typing import Optional
from pydantic import BaseModel, EmailStr, Field, field_validator

class UserCreate(BaseModel):
    email: EmailStr
    username: str = Field(..., min_length=3, max_length=50)
    password: str = Field(..., min_length=6)

class UserResponse(BaseModel):
    id: int
    email: EmailStr
    username: str

    class Config:
        from_attributes = True

class TokenResponse(BaseModel):
    access_token: str
    token_type: str

class TaskCreate(BaseModel):
    title: str = Field(..., min_length=3, max_length=100)
    description: Optional[str] = Field(None, max_length=1000)
    priority: int = Field(default=1, ge=1, le=5)
    due_date: Optional[date] = Field(None)

    @field_validator("due_date")
    @classmethod
    def prevent_past_dates(cls, value: Optional[date]) -> Optional[date]:
        if value and value < date.today():
            raise ValueError("Дедлайн не може бути в минулому")
        return value

class TaskResponse(BaseModel):
    id: int
    title: str
    description: Optional[str]
    priority: int
    due_date: Optional[date]
    owner_id: int

    class Config:
        from_attributes = True

import bcrypt
from datetime import datetime, timedelta
from typing import Optional
from jose import jwt

SECRET_KEY = "super-secret-key-for-demo-purposes-only"
ALGORITHM = "HS256"

def get_password_hash(password: str) -> str:
    pwd_bytes = password.encode("utf-8")[:72]
    salt = bcrypt.gensalt()
    return bcrypt.hashpw(pwd_bytes, salt).decode("utf-8")

def verify_password(plain_password: str, hashed_password: str) -> bool:
    pwd_bytes = plain_password.encode("utf-8")[:72]
    return bcrypt.checkpw(pwd_bytes, hashed_password.encode("utf-8"))

def create_access_token(data: dict, expires_delta: Optional[int] = None) -> str:
    to_encode = data.copy()
    expire = datetime.utcnow() + timedelta(minutes=expires_delta or 15)
    to_encode.update({"exp": expire})
    return jwt.encode(to_encode, SECRET_KEY, algorithm=ALGORITHM)

from fastapi import FastAPI, Depends, HTTPException, status
from fastapi.security import OAuth2PasswordBearer, OAuth2PasswordRequestForm
from jose import jwt, JWTError
from sqlalchemy.ext.asyncio import AsyncSession
from sqlalchemy import select
from app.database import get_db
from app import models, schemas, security

app = FastAPI(title="TaskForge Demo")
oauth2_scheme = OAuth2PasswordBearer(tokenUrl="/auth/login")

# Перевірка авторизації
async def get_current_user(token: str = Depends(oauth2_scheme), db: AsyncSession = Depends(get_db)) -> models.User:
    credentials_exception = HTTPException(
        status_code=status.HTTP_401_UNAUTHORIZED,
        detail="Could not validate credentials",
        headers={"WWW-Authenticate": "Bearer"},
    )
    try:
        payload = jwt.decode(token, security.SECRET_KEY, algorithms=[security.ALGORITHM])
        email: str = payload.get("sub")
        if email is None:
            raise credentials_exception
    except JWTError:
        raise credentials_exception
        
    result = await db.execute(select(models.User).where(models.User.email == email))
    user = result.scalars().first()
    if user is None:
        raise credentials_exception
    return user

@app.get("/health")
def health():
    return {"status": "healthy"}

@app.post("/auth/register", response_model=schemas.UserResponse, status_code=status.HTTP_201_CREATED)
async def register(user_data: schemas.UserCreate, db: AsyncSession = Depends(get_db)):
    # Перевірка чи пошта вільна
    existing = await db.execute(select(models.User).where(models.User.email == user_data.email))
    if existing.scalars().first():
        raise HTTPException(status_code=400, detail="Email already registered")
        
    hashed = security.get_password_hash(user_data.password)
    new_user = models.User(email=user_data.email, username=user_data.username, hashed_password=hashed)
    db.add(new_user)
    await db.commit()
    await db.refresh(new_user)
    return new_user

@app.post("/auth/login", response_model=schemas.TokenResponse)
async def login(form_data: OAuth2PasswordRequestForm = Depends(), db: AsyncSession = Depends(get_db)):
    result = await db.execute(select(models.User).where(models.User.email == form_data.username))
    user = result.scalars().first()
    if not user or not security.verify_password(form_data.password, user.hashed_password):
        raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="Incorrect email or password")
        
    token = security.create_access_token(data={"sub": user.email})
    return {"access_token": token, "token_type": "bearer"}

@app.post("/tasks", response_model=schemas.TaskResponse, status_code=status.HTTP_201_CREATED)
async def create_task(task_data: schemas.TaskCreate, current_user: models.User = Depends(get_current_user), db: AsyncSession = Depends(get_db)):
    new_task = models.Task(**task_data.model_dump(), owner_id=current_user.id)
    db.add(new_task)
    await db.commit()
    await db.refresh(new_task)
    return new_task

@app.get("/tasks", response_model=list[schemas.TaskResponse])
async def get_tasks(current_user: models.User = Depends(get_current_user), db: AsyncSession = Depends(get_db)):
    result = await db.execute(select(models.Task).where(models.Task.owner_id == current_user.id))
    return result.scalars().all()

import pytest
from httpx import AsyncClient
from sqlalchemy.ext.asyncio import create_async_engine, async_sessionmaker, AsyncSession
from app.database import Base, get_db
from app.main import app

# SQLite в пам'яті для ізоляції тестових прогонів
TEST_DATABASE_URL = "sqlite+aiosqlite:///:memory:"

engine = create_async_engine(TEST_DATABASE_URL, connect_args={"check_same_thread": False})
TestingSessionLocal = async_sessionmaker(autocommit=False, autoflush=False, bind=engine, expire_on_commit=False)

@pytest.fixture(scope="session", autouse=True)
async def setup_db():
    """Створює схему в пам'яті один раз для всієї сесії тестів."""
    async with engine.begin() as conn:
        await conn.run_sync(Base.metadata.create_all)
    yield
    async with engine.begin() as conn:
        await conn.run_sync(Base.metadata.drop_all)

@pytest.fixture(scope="function")
async def db_session() -> AsyncSession:
    """Створює окрему транзакцію для кожного окремого тесту та робить rollback."""
    connection = await engine.connect()
    transaction = await connection.begin()
    session = TestingSessionLocal(bind=connection)
    
    yield session
    
    await session.close()
    await transaction.rollback()
    await connection.close()

@pytest.fixture(scope="function")
async def client(db_session: AsyncSession) -> AsyncClient:
    """Створює тестовий клієнт із підміненою сесією БД."""
    async def _override_get_db():
        yield db_session

    app.dependency_overrides[get_db] = _override_get_db
    
    async with AsyncClient(app=app, base_url="http://test") as ac:
        yield ac
        
    app.dependency_overrides.clear()

import factory
from factory import Faker
from app import models

class UserFactory(factory.alchemy.SQLAlchemyModelFactory):
    class Meta:
        model = models.User
        sqlalchemy_session = None  # буде налаштовано у фікстурі
        sqlalchemy_session_persistence = "commit"

    id = factory.Sequence(lambda n: n + 1)
    email = Faker("email")
    username = Faker("user_name")
    hashed_password = "dummy_hashed_password"  # не принципово для базових тестів

class TaskFactory(factory.alchemy.SQLAlchemyModelFactory):
    class Meta:
        model = models.Task
        sqlalchemy_session = None
        sqlalchemy_session_persistence = "commit"

    id = factory.Sequence(lambda n: n + 1)
    title = Faker("sentence", nb_words=3)
    description = Faker("paragraph", nb_sentences=2)
    priority = factory.Iterator([1, 2, 3])
    # Зв'язуємо з UserFactory
    owner = factory.SubFactory(UserFactory)

# Додайте в кінець tests/conftest.py
from tests.factories import UserFactory, TaskFactory

@pytest.fixture
def user_factory(db_session):
    UserFactory._meta.sqlalchemy_session = db_session
    return UserFactory

@pytest.fixture
def task_factory(db_session):
    TaskFactory._meta.sqlalchemy_session = db_session
    return TaskFactory

import pytest

async def test_health_endpoint(client):
    """Швидка перевірка доступності нашого API."""
    response = await client.get("/health")
    assert response.status_code == 200
    assert response.json() == {"status": "healthy"}

async def test_register_user_success(client):
    """Тестування успішної реєстрації."""
    payload = {
        "email": "student@kostyl.dev",
        "username": "student_dev",
        "password": "SecretPassword123"
    }
    response = await client.post("/auth/register", json=payload)
    
    assert response.status_code == 201
    data = response.json()
    assert data["email"] == payload["email"]
    assert data["username"] == payload["username"]
    assert "id" in data

async def test_register_duplicate_email(client, user_factory):
    """Спроба реєстрації з існуючим email має викликати помилку 400."""
    # Створюємо користувача в базі даних через фабрику
    user_factory.create(email="duplicate@kostyl.dev")
    
    payload = {
        "email": "duplicate@kostyl.dev",
        "username": "other_user",
        "password": "Password1234"
    }
    response = await client.post("/auth/register", json=payload)
    
    assert response.status_code == 400
    assert response.json()["detail"] == "Email already registered"

import pytest
from app.security import create_access_token

@pytest.fixture
def auth_headers(user_factory):
    """Генерує заголовок Authorization для тестів, що потребують авторизації."""
    user = user_factory.create(email="auth_user@kostyl.dev")
    token = create_access_token(data={"sub": user.email})
    return {"Authorization": f"Bearer {token}"}

async def test_create_task_authorized(client, auth_headers):
    """Створення завдання авторизованим користувачем."""
    payload = {
        "title": "Build complete test suite",
        "description": "Ensure everything is covered",
        "priority": 5
    }
    response = await client.post("/tasks", json=payload, headers=auth_headers)
    
    assert response.status_code == 201
    data = response.json()
    assert data["title"] == payload["title"]
    assert data["priority"] == 5
    assert "id" in data

async def test_create_task_unauthorized(client):
    """Спроба створити завдання без авторизаційного токену."""
    payload = {"title": "Hack the planet"}
    response = await client.post("/tasks", json=payload)
    assert response.status_code == 401

async def test_get_only_user_tasks(client, user_factory, task_factory):
    """Користувач має бачити лише свої завдання."""
    user_1 = user_factory.create(email="user1@kostyl.dev")
    user_2 = user_factory.create(email="user2@kostyl.dev")
    
    # Створюємо завдання для різних користувачів
    task_factory.create_batch(2, owner=user_1)
    task_factory.create(owner=user_2)
    
    token = create_access_token(data={"sub": user_1.email})
    headers = {"Authorization": f"Bearer {token}"}
    
    response = await client.get("/tasks", headers=headers)
    
    assert response.status_code == 200
    tasks = response.json()
    # Користувач 1 має бачити лише свої 2 завдання
    assert len(tasks) == 2