test: добавить интеграционные тесты для репозиториев и сервисов

RomanVetrov · RomanVetrov · commit a32fc24d86de · 2026-03-09T21:02:40.000+03:00
- Добавлены фикстуры интеграционного слоя для БД

- Проверены user, task и tag репозитории

- Проверены auth и связка task-tag на уровне сервисов
diff --git a/tests/integration/conftest.py b/tests/integration/conftest.py
@@ -0,0 +1,79 @@
+from __future__ import annotations
+
+import os
+from collections.abc import AsyncIterator
+from pathlib import Path
+from uuid import uuid4
+
+import pytest
+import pytest_asyncio
+from sqlalchemy import text
+from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker, create_async_engine
+
+from app.config import settings
+from app.database import Base
+
+_DUMMY_DB_URL = "postgresql+asyncpg://test_user:test_password@localhost:5432/test_db"
+
+
+def _integration_db_url() -> str:
+    explicit = os.getenv("INTEGRATION_DATABASE_URL")
+    if explicit:
+        return explicit
+
+    env_db_url = os.getenv("DATABASE_URL")
+    if env_db_url and env_db_url != _DUMMY_DB_URL:
+        return env_db_url
+
+    env_file = Path(__file__).resolve().parents[2] / ".env"
+    if env_file.exists():
+        for line in env_file.read_text(encoding="utf-8").splitlines():
+            if line.startswith("DATABASE_URL="):
+                return line.split("=", 1)[1].strip()
+
+    return settings.DATABASE_URL
+
+
+@pytest_asyncio.fixture
+async def db_session() -> AsyncIterator[AsyncSession]:
+    # Важно: импорт моделей регистрирует таблицы в Base.metadata.
+    import app.models.tag  # noqa: F401
+    import app.models.task  # noqa: F401
+    import app.models.user  # noqa: F401
+
+    db_url = _integration_db_url()
+    schema = f"test_{uuid4().hex}"
+    admin_engine = create_async_engine(db_url, echo=False)
+    test_engine = None
+    schema_created = False
+
+    try:
+        async with admin_engine.begin() as conn:
+            await conn.execute(text(f'CREATE SCHEMA "{schema}"'))
+        schema_created = True
+
+        test_engine = create_async_engine(
+            db_url,
+            echo=False,
+            connect_args={"server_settings": {"search_path": schema}},
+        )
+        async with test_engine.begin() as conn:
+            await conn.run_sync(Base.metadata.create_all)
+        session_factory = async_sessionmaker(test_engine, expire_on_commit=False)
+
+        async with session_factory() as session:
+            yield session
+    except Exception as exc:
+        pytest.skip(f"Интеграционная БД недоступна: {exc}")
+    finally:
+        if test_engine is not None:
+            await test_engine.dispose()
+        if schema_created:
+            try:
+                async with admin_engine.begin() as conn:
+                    await conn.execute(
+                        text(f'DROP SCHEMA IF EXISTS "{schema}" CASCADE')
+                    )
+            except Exception:
+                pass
+        await admin_engine.dispose()
diff --git a/tests/integration/repositories/test_tag_repo_integration.py b/tests/integration/repositories/test_tag_repo_integration.py
@@ -0,0 +1,81 @@
+from __future__ import annotations
+
+from uuid import uuid4
+
+import pytest
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.models.tag import task_tags
+from app.repositories import tag_repo, task_repo, user_repo
+
+pytestmark = pytest.mark.integration
+
+
+@pytest.mark.asyncio
+async def test_tag_repo_create_update_delete_cycle(db_session: AsyncSession) -> None:
+    """Проверяет CRUD-цикл тега через репозиторий."""
+    tag = await tag_repo.create_tag(
+        db_session,
+        name=f"tag-{uuid4().hex[:6]}",
+        color="#22AAFF",
+    )
+    assert tag.id is not None
+
+    loaded = await tag_repo.get_tag_by_id(db_session, tag.id)
+    assert loaded is not None
+    assert loaded.color == "#22AAFF"
+
+    updated = await tag_repo.update_tag(db_session, loaded, name="renamed-tag")
+    assert updated.name == "renamed-tag"
+
+    deleted_id = await tag_repo.delete_tag(db_session, updated)
+    assert deleted_id == tag.id
+    assert await tag_repo.get_tag_by_id(db_session, tag.id) is None
+
+
+@pytest.mark.asyncio
+async def test_list_tags_returns_sorted_by_name(db_session: AsyncSession) -> None:
+    """Проверяет сортировку list_tags по имени по возрастанию."""
+    await tag_repo.create_tag(db_session, name="zeta", color="#000001")
+    await tag_repo.create_tag(db_session, name="alpha", color="#000002")
+    await tag_repo.create_tag(db_session, name="beta", color="#000003")
+
+    tags = await tag_repo.list_tags(db_session)
+    names = [tag.name for tag in tags]
+
+    assert names == ["alpha", "beta", "zeta"]
+
+
+@pytest.mark.asyncio
+async def test_attach_detach_tag_idempotence(db_session: AsyncSession) -> None:
+    """Проверяет идемпотентность attach/detach связи task-tag на уровне репозитория."""
+    user = await user_repo.create_user(
+        db_session,
+        email=f"tag-owner-{uuid4().hex[:8]}@example.com",
+        hashed_password="hashed",
+    )
+    task = await task_repo.create_task(db_session, user, title="Task for tag")
+    tag = await tag_repo.create_tag(db_session, name="idempotent", color="#FF0000")
+
+    await tag_repo.attach_tag_to_task(db_session, task, tag)
+    await tag_repo.attach_tag_to_task(db_session, task, tag)
+
+    rows = await db_session.execute(
+        select(task_tags.c.task_id, task_tags.c.tag_id).where(
+            task_tags.c.task_id == task.id,
+            task_tags.c.tag_id == tag.id,
+        )
+    )
+    assert len(rows.all()) == 1
+
+    await tag_repo.detach_tag_from_task(db_session, task, tag)
+    await tag_repo.detach_tag_from_task(db_session, task, tag)
+
+    rows_after = await db_session.execute(
+        select(task_tags.c.task_id, task_tags.c.tag_id).where(
+            task_tags.c.task_id == task.id,
+            task_tags.c.tag_id == tag.id,
+        )
+    )
+    assert rows_after.first() is None
diff --git a/tests/integration/repositories/test_task_repo_integration.py b/tests/integration/repositories/test_task_repo_integration.py
@@ -0,0 +1,71 @@
+from __future__ import annotations
+
+from uuid import uuid4
+
+import pytest
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.models.task import StatusEnum
+from app.repositories import task_repo, user_repo
+
+pytestmark = pytest.mark.integration
+
+
+@pytest.mark.asyncio
+async def test_task_repo_crud_cycle(db_session: AsyncSession) -> None:
+    """Проверяет полный CRUD-цикл задачи через репозиторий."""
+    user = await user_repo.create_user(
+        db_session,
+        email=f"task-owner-{uuid4().hex[:8]}@example.com",
+        hashed_password="hashed",
+    )
+
+    created = await task_repo.create_task(
+        db_session,
+        user,
+        title="Repo task",
+        description="created by repo test",
+    )
+    assert created.user_id == user.id
+
+    loaded = await task_repo.get_task_by_id(db_session, created.id)
+    assert loaded is not None
+    assert loaded.title == "Repo task"
+
+    updated = await task_repo.update_task(
+        db_session,
+        loaded,
+        title="Updated by repo",
+        status=StatusEnum.done,
+    )
+    assert updated.title == "Updated by repo"
+    assert updated.status == StatusEnum.done
+
+    deleted_id = await task_repo.delete_task(db_session, updated)
+    assert deleted_id == created.id
+    assert await task_repo.get_task_by_id(db_session, created.id) is None
+
+
+@pytest.mark.asyncio
+async def test_get_tasks_by_user_filters_foreign_tasks(
+    db_session: AsyncSession,
+) -> None:
+    """Проверяет, что get_tasks_by_user возвращает только задачи указанного пользователя."""
+    user_a = await user_repo.create_user(
+        db_session,
+        email=f"user-a-{uuid4().hex[:8]}@example.com",
+        hashed_password="hash-a",
+    )
+    user_b = await user_repo.create_user(
+        db_session,
+        email=f"user-b-{uuid4().hex[:8]}@example.com",
+        hashed_password="hash-b",
+    )
+    await task_repo.create_task(db_session, user_a, title="A1")
+    await task_repo.create_task(db_session, user_a, title="A2")
+    await task_repo.create_task(db_session, user_b, title="B1")
+
+    tasks_a = await task_repo.get_tasks_by_user(db_session, user_a)
+    titles = sorted(task.title for task in tasks_a)
+
+    assert titles == ["A1", "A2"]
diff --git a/tests/integration/repositories/test_user_repo_integration.py b/tests/integration/repositories/test_user_repo_integration.py
@@ -0,0 +1,58 @@
+from __future__ import annotations
+
+from uuid import uuid4
+
+import pytest
+from sqlalchemy.exc import IntegrityError
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.repositories import user_repo
+
+pytestmark = pytest.mark.integration
+
+
+@pytest.mark.asyncio
+async def test_create_and_get_user_by_email(db_session: AsyncSession) -> None:
+    """Проверяет создание пользователя в repo и последующую загрузку по email."""
+    email = f"user-{uuid4().hex[:8]}@example.com"
+    created = await user_repo.create_user(
+        db_session,
+        email=email,
+        hashed_password="hashed-password",
+    )
+
+    loaded = await user_repo.get_user_by_email(db_session, email)
+
+    assert loaded is not None
+    assert loaded.id == created.id
+    assert loaded.email == email
+
+
+@pytest.mark.asyncio
+async def test_get_user_by_id_returns_none_for_unknown_id(
+    db_session: AsyncSession,
+) -> None:
+    """Проверяет, что repo возвращает None для несуществующего user_id."""
+    loaded = await user_repo.get_user_by_id(db_session, uuid4())
+
+    assert loaded is None
+
+
+@pytest.mark.asyncio
+async def test_create_user_enforces_unique_email(db_session: AsyncSession) -> None:
+    """Проверяет уникальность email на уровне БД при повторном create_user."""
+    email = f"user-{uuid4().hex[:8]}@example.com"
+    await user_repo.create_user(
+        db_session,
+        email=email,
+        hashed_password="hash-1",
+    )
+
+    with pytest.raises(IntegrityError):
+        await user_repo.create_user(
+            db_session,
+            email=email,
+            hashed_password="hash-2",
+        )
+
+    await db_session.rollback()
diff --git a/tests/integration/services/test_auth_service_integration.py b/tests/integration/services/test_auth_service_integration.py
diff --git a/tests/integration/services/test_task_tag_services_integration.py b/tests/integration/services/test_task_tag_services_integration.py
