Integrate Content Editor and Publication workflow

This commit is contained in:
2026-11-17 11:43:53 +03:00
parent f18bc9a4fd
commit c3938f24d8
55 changed files with 6207 additions and 203 deletions
+359
View File
@@ -0,0 +1,359 @@
"""Content editor contract: real metadata, stateless readiness, CAS and immutable Live."""
import json
import os
import shutil
import tempfile
import unittest
from pathlib import Path
from unittest.mock import patch
from fastapi.testclient import TestClient
from site_engine.build.pipeline import build_site
from site_engine.core.registry import load_site
from site_engine.parsing.frontmatter import dumps, parse
from site_engine.parsing.yamlio import dump_yaml, load_yaml
from site_engine.services.auth import hash_password
from site_engine.services.documents import EditorContext
from site_engine.services.entries import EntryService
from site_engine.web.app import create_app
ROOT = Path(__file__).resolve().parents[1]
class ContentEditorTests(unittest.TestCase):
@classmethod
def setUpClass(cls):
cls.password = "content editor test password"
cls.password_hash = hash_password(cls.password, n=2**10)
def setUp(self):
tmp = tempfile.TemporaryDirectory(prefix="content-editor-test-")
self.addCleanup(tmp.cleanup)
self.work = Path(tmp.name)
self.site = self.work / "site"
self.dist = self.work / "dist"
shutil.copytree(
ROOT / "examples/site-studio", self.site, ignore=shutil.ignore_patterns(".engine")
)
env = patch.dict(
os.environ,
{
"SITE_ROOT": str(self.site),
"SITE_DIST": str(self.dist),
"SITE_STATE_DIR": str(self.work / "state"),
"SITE_ADMIN_LOGIN": "admin",
"SITE_ADMIN_PASSWORD_HASH": self.password_hash,
"SITE_SECRET_KEY": "content-editor-test-secret-" * 3,
"SITE_COOKIE_SECURE": "0",
"SITE_ADMIN_ORIGIN": "",
"SITE_PREVIEW_ORIGIN": "",
},
)
env.start()
self.addCleanup(env.stop)
self.app = create_app()
self.client = TestClient(self.app)
self.addCleanup(self.client.close)
cookie = self.app.state.auth.login("admin", self.password, "testclient")
self.client.cookies.set("se_session", cookie)
self.app.state.api_credentials["test"] = (cookie, "testclient")
self.principal = self.app.state.auth.authenticate(cookie)
self.ctx = EditorContext(self.principal, "testclient")
self.csrf = self.app.state.auth.csrf_token(self.principal)
self.svc = EntryService(self.site, collection="services", dist=self.dist)
self.snap = self.svc.get("bots")
def payload(self, **extra):
return {"source": self.snap.source, "etag": self.snap.etag, "revision": 7, **extra}
def api(self, op, payload=None, identity="bots"):
return self.client.post(
f"/admin/api/v1/collections/services/entries/{identity}/{op}",
json=self.payload() if payload is None else payload,
headers={"Authorization": "Bearer test"},
)
def ui(self, op, payload=None, csrf=None):
return self.client.post(
"/admin/editor/content/services/bots/" + op,
data={
"csrf": self.csrf if csrf is None else csrf,
"payload": json.dumps(self.payload() if payload is None else payload),
},
headers={
"Origin": "http://testserver",
"HX-Request": "true",
"Accept": "application/json",
},
)
def test_original_workspace_markup_static_and_empty_disabled_collection(self):
response = self.client.get("/admin/content/services/bots")
self.assertEqual(response.status_code, 200)
for marker in (
"entry-workspace",
"collection-pane",
"entry-pane",
"editor-content",
"preview-pane",
"entry-tabs",
"source-edit-wrap",
"data-content-picker",
):
self.assertIn(marker, response.text)
self.assertNotIn("409 Demo", response.text)
for name in ("content-editor.css", "content-adapter.css", "content-editor.js"):
self.assertEqual(self.client.get("/admin/static/" + name).status_code, 200)
empty = self.client.get("/admin/content/posts")
self.assertEqual(empty.status_code, 200)
self.assertIn("Записей пока нет", empty.text)
self.assertIn("OFF", empty.text)
self.assertIn("disabled", empty.text)
def test_update_has_one_registry_and_api_call_and_no_write(self):
before = (self.site / self.snap.path).read_bytes()
calls = self.app.state.api_calls
payload = self.payload(
preview_view="card",
operations=[{"type": "entry_fields", "values": {"title": "Current candidate"}}],
)
with patch("site_engine.services.documents.load_site", wraps=load_site) as load:
response = self.ui("update", payload)
self.assertEqual(response.status_code, 200, response.text)
self.assertEqual(load.call_count, 1)
self.assertEqual(self.app.state.api_calls - calls, 1)
result = response.json()
self.assertIn("Current candidate", result["preview"]["html"])
self.assertIn("f-entry_card", result["preview"]["html"])
self.assertIn("data-content-panel", result["projection"])
self.assertNotIn("name='source'", result["projection"])
self.assertEqual((self.site / self.snap.path).read_bytes(), before)
self.assertFalse((self.site / ".engine/history").exists())
self.assertFalse((self.dist / "current").exists())
def test_readiness_missing_required_and_render_errors_does_not_block_draft_save(self):
meta, body = parse(self.snap.source)
meta.update(
status="draft", hero_asset="assets/missing.webp", cta={"href": {"page": "missing-page"}}
)
meta.pop("title")
source = dumps(meta, body)
response = self.ui("check", self.payload(source=source))
self.assertEqual(response.status_code, 200, response.text)
codes = {i["code"] for i in response.json()["issues"]}
self.assertIn("E_ENTRY_REQUIRED", codes)
self.assertTrue({"E_ASSET_MISSING", "E_LINK_BROKEN"} & codes, codes)
self.assertEqual((self.site / self.snap.path).read_text(), self.snap.source)
self.assertEqual(self.ui("save", self.payload(source=source)).status_code, 200)
self.assertFalse((self.dist / "current").exists())
def test_readiness_reports_invalid_yaml_without_rewriting_source(self):
source = "---\ntitle: [\n---\nCurrent text"
response = self.api("check", self.payload(source=source))
self.assertEqual(response.status_code, 200)
self.assertTrue(response.json()["issues"])
self.assertEqual((self.site / self.snap.path).read_text(), self.snap.source)
def test_dependencies_use_candidate_query_membership_and_nested_typed_refs(self):
schema_file = self.site / "collections/cases.yaml"
schema = load_yaml(schema_file.read_text())
schema["fields"].append(
{
"key": "nested",
"type": "list",
"fields": [
{"key": "related", "type": "ref", "to": "*"},
{"key": "link", "type": "link"},
],
}
)
schema_file.write_text(dump_yaml(schema))
target = self.site / "content/cases/booking.md"
meta, body = parse(target.read_text())
meta["nested"] = [{"related": "services/bots", "link": {"entry": "services/bots"}}]
target.write_text(dumps(meta, body))
meta, body = parse(self.snap.source)
result = self.svc.validate_source("bots", self.snap.source, self.snap.etag).schema[
"content"
]
self.assertTrue(any(u["field"] == "nested.0.related" for u in result["usages"]))
self.assertTrue(any(u["field"] == "nested.0.link" for u in result["usages"]))
# Home's featured query uses the candidate, not the saved file.
home_before = [u for u in result["usages"] if u["file"] == "pages/index.md"]
self.assertTrue(home_before)
meta["status"] = "draft"
result = self.svc.validate_source("bots", dumps(meta, body), self.snap.etag).schema[
"content"
]
self.assertFalse(any(u["file"] == "pages/index.md" for u in result["usages"]))
self.assertTrue(any(r["target"] == "scenarios/legal" for r in result["relations"]))
self.assertFalse(next(c for c in result["collections"] if c["id"] == "posts")["enabled"])
def test_typed_form_preserves_link_list_refs_and_optional_boolean(self):
response = self.api(
"update",
self.payload(
operations=[
{
"type": "inspector",
"fields": {
"operation": ["entry_fields"],
"p.title": ["Typed fields"],
"p.featured": ["false"],
"p.cta.href.kind": ["entry"],
"p.cta.href.target": ["services/ai"],
"p.benefits.0": ["First"],
"p.benefits.1": ["Second"],
"p.benefits.0._del": ["1"],
"p.related_scenarios": ["legal, services"],
"status": ["draft"],
},
}
]
),
)
self.assertEqual(response.status_code, 200, response.text)
meta = response.json()["snapshot"]["model"]["meta"]
self.assertEqual(meta["benefits"], ["Second"])
self.assertEqual(meta["cta"]["href"], {"entry": "services/ai"})
self.assertEqual(meta["related_scenarios"], ["legal", "services"])
self.assertFalse(meta["featured"])
def test_duplicate_uses_current_editor_and_cas_both_files(self):
source = self.snap.source.replace("Telegram-боты", "My candidate", 1)
response = self.ui("duplicate", self.payload(source=source, id="bots-copy"))
self.assertEqual(response.status_code, 200, response.text)
copy = response.json()["snapshot"]
self.assertEqual(copy["model"]["meta"]["status"], "draft")
self.assertEqual(copy["model"]["meta"]["title"], "My candidate (копия)")
self.assertEqual(copy["model"]["meta"]["slug"], "bots-copy")
self.assertEqual((self.site / self.snap.path).read_text(), self.snap.source)
self.assertEqual(self.api("duplicate", self.payload(id="bots-copy")).status_code, 409)
(self.site / self.snap.path).write_text(self.snap.source + "\nchanged")
self.assertEqual(self.api("duplicate", self.payload(id="bots-another")).status_code, 409)
self.assertFalse((self.site / "content/services/bots-another.md").exists())
self.assertEqual(self.api("duplicate", self.payload(id="../outside")).status_code, 422)
def test_delete_requires_saved_archive_cas_and_history(self):
self.assertEqual(self.api("delete").status_code, 422)
# Unsaved status does not authorize deleting a published file.
self.assertEqual(
self.api(
"delete", self.payload(source=self.snap.source.replace("published", "archived"))
).status_code,
422,
)
snapshot = self.svc.save_source(
"bots", self.snap.source.replace("published", "archived"), self.snap.etag, self.ctx
)
self.assertEqual(self.api("delete").status_code, 409)
response = self.api("delete", {"source": snapshot.source, "etag": snapshot.etag})
self.assertEqual(response.status_code, 200, response.text)
self.assertTrue(response.json()["deleted"])
self.assertFalse((self.site / self.snap.path).exists())
history = list((self.site / ".engine/history").rglob("*"))
self.assertTrue(any(p.is_file() for p in history))
def test_after_commit_audit_failure_reports_committed_copy_or_deleted_flag(self):
with patch.object(
self.app.state.auth.audit, "write", side_effect=OSError("audit unavailable")
):
with self.assertLogs("uvicorn.error", level="ERROR") as logs:
response = self.api("duplicate", self.payload(id="bots-copy"))
self.assertEqual(response.status_code, 500)
self.assertEqual(response.json()["error"]["committed"]["id"], "bots-copy")
self.assertTrue(any("Traceback" in item for item in logs.output))
copy_svc = EntryService(self.site, collection="services")
snapshot = copy_svc.get("bots-copy")
with patch.object(
self.app.state.auth.audit, "write", side_effect=OSError("audit unavailable")
):
response = self.api(
"delete", {"source": snapshot.source, "etag": snapshot.etag}, identity="bots-copy"
)
self.assertEqual(response.status_code, 500)
self.assertTrue(response.json()["error"]["deleted"])
self.assertFalse((self.site / snapshot.path).exists())
def test_live_is_release_html_and_assets_not_current_workspace(self):
build_site(self.site, self.dist)
manifest = json.loads((self.dist / "current/manifest.json").read_text())
self.assertEqual(manifest["entry_routes"]["services/bots"], "/services/bots/")
self.assertIn(self.snap.path, manifest["entry_sources"])
response = self.api(
"update",
self.payload(
preview_version="live",
preview_view="page",
source=self.snap.source.replace("Telegram-боты", "Only workspace", 1),
),
)
self.assertEqual(response.status_code, 200, response.text)
preview = response.json()["preview"]
self.assertIn("Telegram-боты", preview["html"])
self.assertNotIn("Only workspace", preview["html"])
result = self.client.get(preview["url"])
self.assertEqual(result.status_code, 200)
self.assertIn("script-src 'none'", result.headers["content-security-policy"])
from urllib.parse import parse_qs, urlsplit
token = parse_qs(urlsplit(preview["url"]).query)["token"][0]
folder, _meta = self.app.state.previews.authorize(preview["snapshot"], token)
self.assertTrue(list((folder / "assets").glob("site.*.css")))
self.assertEqual(self.client.get(preview["url"].split("?")[0]).status_code, 403)
card = self.api("update", self.payload(preview_version="live", preview_view="card")).json()[
"preview"
]
self.assertFalse(card["url"])
self.assertIn("карточка", card["message"])
def test_comparison_uses_unsaved_candidate_and_old_release_is_unknown(self):
build_site(self.site, self.dist)
self.assertFalse(
next(
e for e in self.svc.get("bots").schema["content"]["entries"] if e["slug"] == "bots"
)["changed"]
)
candidate = self.svc.validate_source("bots", self.snap.source + "\nunsaved", self.snap.etag)
self.assertTrue(
next(e for e in candidate.schema["content"]["entries"] if e["slug"] == "bots")[
"changed"
]
)
manifest_file = self.dist / "current/manifest.json"
manifest = json.loads(manifest_file.read_text())
del manifest["entry_sources"]
del manifest["entry_routes"]
manifest_file.write_text(json.dumps(manifest))
result = self.svc.get("bots").schema["content"]
self.assertFalse(result["comparison_available"])
self.assertIsNone(result["entries"][0]["changed"])
live = self.api("update", self.payload(preview_version="live")).json()["preview"]
self.assertFalse(live["url"])
self.assertIn("snapshots", live["message"])
def test_empty_new_draft_has_real_card_without_inventing_saved_title(self):
snap = self.svc.create("empty-draft", "", None, self.ctx)
response = self.api(
"update",
{"source": snap.source, "etag": snap.etag, "preview_view": "card"},
identity="empty-draft",
)
self.assertEqual(response.status_code, 200, response.text)
self.assertIsNone(response.json()["preview_error"])
self.assertIn("empty-draft", response.json()["preview"]["html"])
self.assertNotIn("title", parse((self.site / snap.path).read_text())[0])
def test_auth_csrf_and_validation_failures_have_visible_json_contract(self):
response = self.ui("check", csrf="bad")
self.assertEqual(response.status_code, 403)
self.assertTrue(response.json()["error"]["request_id"])
self.assertEqual(self.api("update", self.payload(preview_view="fake")).status_code, 422)
self.client.cookies.clear()
self.assertEqual(self.ui("delete").status_code, 401)
if __name__ == "__main__":
unittest.main()