实现本地 Markdown 清洗评审器

tests/test_artifact_store.py

@@ -10,6 +10,8 @@ import pytest
 import mdpolish.artifact_store as artifact_store
 from mdpolish.artifact_store import ArtifactStoreError, StoredDocument, publish_run
 
+_SOURCE_BYTES = b"source\n"
+
 
 def stored_document(document_id: str = "paper", output: bytes | None = b"cleaned\n") -> StoredDocument:
     status = "success" if output is not None else "failed"
@@ -18,7 +20,7 @@ def stored_document(document_id: str = "paper", output: bytes | None = b"cleaned
         "schema_version": 1,
         "document": {"document_id": document_id, "source_label": f"inputs/{document_id}.md"},
         "status": status,
-        "input_sha256": "1" * 64,
+        "input_sha256": sha256(_SOURCE_BYTES).hexdigest(),
         "current_sha256": current_sha256,
         "changes": [],
         "errors": [] if status == "success" else [{"error_type": "SyntheticError"}],
@@ -82,15 +84,49 @@ def manifest_json(
     return (json.dumps(payload, indent=2) + "\n").encode()
 
 
+def review_locator_json(
+    artifacts_root: Path,
+    run_date: str,
+    run_id: str,
+    documents: tuple[StoredDocument, ...],
+) -> bytes:
+    source_root = artifacts_root.parent / f"{artifacts_root.name}-sources"
+    source_root.mkdir(exist_ok=True)
+    locator_documents: list[dict[str, object]] = []
+    for position, document in enumerate(documents):
+        source_path = source_root / f"{position}-{document.document_id}.md"
+        source_path.write_bytes(_SOURCE_BYTES)
+        report = json.loads(document.result_json)
+        locator_documents.append(
+            {
+                "document_id": document.document_id,
+                "source_path": str(source_path.resolve()),
+                "input_sha256": report["input_sha256"],
+            }
+        )
+    payload = {
+        "schema_version": 1,
+        "run": {
+            "run_id": run_id,
+            "run_directory": str((artifacts_root / run_date / "runs" / run_id).resolve()),
+            "manifest_path": "manifest.json",
+        },
+        "documents": locator_documents,
+    }
+    return (json.dumps(payload, indent=2) + "\n").encode()
+
+
 def test_publish_run_creates_private_date_layout_and_status_specific_files(tmp_path: Path) -> None:
     artifacts_root = tmp_path / "artifacts"
     documents = (stored_document("success"), stored_document("failed", None))
+    locator_json = review_locator_json(artifacts_root, "2026-08-22", "example-run", documents)
 
     run_directory = publish_run(
         artifacts_root=artifacts_root,
         run_date="2026-08-22",
         run_id="example-run",
         manifest_json=manifest_json("2026-08-22", "example-run", documents),
+        review_locator_json=locator_json,
         documents=documents,
     )
 
@@ -100,6 +136,7 @@ def test_publish_run_creates_private_date_layout_and_status_specific_files(tmp_p
     assert (run_directory / "documents/success/cleaned.md").read_bytes() == b"cleaned\n"
     assert (run_directory / "documents/success/changes.diff").read_bytes() == b""
     assert (run_directory / "documents/failed/result.json").is_file()
+    assert (run_directory / "review-locator.json").read_bytes() == locator_json
     assert not (run_directory / "documents/failed/cleaned.md").exists()
     assert not (run_directory / "documents/failed/changes.diff").exists()
 
@@ -121,11 +158,13 @@ def test_publish_run_rejects_existing_target_without_overwriting(tmp_path: Path)
     artifacts_root = tmp_path / "artifacts"
     documents = (stored_document(),)
     first_manifest = manifest_json("2026-08-22", "same-run", documents)
+    locator_json = review_locator_json(artifacts_root, "2026-08-22", "same-run", documents)
     run_directory = publish_run(
         artifacts_root=artifacts_root,
         run_date="2026-08-22",
         run_id="same-run",
         manifest_json=first_manifest,
+        review_locator_json=locator_json,
         documents=documents,
     )
 
@@ -135,6 +174,7 @@ def test_publish_run_rejects_existing_target_without_overwriting(tmp_path: Path)
             run_date="2026-08-22",
             run_id="same-run",
             manifest_json=first_manifest,
+            review_locator_json=locator_json,
             documents=documents,
         )
 
@@ -152,13 +192,15 @@ def test_publish_run_rejects_existing_target_without_overwriting(tmp_path: Path)
     ],
 )
 def test_publish_run_rejects_unsafe_date_and_run_id(tmp_path: Path, run_date: str, run_id: str) -> None:
