Initial curated RAGcore source from c16667f0c9397e2bfc8dd0255b114fba23c8d05e

tests/integration/publication/test_publication.py

@@ -0,0 +1,130 @@
+"""PostgreSQL integration tests for atomic document publication."""
+
+from __future__ import annotations
+
+from uuid import uuid4
+
+import pytest
+import pytest_asyncio
+from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker
+
+from ragcore.application.documents import (
+    ArtifactRecord,
+    ChunkRecord,
+    DocumentPublicationService,
+    DocumentRecord,
+    DocumentVersionRecord,
+    DocumentVersionState,
+)
+from ragcore.application.sources import implicit_source_record
+from ragcore.config import Settings
+from ragcore.infrastructure.database import (
+    create_database_engine,
+    create_session_factory,
+)
+from ragcore.infrastructure.database.content import PostgresDocumentRepository
+from ragcore.infrastructure.database.sources import PostgresSourceRegistry
+
+
+@pytest_asyncio.fixture
+async def publication_context() -> tuple[
+    PostgresDocumentRepository, async_sessionmaker[AsyncSession]
+]:
+    engine = create_database_engine(Settings(env="test"))
+    factory = create_session_factory(engine)
+    try:
+        yield PostgresDocumentRepository(factory), factory
+    finally:
+        await engine.dispose()
+
+
+async def _register_source(factory, document) -> None:  # type: ignore[no-untyped-def]
+    """The content schema requires a registry row for every document's source."""
+
+    await PostgresSourceRegistry(factory).ensure_source(
+        implicit_source_record(
+            source_id=document.source_id,
+            workspace_id=document.workspace_id,
+            space_id=document.space_id,
+        )
+    )
+
+
+def version(document_id, state: DocumentVersionState, *, fingerprint: str) -> DocumentVersionRecord:
+    return DocumentVersionRecord(
+        id=uuid4(),
+        document_id=document_id,
+        source_fingerprint=fingerprint,
+        content_hash=fingerprint,
+        parser_version="parser-v1",
+        chunk_profile_version="prose-v1",
+        state=state,
+    )
+
+
+@pytest.mark.integration
+async def test_publication_supersedes_previous_and_is_idempotent(
+    publication_context: tuple[PostgresDocumentRepository, async_sessionmaker[AsyncSession]],
+) -> None:
+    repository, factory = publication_context
+    document = DocumentRecord(uuid4(), uuid4(), uuid4(), "source-1", f"doc-{uuid4()}", "Runbook")
+    await _register_source(factory, document)
+    await repository.create_document(document)
+    first = version(document.id, DocumentVersionState.VALIDATED, fingerprint="1" * 64)
+    second = version(document.id, DocumentVersionState.VALIDATED, fingerprint="2" * 64)
+    await repository.create_version(first)
+    await repository.create_version(second)
+    service = DocumentPublicationService(repository)
+    artifact = ArtifactRecord(uuid4(), second.id, "canonical", "2" * 64, "parsed/key", 10)
+    chunk = ChunkRecord(uuid4(), second.id, "/blocks/0000", "3" * 64, "prose-v1", "safe", 1)
+
+    await service.publish_validated(first.id, artifacts=(), chunks=())
+    await service.publish_validated(second.id, artifacts=(artifact,), chunks=(chunk,))
+    await service.publish_validated(second.id, artifacts=(artifact,), chunks=(chunk,))
+
+    assert (await repository.list_searchable_versions(document.id)) == (
+        await repository.get_version(second.id),
+    )
+    assert (await repository.get_version(first.id)).state is DocumentVersionState.SUPERSEDED
+
+
+@pytest.mark.integration
+async def test_failed_version_does_not_replace_previous_active_version(
+    publication_context: tuple[PostgresDocumentRepository, async_sessionmaker[AsyncSession]],
+) -> None:
+    repository, factory = publication_context
+    document = DocumentRecord(uuid4(), uuid4(), uuid4(), "source-2", f"doc-{uuid4()}", "Stable")
+    await _register_source(factory, document)
+    await repository.create_document(document)
+    active = version(document.id, DocumentVersionState.VALIDATED, fingerprint="4" * 64)
+    failed = version(document.id, DocumentVersionState.FAILED, fingerprint="5" * 64)
+    await repository.create_version(active)
+    await repository.create_version(failed)
+    service = DocumentPublicationService(repository)
+    await service.publish_validated(active.id, artifacts=(), chunks=())
+
+    with pytest.raises(RuntimeError):
+        await service.publish_validated(failed.id, artifacts=(), chunks=())
+
+    assert len(await repository.list_searchable_versions(document.id)) == 1
+    assert (await repository.list_searchable_versions(document.id))[0].id == active.id
+
+
+@pytest.mark.integration
+async def test_source_deletion_retires_active_version_immediately(
+    publication_context: tuple[PostgresDocumentRepository, async_sessionmaker[AsyncSession]],
+) -> None:
+    repository, factory = publication_context
+    document = DocumentRecord(uuid4(), uuid4(), uuid4(), "source-3", f"doc-{uuid4()}", "Deleted")
+    await _register_source(factory, document)
+    await repository.create_document(document)
+    active = version(document.id, DocumentVersionState.VALIDATED, fingerprint="6" * 64)
+    await repository.create_version(active)
+    await DocumentPublicationService(repository).publish_validated(
+        active.id, artifacts=(), chunks=()
+    )
+
+    await DocumentPublicationService(repository).mark_source_deleted(document.id)
+
+    assert await repository.list_searchable_versions(document.id) == ()
+    assert (await repository.get_version(active.id)).state is DocumentVersionState.RETIRED