Initial commit

backend/tests/integration/conftest.py

@@ -0,0 +1,157 @@
+import json
+from pathlib import Path
+from httpx import AsyncClient
+import pytest
+
+from collections.abc import AsyncGenerator
+from typing import Any
+
+from sqlalchemy.ext.asyncio import (
+    AsyncSession,
+    AsyncEngine,
+    async_sessionmaker,
+)
+from advanced_alchemy.base import UUIDAuditBase
+from chitai.database import models as m
+from chitai import services
+from chitai.database.config import config
+
+
+@pytest.fixture(autouse=True)
+def _patch_db(
+    engine: AsyncEngine,
+    sessionmaker: async_sessionmaker[AsyncSession],
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setattr(config, "session_maker", sessionmaker)
+    monkeypatch.setattr(config, "engine_instance", engine)
+
+
+@pytest.fixture(autouse=True)
+async def _seed_db(
+    engine: AsyncEngine,
+    sessionmaker: async_sessionmaker[AsyncSession],
+    raw_users: list[m.User | dict[str, Any]],
+    raw_libraries: list[m.Library | dict[str, Any]],
+) -> AsyncGenerator[None, None]:
+    """Populate test database with.
+
+    Args:
+        engine: The SQLAlchemy engine instance.
+        sessionmaker: The SQLAlchemy sessionmaker factory.
+        raw_users: Test users to add to the database
+        raw_teams: Test teams to add to the database
+
+    """
+
+    metadata = UUIDAuditBase.registry.metadata
+    async with engine.begin() as conn:
+        await conn.run_sync(metadata.drop_all)
+        await conn.run_sync(metadata.create_all)
+
+    async with services.UserService.new(sessionmaker()) as users_service:
+        await users_service.create_many(raw_users, auto_commit=True)
+
+    async with services.LibraryService.new(sessionmaker()) as library_service:
+        await library_service.create_many(raw_libraries, auto_commit=True)
+
+    yield
+
+
+@pytest.fixture
+async def populated_authenticated_client(
+    authenticated_client: AsyncClient, books_to_upload: list[tuple[Path, dict]]
+) -> AsyncClient:
+    # Upload books
+    for path, data in books_to_upload:
+        await upload_book_via_api(authenticated_client, data, path)
+
+    await create_bookshelf(
+        authenticated_client, {"title": "Favourites", "library_id": 1}
+    )
+
+    await add_books_to_bookshelf(authenticated_client, 1, [1, 2])
+
+    return authenticated_client
+
+
+@pytest.fixture
+def books_to_upload() -> list[tuple[Path, dict]]:
+    return [
+        (
+            Path(
+                "tests/data_files/The Adventures of Sherlock Holmes - Arthur Conan Doyle.epub"
+            ),
+            {
+                "library_id": "1",
+                "title": "The Adventures of Sherlock Holmes",
+                "description": "Some description...",
+                "authors": "Arthur Conan Doyle",
+                "publisher": "Some Publisher",
+                "tags": "Mystery",
+                "edition": "2",
+                "language": "en",
+                "pages": "300",
+                "series": "Sherlock Holmes",
+                "series_position": "1",
+                "identifiers": json.dumps({"isbn-10": "1234567890"}),
+            },
+        ),
+        (
+            Path("tests/data_files/Frankenstein - Mary Shelley.epub"),
+            {
+                "library_id": "1",
+                "title": "Frankenstein",
+                "description": "Some description...",
+                "authors": "Mary Shelley",
+                "tags": "Mystery",
+                "edition": "1",
+                "language": "en",
+                "pages": "250",
+            },
+        ),
+        (
+            Path("tests/data_files/A Tale of Two Cities - Charles Dickens.epub"),
+            {
+                "library_id": "1",
+                "title": "A Tale of Two Cities",
+                "description": "Some description...",
+                "authors": "Charles Dickens",
+                "tags": "Classic",
+                "edition": "1",
+                "language": "en",
+                "pages": "500",
+            },
+        ),
+    ]
+
+
+async def upload_book_via_api(
+    client: AsyncClient, book_data: dict, book_file_path: Path
+) -> None:
+    with book_file_path.open("rb") as file:
+        files = {"files": file}
+
+        response = await client.post("/books?library_id=1", data=book_data, files=files)
+
+        assert response.status_code == 201
+
+
+async def create_bookshelf(client: AsyncClient, shelf_data: dict) -> None:
+    response = await client.post("/shelves", json=shelf_data)
+
+    assert response.status_code == 201
+
+
+async def add_books_to_bookshelf(
+    client: AsyncClient, shelf_id: int, book_ids: list[int]
+) -> None:
+    query_params = ""
+    for id in book_ids:
+        query_params += f"book_ids={id}&"
+
+    response = await client.post(
+        f"/shelves/{shelf_id}/books", params={"book_ids": book_ids}
+    )
+
+    assert response.status_code == 201