diff --git a/server/tests/conftest.py b/server/tests/conftest.py index dc26478..3956645 100644 --- a/server/tests/conftest.py +++ b/server/tests/conftest.py @@ -5,7 +5,9 @@ import pytest from sqlalchemy import create_engine, text +from app.config import Settings from app.storage.db import Database +from app.storage.importer import import_file_repository from app.storage.models import Base TEST_DATABASE_URL = os.environ.get( @@ -39,3 +41,12 @@ finally: Base.metadata.drop_all(engine) engine.dispose() + + +@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 diff --git a/server/tests/test_db_changesets.py b/server/tests/test_db_changesets.py new file mode 100644 index 0000000..69860e1 --- /dev/null +++ b/server/tests/test_db_changesets.py @@ -0,0 +1,279 @@ +from __future__ import annotations + +import pytest +from fastapi.testclient import TestClient +from sqlalchemy import func, select + +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 InventoryItem, InventoryItemVersion +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_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 + + +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() diff --git a/server/tests/test_db_storage.py b/server/tests/test_db_storage.py index e47dcf9..8304c21 100644 --- a/server/tests/test_db_storage.py +++ b/server/tests/test_db_storage.py @@ -13,15 +13,6 @@ 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)