+    artifacts_root = tmp_path / "artifacts"
     documents = (stored_document(),)
     with pytest.raises(ArtifactStoreError):
         publish_run(
-            artifacts_root=tmp_path / "artifacts",
+            artifacts_root=artifacts_root,
             run_date=run_date,
             run_id=run_id,
             manifest_json=manifest_json(run_date, run_id, documents),
+            review_locator_json=review_locator_json(artifacts_root, run_date, run_id, documents),
             documents=documents,
         )
 
@@ -166,22 +208,30 @@ def test_publish_run_rejects_unsafe_date_and_run_id(tmp_path: Path, run_date: st
 def test_publish_run_rejects_inconsistent_or_duplicate_document_artifacts(tmp_path: Path) -> None:
     valid = stored_document()
     bad_hash = StoredDocument("paper", valid.result_json, b"output", b"", "0" * 64)
+    first_artifacts_root = tmp_path / "artifacts-a"
     with pytest.raises(ArtifactStoreError, match="output hash"):
         publish_run(
-            artifacts_root=tmp_path / "artifacts-a",
+            artifacts_root=first_artifacts_root,
             run_date="2026-08-22",
             run_id="bad-hash",
             manifest_json=manifest_json("2026-08-22", "bad-hash", (bad_hash,)),
+            review_locator_json=review_locator_json(
+                first_artifacts_root, "2026-08-22", "bad-hash", (bad_hash,)
+            ),
             documents=(bad_hash,),
         )
 
     duplicates = (stored_document(), stored_document())
+    second_artifacts_root = tmp_path / "artifacts-b"
     with pytest.raises(ArtifactStoreError, match="unique"):
         publish_run(
-            artifacts_root=tmp_path / "artifacts-b",
+            artifacts_root=second_artifacts_root,
             run_date="2026-08-22",
             run_id="duplicate",
             manifest_json=manifest_json("2026-08-22", "duplicate", duplicates),
+            review_locator_json=review_locator_json(
+                second_artifacts_root, "2026-08-22", "duplicate", duplicates
+            ),
             documents=duplicates,
         )
 
@@ -189,32 +239,81 @@ def test_publish_run_rejects_inconsistent_or_duplicate_document_artifacts(tmp_pa
 def test_publish_run_rejects_manifest_path_or_document_mismatch(tmp_path: Path) -> None:
     documents = (stored_document(),)
     wrong_date = manifest_json("2026-08-21", "review", documents)
+    first_artifacts_root = tmp_path / "artifacts-a"
     with pytest.raises(ArtifactStoreError, match="identity"):
         publish_run(
-            artifacts_root=tmp_path / "artifacts-a",
+            artifacts_root=first_artifacts_root,
             run_date="2026-08-22",
             run_id="review",
             manifest_json=wrong_date,
+            review_locator_json=review_locator_json(
+                first_artifacts_root, "2026-08-22", "review", documents
+            ),
             documents=documents,
         )
 
     payload = json.loads(manifest_json("2026-08-22", "review", documents))
     payload["documents"][0]["change_count"] = 99
     mismatched_index = (json.dumps(payload, indent=2) + "\n").encode()
+    second_artifacts_root = tmp_path / "artifacts-b"
     with pytest.raises(ArtifactStoreError, match="index"):
         publish_run(
-            artifacts_root=tmp_path / "artifacts-b",
+            artifacts_root=second_artifacts_root,
             run_date="2026-08-22",
             run_id="review",
             manifest_json=mismatched_index,
+            review_locator_json=review_locator_json(
+                second_artifacts_root, "2026-08-22", "review", documents
+            ),
             documents=documents,
         )
 
 
+def test_publish_run_rejects_inconsistent_review_locator(tmp_path: Path) -> None:
+    artifacts_root = tmp_path / "artifacts"
+    documents = (stored_document(),)
+    locator = json.loads(review_locator_json(artifacts_root, "2026-08-22", "review", documents))
+    locator["documents"][0]["input_sha256"] = "0" * 64
+    inconsistent_locator = (json.dumps(locator, indent=2) + "\n").encode()
+
+    with pytest.raises(ArtifactStoreError, match="document identity"):
+        publish_run(
+            artifacts_root=artifacts_root,
+            run_date="2026-08-22",
+            run_id="review",
+            manifest_json=manifest_json("2026-08-22", "review", documents),
+            review_locator_json=inconsistent_locator,
+            documents=documents,
+        )
+
+    assert not artifacts_root.exists()
+
+
+def test_publish_run_rejects_source_changed_after_locator_creation(tmp_path: Path) -> None:
+    artifacts_root = tmp_path / "artifacts"
+    documents = (stored_document(),)
+    locator_json = review_locator_json(artifacts_root, "2026-08-22", "review", documents)
+    locator = json.loads(locator_json)
+    Path(locator["documents"][0]["source_path"]).write_bytes(b"changed\n")
+
+    with pytest.raises(ArtifactStoreError, match="input hash"):
+        publish_run(
+            artifacts_root=artifacts_root,
+            run_date="2026-08-22",
+            run_id="review",
+            manifest_json=manifest_json("2026-08-22", "review", documents),
+            review_locator_json=locator_json,
+            documents=documents,
+        )
+
+    assert not artifacts_root.exists()
+
+
 def test_publish_race_does_not_replace_a_new_target(
     tmp_path: Path,
     monkeypatch: pytest.MonkeyPatch,
 ) -> None:
+    artifacts_root = tmp_path / "artifacts"
     documents = (stored_document(),)
     original_rename = artifact_store._rename_no_replace
 
@@ -226,10 +325,11 @@ def test_publish_race_does_not_replace_a_new_target(
     monkeypatch.setattr(artifact_store, "_rename_no_replace", create_competing_target)
     with pytest.raises(ArtifactStoreError, match="already exists"):
         publish_run(
-            artifacts_root=tmp_path / "artifacts",
+            artifacts_root=artifacts_root,
             run_date="2026-08-22",
             run_id="raced",
             manifest_json=manifest_json("2026-08-22", "raced", documents),
+            review_locator_json=review_locator_json(artifacts_root, "2026-08-22", "raced", documents),
             documents=documents,
         )
 
@@ -253,14 +353,44 @@ def test_write_failure_cleans_temporary_directory_and_does_not_publish(
         original_write(path, content)
 
     monkeypatch.setattr(artifact_store, "_write_private_file", fail_second_write)
+    artifacts_root = tmp_path / "artifacts"
     documents = (stored_document(),)
 
     with pytest.raises(OSError, match="synthetic"):
         publish_run(
-            artifacts_root=tmp_path / "artifacts",
+            artifacts_root=artifacts_root,
             run_date="2026-08-22",
             run_id="broken",
             manifest_json=manifest_json("2026-08-22", "broken", documents),
+            review_locator_json=review_locator_json(artifacts_root, "2026-08-22", "broken", documents),
+            documents=documents,
+        )
+
+    runs_directory = tmp_path / "artifacts/2026-08-22/runs"
+    assert list(runs_directory.iterdir()) == []
+
+
+def test_locator_write_failure_does_not_publish(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
+    original_write = artifact_store._write_private_file
+
+    def fail_locator_write(path: Path, content: bytes) -> None:
+        if path.name == "review-locator.json":
+            raise OSError("synthetic locator write failure")
+        original_write(path, content)
+
+    monkeypatch.setattr(artifact_store, "_write_private_file", fail_locator_write)
+    artifacts_root = tmp_path / "artifacts"
+    documents = (stored_document(),)
+
+    with pytest.raises(OSError, match="locator"):
+        publish_run(
+            artifacts_root=artifacts_root,
+            run_date="2026-08-22",
+            run_id="locator-failure",
+            manifest_json=manifest_json("2026-08-22", "locator-failure", documents),
+            review_locator_json=review_locator_json(
+                artifacts_root, "2026-08-22", "locator-failure", documents
+            ),
             documents=documents,
         )