Newer
Older
gnexus-book / server / tests / test_db_storage.py
from __future__ import annotations

import pytest

from app.config import Settings
from app.docs_repository import DocsRepository
from app.inventory import InventoryRepository
from app.pending_changes import PendingChangeError, PendingChangeRepository, ProposedChangeRequest
from app.storage.db import Database
from app.storage.db_repositories import PostgresDocsRepository, PostgresInventoryRepository
from app.storage.factory import make_docs_repository, make_inventory_repository
from app.storage.importer import database_counts, import_file_repository
from app.storage.parity import compare_repositories


@pytest.fixture()
def imported(database: Database) -> tuple[Settings, Database]:
    settings = Settings(storage_backend="db", database_url=database.url)
    report = import_file_repository(settings, database, replace=True)
    assert report.documents > 0
    assert report.inventory_items > 0
    return settings, database


def test_read_parity_with_file_backend(imported: tuple[Settings, Database]) -> None:
    settings, database = imported
    result = compare_repositories(settings, database)

    assert result["ok"], result["differences"][:3]


def test_import_is_repeatable(imported: tuple[Settings, Database]) -> None:
    settings, database = imported
    before = database_counts(database)

    import_file_repository(settings, database, replace=True)

    assert database_counts(database) == before


def test_factory_selects_database_backend(imported: tuple[Settings, Database]) -> None:
    settings, _ = imported

    assert isinstance(make_docs_repository(settings), PostgresDocsRepository)
    assert isinstance(make_inventory_repository(settings), PostgresInventoryRepository)


def test_factory_defaults_to_file_backend() -> None:
    settings = Settings(storage_backend="file")

    assert isinstance(make_docs_repository(settings), DocsRepository)
    assert isinstance(make_inventory_repository(settings), InventoryRepository)


def test_search_matches_file_backend(imported: tuple[Settings, Database]) -> None:
    settings, database = imported
    file_repo = DocsRepository(Settings(repo_root=settings.repo_root, storage_backend="file"))
    db_repo = PostgresDocsRepository(database)

    assert file_repo.search("GitBucket") == db_repo.search("GitBucket")
    assert file_repo.search("") == db_repo.search("")


def test_inventory_item_lookup(imported: tuple[Settings, Database]) -> None:
    _, database = imported
    repo = PostgresInventoryRepository(database)

    assert repo.read_item("services", "gitbucket")["name"] == "GitBucket"

    with pytest.raises(Exception, match="Inventory item not found"):
        repo.read_item("services", "does-not-exist")


def test_document_read_returns_expected_shape(imported: tuple[Settings, Database]) -> None:
    _, database = imported
    repo = PostgresDocsRepository(database)
    document = repo.read_doc("10-systems/applications/gitbucket.md")

    assert set(document) == {"path", "frontmatter", "body", "raw"}
    assert "GitBucket" in document["body"]
    assert document["frontmatter"]["owner"] == "gmikcon"


def test_file_write_path_is_blocked_in_database_mode(imported: tuple[Settings, Database]) -> None:
    settings, _ = imported
    repo = PendingChangeRepository(settings)

    with pytest.raises(PendingChangeError, match="database mode"):
        repo.create(
            ProposedChangeRequest(
                kind="doc",
                target="10-systems/example.md",
                summary="Example",
                payload={"content": "# Example"},
            )
        )