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

import threading
import uuid

import pytest
from fastapi.testclient import TestClient
from sqlalchemy import func, select

from app.auth.actor import Actor
from app.config import Settings, get_settings
from app.main import app
from app.pending_changes import PendingChangeError, ProposedChangeRequest
from app.storage.db import Database
from app.storage.db_repositories import PostgresDocsRepository, PostgresInventoryRepository
from app.storage.documents import (
    DocumentError,
    diff_document_versions,
    get_document_version,
    list_document_versions,
    restore_document_version,
)
from app.storage.models import (
    AuditLog,
    Changeset,
    DocVersion,
    Document,
    InventoryItem,
    InventoryItemVersion,
    User,
)
from app.storage.pending_changes_db import PostgresPendingChangeRepository
from app.storage.validation import validate_database


def _document(title: str, body: str = "Body.\n") -> str:
    return (
        "---\n"
        "owner: gmikcon\n"
        "status: active\n"
        "last_reviewed: 2026-11-19\n"
        "review_interval: 90d\n"
        "confidence: high\n"
        "source_of_truth: test\n"
        "---\n\n"
        f"# {title}\n\n"
        f"{body}"
    )


@pytest.fixture()
def repository(imported: tuple[Settings, Database]) -> PostgresPendingChangeRepository:
    settings, database = imported
    return PostgresPendingChangeRepository(database, settings, via="api")


def test_create_draft_change(repository: PostgresPendingChangeRepository) -> None:
    change = repository.create(
        ProposedChangeRequest(
            kind="doc",
            target="10-systems/example.md",
            summary="Add example",
            reason="test",
            payload={"content": _document("Example")},
        )
    )

    assert change["status"] == "draft"
    assert change["kind"] == "doc"
    assert repository.get(change["id"])["target"] == "10-systems/example.md"
    assert any(item["id"] == change["id"] for item in repository.list())


def test_delete_draft_change(
    repository: PostgresPendingChangeRepository,
) -> None:
    change = repository.create(
        ProposedChangeRequest(
            kind="doc",
            target="10-systems/deletable.md",
            summary="Deletable draft",
            payload={"content": _document("Deletable")},
        )
    )

    deleted = repository.delete(change["id"])

    assert deleted == {"id": change["id"], "status": "deleted"}
    with pytest.raises(PendingChangeError, match="not found"):
        repository.get(change["id"])


def test_delete_applied_change_is_rejected(
    repository: PostgresPendingChangeRepository,
) -> None:
    change = repository.create(
        ProposedChangeRequest(
            kind="doc",
            target="10-systems/applied.md",
            summary="Applied draft",
            payload={"content": _document("Applied")},
        )
    )
    repository.apply(change["id"])

    with pytest.raises(PendingChangeError, match="Only draft changes"):
        repository.delete(change["id"])


def test_apply_document_change_creates_version(
    imported: tuple[Settings, Database], repository: PostgresPendingChangeRepository
) -> None:
    settings, database = imported
    change = repository.create(
        ProposedChangeRequest(
            kind="doc",
            target="10-systems/example.md",
            summary="Add example",
            payload={"content": _document("Example")},
        )
    )

    applied = repository.apply(change["id"])

    assert applied["status"] == "applied"
    assert applied["applied_at"]
    assert applied["validation"]["status"] == "ok"

    document = PostgresDocsRepository(database).read_doc("10-systems/example.md")
    assert "# Example" in document["body"]
    assert document["frontmatter"]["owner"] == "gmikcon"

    versions = list_document_versions(database, "10-systems/example.md")
    assert [version["version_no"] for version in versions] == [1]
    assert versions[0]["changeset_id"] == change["id"]


def test_update_creates_second_version_and_diff(
    imported: tuple[Settings, Database], repository: PostgresPendingChangeRepository
) -> None:
    _, database = imported
    target = "10-systems/applications/gitbucket.md"

    change = repository.create(
        ProposedChangeRequest(
            kind="doc",
            target=target,
            summary="Update GitBucket",
            payload={"content": _document("GitBucket", "Version two marker.\n")},
        )
    )
    repository.apply(change["id"])

    versions = list_document_versions(database, target)
    assert [version["version_no"] for version in versions] == [1, 2]

    diff = diff_document_versions(database, target)
    assert diff["from_version"] == 1
    assert diff["to_version"] == 2
    assert "+Version two marker." in diff["diff"]

    latest = PostgresDocsRepository(database).read_doc(target)
    assert "Version two marker." in latest["body"]


