Implement task 014 assets and media library workflow

2026-05-21 23:55:15 +03:00
parent c3914bf8be
commit 8243f20b0e
23 changed files with 2423 additions and 22 deletions
@@ -0,0 +1,366 @@
+from __future__ import annotations
+
+import base64
+import os
+import sys
+import tempfile
+import unittest
+from pathlib import Path
+from typing import Any
+from uuid import UUID
+
+from fastapi.testclient import TestClient
+
+
+BACKEND_ROOT = Path(__file__).resolve().parents[2]
+sys.path.insert(0, str(BACKEND_ROOT))
+
+from src.application.seed_data import seed_reference_data  # noqa: E402
+from src.infrastructure.repositories import open_backend_repository  # noqa: E402
+from src.presentation.dependencies import get_repository  # noqa: E402
+from src.presentation.main import app  # noqa: E402
+
+
+DEMO_EDITOR_EMAIL = "editor@example.com"
+DEMO_USER_EMAIL_HEADER = "X-Demo-User-Email"
+
+
+class AssetsMediaLibraryPublicApiTest(unittest.TestCase):
+    def setUp(self) -> None:
+        self.tmp_dir = tempfile.TemporaryDirectory()
+        self.objects_root = Path(self.tmp_dir.name) / "objects"
+        os.environ["OBJECT_STORAGE_LOCAL_ROOT"] = str(self.objects_root)
+        dsn = f"sqlite:///{Path(self.tmp_dir.name) / 'assets-media-library.db'}"
+        self.repository = open_backend_repository(dsn)
+        self.repository.setup()
+        seed_reference_data(self.repository)
+        app.dependency_overrides[get_repository] = lambda: self.repository
+        self.client = TestClient(app)
+
+    def tearDown(self) -> None:
+        app.dependency_overrides.clear()
+        os.environ.pop("OBJECT_STORAGE_LOCAL_ROOT", None)
+        self.tmp_dir.cleanup()
+
+    def test_generate_specs_links_assets_to_approved_plan_sections(self) -> None:
+        article_id, plan = self._prepare_article_with_approved_plan()
+
+        response = self.client.post(
+            f"/api/articles/{article_id}/assets/generate-specs",
+            headers={DEMO_USER_EMAIL_HEADER: DEMO_EDITOR_EMAIL},
+        )
+        self.assertEqual(201, response.status_code, response.text)
+        assets = response.json()["assets"]
+        self.assertEqual(len(plan["sections"]), len(assets))
+        section_ids = {section["id"] for section in plan["sections"]}
+        for asset in assets:
+            self.assertIn(asset["section_id"], section_ids)
+            self.assertEqual("GENERATED", asset["status"])
+            self.assertTrue(asset["title"])
+
+    def test_upload_stores_object_and_persists_object_key(self) -> None:
+        article_id = self._prepare_article_with_assembled_draft()
+        asset_id = self._generate_specs(article_id)[0]["id"]
+
+        upload_response = self.client.post(
+            f"/api/articles/{article_id}/assets/{asset_id}/upload",
+            headers={DEMO_USER_EMAIL_HEADER: DEMO_EDITOR_EMAIL},
+            json={
+                "filename": "hero.png",
+                "content_base64": base64.b64encode(b"fake-binary-image-content").decode("utf-8"),
+                "content_type": "image/png",
+            },
+        )
+        self.assertEqual(200, upload_response.status_code, upload_response.text)
+        asset = upload_response.json()["asset"]
+        self.assertEqual("PENDING", asset["status"])
+        self.assertTrue(asset["object_key"])
+        self.assertTrue(asset["file_url"].startswith("file://"))
+        self.assertTrue(
+            (self.objects_root / asset["object_key"]).exists(),
+            "Uploaded object must exist in local object storage",
+        )
+        persisted = (self.objects_root / asset["object_key"]).read_bytes()
+        self.assertEqual(b"fake-binary-image-content", persisted)
+        history = asset["history"]
+        self.assertGreaterEqual(len(history), 1)
+        self.assertEqual("ASSET_FILE_UPLOADED", history[-1]["action"])
+
+    def test_approve_asset_writes_workflow_event(self) -> None:
+        article_id = self._prepare_article_with_assembled_draft()
+        asset_id = self._generate_specs(article_id)[0]["id"]
+        self._upload_asset(article_id, asset_id, filename="approve.png", payload=b"approve")
+
+        approve_response = self.client.post(
+            f"/api/articles/{article_id}/assets/{asset_id}/approve",
+            headers={DEMO_USER_EMAIL_HEADER: DEMO_EDITOR_EMAIL},
+        )
+        self.assertEqual(200, approve_response.status_code, approve_response.text)
+        self.assertEqual("APPROVED", approve_response.json()["asset"]["status"])
+
+        article_detail = self.client.get(
+            f"/api/articles/{article_id}",
+            headers={DEMO_USER_EMAIL_HEADER: DEMO_EDITOR_EMAIL},
+        )
+        self.assertEqual(200, article_detail.status_code, article_detail.text)
+        events = article_detail.json()["workflow_events"]
+        approval_events = [event for event in events if event["event_type"] == "ASSET_APPROVED"]
+        self.assertTrue(approval_events, "Approval must write workflow event")
+        self.assertEqual(asset_id, approval_events[-1]["payload"]["asset_id"])
+
+    def test_rejected_assets_are_excluded_from_draft_publish_bundle(self) -> None:
+        article_id = self._prepare_article_with_completed_scaffolds()
+        generated_assets = self._generate_specs(article_id)
+        self.assertGreaterEqual(len(generated_assets), 2)
+        approved_asset = generated_assets[0]
+        rejected_asset = generated_assets[1]
+
+        approved_upload = self._upload_asset(
+            article_id,
+            approved_asset["id"],
+            filename="approved.png",
+            payload=b"approved-image",
+        )
+        self._approve_asset(article_id, approved_asset["id"])
+        rejected_upload = self._upload_asset(
+            article_id,
+            rejected_asset["id"],
+            filename="rejected.png",
+            payload=b"rejected-image",
+        )
+        self._patch_asset(
+            article_id,
+            rejected_asset["id"],
+            request={"status": "REJECTED"},
+        )
+
+        draft = self._assemble_draft(article_id)
+        self.assertIn(approved_upload["file_url"], draft["body_markdown"])
+        self.assertNotIn(rejected_upload["file_url"], draft["body_markdown"])
+        self.assertIn(approved_upload["file_url"], "\n".join(draft["visual_placeholders"]))
+        self.assertNotIn(rejected_upload["file_url"], "\n".join(draft["visual_placeholders"]))
+
+    def test_replacement_preserves_audit_history(self) -> None:
+        article_id = self._prepare_article_with_assembled_draft()
+        asset_id = self._generate_specs(article_id)[0]["id"]
+        first = self._upload_asset(article_id, asset_id, filename="first.png", payload=b"first")
+        second = self._upload_asset(article_id, asset_id, filename="second.png", payload=b"second")
+        self.assertNotEqual(first["object_key"], second["object_key"])
+
+        list_response = self.client.get(
+            f"/api/articles/{article_id}/assets",
+            headers={DEMO_USER_EMAIL_HEADER: DEMO_EDITOR_EMAIL},
+        )
+        self.assertEqual(200, list_response.status_code, list_response.text)
+        asset = next(item for item in list_response.json()["assets"] if item["id"] == asset_id)
+        history = asset["history"]
+        actions = [item["action"] for item in history]
+        self.assertIn("ASSET_FILE_UPLOADED", actions)
+        self.assertIn("ASSET_FILE_REPLACED", actions)
+        replaced_event = next(item for item in history if item["action"] == "ASSET_FILE_REPLACED")
+        self.assertEqual(first["object_key"], replaced_event["payload"]["previous_object_key"])
+        self.assertEqual(second["object_key"], replaced_event["payload"]["next_object_key"])
+
+    def test_media_library_lists_assets_with_required_fields(self) -> None:
+        article_id = self._prepare_article_with_assembled_draft()
+        asset_id = self._generate_specs(article_id)[0]["id"]
+        self._upload_asset(article_id, asset_id, filename="library.png", payload=b"library")
+        self._patch_asset(
+            article_id,
+            asset_id,
+            request={
+                "title": "Library Hero",
+                "alt_text": "Dashboard on laptop screen",
+                "caption": "Screenshot used in introduction section.",
+            },
+        )
+
+        list_response = self.client.get(
+            f"/api/articles/{article_id}/assets",
+            headers={DEMO_USER_EMAIL_HEADER: DEMO_EDITOR_EMAIL},
+        )
+        self.assertEqual(200, list_response.status_code, list_response.text)
+        asset = next(item for item in list_response.json()["assets"] if item["id"] == asset_id)
+        self.assertEqual("Library Hero", asset["title"])
+        self.assertTrue(asset["asset_type"])
+        self.assertTrue(asset["status"])
+        self.assertTrue(asset["file_url"])
+        self.assertEqual("Dashboard on laptop screen", asset["alt_text"])
+        self.assertEqual("Screenshot used in introduction section.", asset["caption"])
+
+    def test_draft_preview_uses_approved_asset_references(self) -> None:
+        article_id = self._prepare_article_with_completed_scaffolds()
+        asset = self._generate_specs(article_id)[0]
+        uploaded = self._upload_asset(
+            article_id,
+            asset["id"],
+            filename="preview.png",
+            payload=b"preview",
+        )
+        self._approve_asset(article_id, asset["id"])
+
+        draft = self._assemble_draft(article_id)
+        self.assertIn(uploaded["file_url"], draft["body_markdown"])
+        self.assertIn(uploaded["file_url"], "\n".join(draft["visual_placeholders"]))
+
+    def _assemble_draft(self, article_id: UUID) -> dict[str, Any]:
+        response = self.client.post(
+            f"/api/articles/{article_id}/draft/assemble",
+            headers={DEMO_USER_EMAIL_HEADER: DEMO_EDITOR_EMAIL},
+        )
+        self.assertEqual(201, response.status_code, response.text)
+        return response.json()["draft"]
+
+    def _upload_asset(self, article_id: UUID, asset_id: str, *, filename: str, payload: bytes) -> dict[str, Any]:
+        response = self.client.post(
+            f"/api/articles/{article_id}/assets/{asset_id}/upload",
+            headers={DEMO_USER_EMAIL_HEADER: DEMO_EDITOR_EMAIL},
+            json={
+                "filename": filename,
+                "content_base64": base64.b64encode(payload).decode("utf-8"),
+                "content_type": "image/png",
+            },
+        )
+        self.assertEqual(200, response.status_code, response.text)
+        return response.json()["asset"]
+
+    def _approve_asset(self, article_id: UUID, asset_id: str) -> None:
+        response = self.client.post(
+            f"/api/articles/{article_id}/assets/{asset_id}/approve",
+            headers={DEMO_USER_EMAIL_HEADER: DEMO_EDITOR_EMAIL},
+        )
+        self.assertEqual(200, response.status_code, response.text)
+
+    def _patch_asset(self, article_id: UUID, asset_id: str, *, request: dict[str, Any]) -> dict[str, Any]:
+        response = self.client.patch(
+            f"/api/articles/{article_id}/assets/{asset_id}",
+            headers={DEMO_USER_EMAIL_HEADER: DEMO_EDITOR_EMAIL},
+            json=request,
+        )
+        self.assertEqual(200, response.status_code, response.text)
+        return response.json()["asset"]
+
+    def _generate_specs(self, article_id: UUID) -> list[dict[str, Any]]:
+        response = self.client.post(
+            f"/api/articles/{article_id}/assets/generate-specs",
+            headers={DEMO_USER_EMAIL_HEADER: DEMO_EDITOR_EMAIL},
+        )
+        self.assertEqual(201, response.status_code, response.text)
+        return response.json()["assets"]
+
+    def _prepare_article_with_assembled_draft(self) -> UUID:
+        article_id = self._prepare_article_with_completed_scaffolds()
+        self._assemble_draft(article_id)
+        return article_id
+
+    def _prepare_article_with_completed_scaffolds(self) -> UUID:
+        article_id, _ = self._prepare_article_with_approved_plan()
+        self._ensure_evidence_ready(article_id)
+        section_jobs = self._start_parallel_production(article_id)
+        self._complete_all_section_jobs_success(section_jobs)
+        return article_id
+
+    def _prepare_article_with_approved_plan(self) -> tuple[UUID, dict[str, Any]]:
+        site = self.client.get(
+            "/api/sites",
+            headers={DEMO_USER_EMAIL_HEADER: DEMO_EDITOR_EMAIL},
+        ).json()[0]["site"]
+        article = self.client.post(
+            "/api/articles",
+            headers={DEMO_USER_EMAIL_HEADER: DEMO_EDITOR_EMAIL},
+            json={
+                "target_site_id": site["id"],
+                "brief_description": "Assets library integration coverage",
+                "working_title": "Assets and Media Library",
+                "content_type": "longform_guide",
+                "primary_keyword": "assets media library",
+            },
+        ).json()["article"]
+        article_id = UUID(article["id"])
+
+        questions = self.client.post(
+            f"/api/articles/{article_id}/boundary-questions/generate",
+            headers={DEMO_USER_EMAIL_HEADER: DEMO_EDITOR_EMAIL},
+        ).json()["questions"]
+        for question in questions:
+            if question["is_required"]:
+                patch_response = self.client.patch(
+                    f"/api/articles/{article_id}/boundary-questions/{question['id']}",
+                    headers={DEMO_USER_EMAIL_HEADER: DEMO_EDITOR_EMAIL},
+                    json={"answer": f"Answer for {question['category']}"},
+                )
+                self.assertEqual(200, patch_response.status_code, patch_response.text)
+
+        submit_response = self.client.post(
+            f"/api/articles/{article_id}/boundary-questions/submit",
+            headers={DEMO_USER_EMAIL_HEADER: DEMO_EDITOR_EMAIL},
+        )
+        self.assertEqual(200, submit_response.status_code, submit_response.text)
+
+        plan_response = self.client.post(
+            f"/api/articles/{article_id}/plan/generate",
+            headers={DEMO_USER_EMAIL_HEADER: DEMO_EDITOR_EMAIL},
+        )
+        self.assertEqual(201, plan_response.status_code, plan_response.text)
+        plan = plan_response.json()["plan"]
+        self.assertGreaterEqual(len(plan["sections"]), 1)
+
+        approve_plan_response = self.client.post(
+            f"/api/articles/{article_id}/plans/{plan['id']}/approve",
+            headers={DEMO_USER_EMAIL_HEADER: DEMO_EDITOR_EMAIL},
+        )
+        self.assertEqual(200, approve_plan_response.status_code, approve_plan_response.text)
+        return article_id, plan
+
+    def _complete_all_section_jobs_success(self, section_jobs: list[dict[str, Any]]) -> None:
+        for index, job in enumerate(section_jobs, start=1):
+            complete_response = self.client.post(
+                f"/internal/agent-jobs/{job['id']}/complete",
+                json={
+                    "workspace_path": f"/tmp/{job['id']}",
+                    "stdout": "fake section scaffolding runner\n",
+                    "stderr": "",
+                    "exit_code": 0,
+                    "duration_ms": 1,
+                    "output": {
+                        "status": "SUCCEEDED",
+                        "output_files": [{"path": f"outputs/section-{index}.md"}],
+                        "payload": {
+                            "used_evidence_ids": job["payload"]["used_evidence_ids"],
+                            "unsupported_claims": [],
+                            "draft_markdown": f"## {job['payload']['heading']}\n\nSection {index}.",
+                        },
+                    },
+                },
+            )
+            self.assertEqual(200, complete_response.status_code, complete_response.text)
+            self.assertEqual("SUCCEEDED", complete_response.json()["job"]["status"])
+
+    def _start_parallel_production(self, article_id: UUID) -> list[dict[str, Any]]:
+        response = self.client.post(
+            f"/api/articles/{article_id}/draft/start",
+            headers={DEMO_USER_EMAIL_HEADER: DEMO_EDITOR_EMAIL},
+        )
+        self.assertEqual(202, response.status_code, response.text)
+        jobs = response.json()["jobs"]
+        section_jobs = [job for job in jobs if job["job_type"] == "SECTION_SCAFFOLD"]
+        self.assertTrue(section_jobs)
+        return section_jobs
+
+    def _ensure_evidence_ready(self, article_id: UUID) -> None:
+        research_response = self.client.post(
+            f"/api/articles/{article_id}/research/start",
+            headers={DEMO_USER_EMAIL_HEADER: DEMO_EDITOR_EMAIL},
+        )
+        self.assertEqual(201, research_response.status_code, research_response.text)
+
+        evidence_response = self.client.get(
+            f"/api/articles/{article_id}/evidence",
+            headers={DEMO_USER_EMAIL_HEADER: DEMO_EDITOR_EMAIL},
+        )
+        self.assertEqual(200, evidence_response.status_code, evidence_response.text)
+        self.assertEqual("EVIDENCE_MATRIX_READY", evidence_response.json()["article"]["status"])
+
+
+if __name__ == "__main__":
+    unittest.main()