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.freshness import build_freshness_report
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.freshness import build_freshness_report_db
from app.storage.importer import database_counts, import_file_repository
from app.storage.parity import compare_repositories


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_freshness_matches_file_backend(imported: tuple[Settings, Database]) -> None:
    settings, database = imported
    file_report = build_freshness_report(
        Settings(repo_root=settings.repo_root, storage_backend="file")
    )
    db_report = build_freshness_report_db(database)

    def key(issue: dict[str, str]) -> tuple[str, str, str]:
        return (issue["path"], issue["code"], issue["message"])

    assert db_report["document_count"] == file_report["document_count"]
    assert sorted(map(key, db_report["issues"])) == sorted(map(key, file_report["issues"]))


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"},
            )
        )