def test_validation_failure_rolls_back(
    imported: tuple[Settings, Database], repository: PostgresPendingChangeRepository
) -> None:
    _, database = imported
    change = repository.create(
        ProposedChangeRequest(
            kind="doc",
            target="10-systems/bad.md",
            summary="Invalid document",
            payload={"content": "# Missing frontmatter\n"},
        )
    )

    with pytest.raises(PendingChangeError, match="validation"):
        repository.apply(change["id"])

    assert repository.get(change["id"])["status"] == "draft"
    paths = {doc["path"] for doc in PostgresDocsRepository(database).list_docs()}
    assert "10-systems/bad.md" not in paths
    with pytest.raises(DocumentError):
        list_document_versions(database, "10-systems/bad.md")


def test_secret_is_rejected_by_database_validation(
    imported: tuple[Settings, Database], repository: PostgresPendingChangeRepository
) -> None:
    _, database = imported
    change = repository.create(
        ProposedChangeRequest(
            kind="doc",
            target="10-systems/unsafe.md",
            summary="Unsafe document",
            payload={"content": _document("Unsafe", "api_key: raw-value\n")},
        )
    )

    with pytest.raises(PendingChangeError, match="possible-secret"):
        repository.apply(change["id"])

    paths = {doc["path"] for doc in PostgresDocsRepository(database).list_docs()}
    assert "10-systems/unsafe.md" not in paths


def test_restore_creates_new_version(
    imported: tuple[Settings, Database], repository: PostgresPendingChangeRepository
) -> None:
    settings, database = imported
    target = "10-systems/applications/gitbucket.md"
    original_raw = get_document_version(database, target, 1)["raw"]

    change = repository.create(
        ProposedChangeRequest(
            kind="doc",
            target=target,
            summary="Update GitBucket",
            payload={"content": _document("GitBucket", "Temporary marker.\n")},
        )
    )
    repository.apply(change["id"])

    restored = restore_document_version(database, settings, target, 1, summary="Restore GitBucket")

    assert restored["status"] == "applied"
    versions = list_document_versions(database, target)
    assert [version["version_no"] for version in versions] == [1, 2, 3]
    assert get_document_version(database, target, 3)["raw"] == original_raw


def test_inventory_item_update_creates_version(
    imported: tuple[Settings, Database], repository: PostgresPendingChangeRepository
) -> None:
    _, database = imported
    change = repository.create(
        ProposedChangeRequest(
            kind="inventory-item",
            target="services/gitbucket",
            summary="Update service criticality",
            payload={"mode": "update", "patch": {"criticality": "medium"}},
        )
    )

    repository.apply(change["id"])

    service = PostgresInventoryRepository(database).read_item("services", "gitbucket")
    assert service["criticality"] == "medium"

    with database.session() as session:
        count = session.scalar(
            select(func.count())
            .select_from(InventoryItemVersion)
            .join(InventoryItem, InventoryItem.id == InventoryItemVersion.inventory_item_id)
            .where(
                InventoryItem.type == "services",
                InventoryItem.item_id == "gitbucket",
            )
        )
    assert count == 2


def test_invalid_inventory_patch_rolls_back(
    imported: tuple[Settings, Database], repository: PostgresPendingChangeRepository
) -> None:
    _, database = imported
    before = PostgresInventoryRepository(database).read_item("services", "gitbucket")

    change = repository.create(
        ProposedChangeRequest(
            kind="inventory-item",
            target="services/gitbucket",
            summary="Invalid criticality",
            payload={"mode": "update", "patch": {"criticality": "extreme"}},
        )
    )

    with pytest.raises(PendingChangeError, match="json-schema-validation-error"):
        repository.apply(change["id"])

    assert PostgresInventoryRepository(database).read_item("services", "gitbucket") == before


