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_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()