@pytest.mark.parametrize("target", ["README.md", "server/leak.md"])
def test_secret_scan_covers_all_document_paths(
    imported: tuple[Settings, Database],
    repository: PostgresPendingChangeRepository,
    target: str,
) -> None:
    change = repository.create(
        ProposedChangeRequest(
            kind="doc",
            target=target,
            summary="Leak a secret",
            payload={"content": "password: hunter2\n"},
        )
    )

    with pytest.raises(PendingChangeError, match="possible-secret"):
        repository.apply(change["id"])


def test_actor_user_id_is_recorded(
    imported: tuple[Settings, Database],
    repository: PostgresPendingChangeRepository,
) -> None:
    settings, database = imported
    with database.session() as session:
        with session.begin():
            user = User(
                sub="actor-user",
                email="actor@example.test",
                display_name="Actor User",
                profile={},
            )
            session.add(user)
            session.flush()
            user_id = user.id

    actor = Actor(
        kind="user", name="Actor User", via="ui", user_id=user_id
    )
    change = repository.create(
        ProposedChangeRequest(
            kind="doc",
            target="10-systems/actor.md",
            summary="Add actor document",
            payload={"content": _document("Actor")},
        ),
        actor=actor,
    )
    repository.apply(change["id"], actor=actor)

    with database.session() as session:
        changeset = session.get(Changeset, uuid.UUID(change["id"]))
        assert changeset is not None
        assert changeset.author_user_id == user_id

        audits = session.scalars(
            select(AuditLog)
            .where(AuditLog.entity_id == change["id"])
            .order_by(AuditLog.created_at)
        ).all()
        assert audits
        assert all(audit.actor_user_id == user_id for audit in audits)

        version = session.scalars(
            select(DocVersion)
            .join(Document, Document.id == DocVersion.document_id)
            .where(Document.slug == "10-systems/actor.md")
            .order_by(DocVersion.version_no.desc())
        ).first()
        assert version is not None
        assert version.author_user_id == user_id


def test_concurrent_apply_is_serialized(
    imported: tuple[Settings, Database],
    repository: PostgresPendingChangeRepository,
) -> None:
    settings, database = imported
    change = repository.create(
        ProposedChangeRequest(
            kind="doc",
            target="10-systems/concurrent.md",
            summary="Add concurrent document",
            payload={"content": _document("Concurrent")},
        )
    )
    barrier = threading.Barrier(2)
    results: list[str] = []

    def run() -> None:
        worker = PostgresPendingChangeRepository(database, settings, via="api")
        barrier.wait()
        try:
            worker.apply(change["id"])
            results.append("ok")
        except Exception as exc:  # noqa: BLE001 - asserted below
            results.append(str(exc))

    threads = [threading.Thread(target=run) for _ in range(2)]
    for thread in threads:
        thread.start()
    for thread in threads:
        thread.join(timeout=10)
        assert not thread.is_alive()

    assert results.count("ok") == 1
    assert any("Only pending changes can be applied" in result for result in results)
    assert len(list_document_versions(database, "10-systems/concurrent.md")) == 1


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

    assert validate_database(database)["status"] == "ok"


def test_api_changeset_flow_in_database_mode(imported: tuple[Settings, Database]) -> None:
    settings, _ = imported
    app.dependency_overrides[get_settings] = lambda: settings
    client = TestClient(app)
    target = "10-systems/api-example.md"

    try:
        created = client.post(
            "/changes",
            json={
                "kind": "doc",
                "target": target,
                "summary": "Add API example",
                "payload": {"content": _document("API Example")},
            },
        )
        assert created.status_code == 200, created.text
        change = created.json()

        applied = client.post(f"/changes/{change['id']}/apply")
        assert applied.status_code == 200, applied.text
        assert applied.json()["status"] == "applied"

        document = client.get("/docs/read", params={"path": target})
        assert document.status_code == 200
        assert "# API Example" in document.json()["body"]

        history = client.get(f"/documents/{target}/history")
        assert history.status_code == 200
        assert len(history.json()) == 1

        validation = client.get("/validate")
        assert validation.status_code == 200
        assert validation.json()["status"] == "ok"
    finally:
        app.dependency_overrides.clear()