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()
+397
View File
@@ -0,0 +1,397 @@
"""Publication contract: real candidates, private provenance, 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, hash_tree
from site_engine.services.auth import hash_password
from site_engine.services.documents import EditorContext
from site_engine.services.publication import PublicationService
from site_engine.web.app import create_app
ROOT = Path(__file__).resolve().parents[1]
class PublicationTests(unittest.TestCase):
@classmethod
def setUpClass(cls):
cls.password = "publication test password"
cls.password_hash = hash_password(cls.password, n=2**10)
def setUp(self):
tmp = tempfile.TemporaryDirectory(prefix="publication-test-")
self.addCleanup(tmp.cleanup)
self.work = Path(tmp.name)
self.site, self.dist, self.state = (self.work / n for n in ("site", "dist", "state"))
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.state),
"SITE_ADMIN_LOGIN": "admin",
"SITE_ADMIN_PASSWORD_HASH": self.password_hash,
"SITE_SECRET_KEY": "publication-test-secret-" * 4,
"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 = PublicationService(self.site, self.dist, self.state, self.app.state.auth.audit)
def api(self, method="GET", path="", payload=None):
return self.client.request(
method,
"/admin/api/v1/publication" + path,
json=payload,
headers={"Authorization": "Bearer test"},
)
def ui(self, operation, payload=None, csrf=None):
return self.client.post(
"/admin/publication/" + operation,
data={
"csrf": self.csrf if csrf is None else csrf,
"payload": json.dumps(payload or {}),
},
headers={"Origin": "http://testserver", "Accept": "application/json"},
)
def build(self):
r = self.api("POST", "/build")
self.assertEqual(r.status_code, 200, r.text)
return r.json()
def activate(self, candidate, base=None, comment="Проверенный релиз"):
return self.api(
"POST", "/activate", {"id": candidate["id"], "expected_live": base, "comment": comment}
)
def edit(self, rel="pages/index.md", old="Студия автоматизации", new="Новая студия"):
path = self.site / rel
source = path.read_text()
if old not in source:
source += "\n" + new
else:
source = source.replace(old, new)
path.write_text(source)
def test_original_screen_and_api_only_adapter_static_and_csrf(self):
r = self.client.get("/admin/publish")
self.assertEqual(r.status_code, 200, r.text)
self.assertIn("data-publication-root", r.text)
for name in (
"publication.css",
"publication-adapter.css",
"publication.js",
"publication-icons.json",
):
self.assertEqual(self.client.get("/admin/static/" + name).status_code, 200, name)
before = self.app.state.api_calls
self.assertEqual(self.ui("validate").status_code, 200)
self.assertEqual(self.app.state.api_calls - before, 1)
self.assertEqual(self.ui("build", csrf="bad").status_code, 403)
self.assertEqual(self.client.get("/admin/publication/build").status_code, 405)
self.assertEqual(self.client.get("/admin/publication/unknown").status_code, 404)
def test_build_never_activates_and_private_snapshots_never_in_dist(self):
initial = hash_tree(self.site)
c = self.build()
self.assertIsNone(self.svc.current())
self.assertEqual(hash_tree(self.site), initial)
self.assertTrue((self.dist / c["id"] / "index.html").is_file())
self.assertFalse((self.dist / c["id"] / "pages").exists())
self.assertFalse((self.dist / c["id"] / "content").exists())
self.assertNotIn("sources", self.svc.manifest(c["id"]))
self.assertIn("content/services/automation.md", self.svc.provenance(c["id"])["sources"])
state = self.api().json()
self.assertTrue(state["candidate"]["fresh"])
self.assertTrue(state["history"][0]["candidate"])
self.assertEqual(state["builds"][0]["status"], "ready")
def test_activate_exact_existing_output_and_no_rebuild(self):
c = self.build()
output = hash_tree(self.dist / c["id"])
with patch(
"site_engine.services.publication.build_site",
side_effect=AssertionError("must not rebuild"),
):
r = self.activate(c)
self.assertEqual(r.status_code, 200, r.text)
self.assertEqual(self.svc.current(), c["id"])
self.assertEqual(hash_tree(self.dist / c["id"]), output)
state = self.api().json()
self.assertIsNone(state["candidate"])
self.assertFalse(state["changes"])
self.assertEqual(state["history"][0]["comment"], "Проверенный релиз")
def test_stale_source_and_replaced_candidate_cannot_activate_or_rollback(self):
c = self.build()
self.edit()
self.assertFalse(self.api().json()["candidate"]["fresh"])
self.assertEqual(self.activate(c).status_code, 409)
self.assertEqual(
self.api("POST", "/rollback", {"id": c["id"], "expected_live": None}).status_code, 422
)
newer = self.build()
self.assertNotEqual(c["id"], newer["id"])
self.assertEqual(self.activate(c).status_code, 409)
self.assertIsNone(self.svc.current())
def test_engine_resources_and_output_tampering_invalidate_candidate(self):
c = self.build()
with patch(
"site_engine.services.publication.render_fingerprint", return_value="changed-engine"
):
self.assertFalse(self.api().json()["candidate"]["fresh"])
self.assertEqual(self.activate(c).status_code, 409)
(self.dist / c["id"] / "index.html").write_text("tampered")
self.assertEqual(self.activate(c).status_code, 422)
self.assertIsNone(self.svc.current())
def test_live_cas_and_rollback_do_not_touch_workspace(self):
a = self.build()
self.assertEqual(self.activate(a).status_code, 200)
self.edit()
b = self.build()
self.assertEqual(self.activate(b, base="20000101T000000-12345678").status_code, 409)
self.assertEqual(self.activate(b, base=a["id"]).status_code, 200)
before = hash_tree(self.site)
r = self.api("POST", "/rollback", {"id": a["id"], "expected_live": b["id"]})
self.assertEqual(r.status_code, 200, r.text)
self.assertEqual(self.svc.current(), a["id"])
self.assertEqual(hash_tree(self.site), before)
self.assertEqual(
self.api("POST", "/rollback", {"id": b["id"], "expected_live": b["id"]}).status_code,
409,
)
self.assertTrue(self.api().json()["changes"])
def test_comparison_actual_text_added_deleted_assets_and_old_release_unknown(self):
a = self.build()
self.activate(a)
self.edit()
(self.site / "assets/new.txt").write_text("new asset")
(self.site / "assets/hero.webp").unlink()
state = self.api().json()
rows = {x["path"]: x for x in state["changes"]}
self.assertEqual(rows["pages/index.md"]["kind"], "modified")
self.assertEqual(rows["assets/new.txt"]["kind"], "new")
self.assertEqual(rows["assets/hero.webp"]["kind"], "deleted")
diff = self.api(path="/compare?path=pages/index.md").json()
self.assertNotEqual(diff["before"]["source"], diff["after"]["source"])
(self.state / "publication/releases" / f"{a['id']}.json").unlink()
state = self.api().json()
self.assertFalse(state["comparison_available"])
self.assertTrue(all(x["kind"] == "unknown" for x in state["changes"]))
self.assertIsNone(self.api(path="/compare?path=pages/index.md").json()["before"])
def test_candidate_diff_is_immutable_after_workspace_change(self):
a = self.build()
self.activate(a)
self.edit()
self.build()
before = self.api(path="/candidate-diff").json()
(self.site / "assets/not-in-candidate.txt").write_text("later")
after = self.api(path="/candidate-diff").json()
self.assertEqual(before, after)
self.assertNotIn("assets/not-in-candidate.txt", json.dumps(after))
def test_validation_and_failed_strict_render_preserve_live_and_previous_candidate(self):
a = self.build()
self.activate(a)
self.edit()
b = self.build()
with (
patch(
"site_engine.core.render.Renderer.render",
side_effect=RuntimeError("real render probe"),
),
self.assertLogs("uvicorn.error", level="ERROR") as captured,
):
r = self.api("POST", "/build")
self.assertEqual(r.status_code, 500)
self.assertIn("real render probe", "\n".join(captured.output))
self.assertTrue(r.json()["error"]["request_id"])
state = self.api().json()
self.assertEqual(state["current"], a["id"])
self.assertEqual(state["candidate"]["id"], b["id"])
self.assertEqual(state["builds"][0]["status"], "failed")
self.edit(
"pages/index.md", "status: published", "status: published\nlayout: missing-layout"
)
r = self.api("POST", "/validate")
self.assertEqual(r.status_code, 200, r.text)
self.assertGreater(r.json()["errors"], 0)
self.assertEqual(self.api("POST", "/build").status_code, 422)
self.assertEqual(self.svc.current(), a["id"])
def test_passive_snapshot_is_real_build_with_assets_and_no_site_scripts(self):
c = self.build()
self.edit()
r = self.api("POST", "/preview", {"id": c["id"], "route": "/"})
self.assertEqual(r.status_code, 200, r.text)
preview = r.json()
page = self.client.get(preview["url"])
self.assertEqual(page.status_code, 200)
self.assertNotIn("<script", page.text)
self.assertIn("script-src 'none'", page.headers["content-security-policy"])
self.assertIn("site.", page.text)
self.assertEqual(
self.api("POST", "/preview", {"id": c["id"], "route": "/missing/"}).status_code, 404
)
self.assertEqual(self.client.get(preview["url"].split("?")[0]).status_code, 403)
with patch.dict(
os.environ,
{
"SITE_ADMIN_ORIGIN": "http://127.0.0.1:9100",
"SITE_PREVIEW_ORIGIN": "http://127.0.0.1:9101",
},
):
from site_engine.services.preview import PreviewConfig, PreviewStore
from site_engine.web.preview_app import snapshot_response
store = PreviewStore(self.state, b"secret", PreviewConfig.from_env())
p = self.svc.preview(c["id"], "/", store, self.principal)
from urllib.parse import parse_qs, urlsplit
token = parse_qs(urlsplit(p["url"]).query)["token"][0]
response = snapshot_response(store, p["snapshot"], token)
self.assertNotIn(b"<script", response.body)
self.assertIn("script-src 'none'", response.headers["content-security-policy"])
def test_commit_audit_failure_reports_actual_switched_release(self):
c = self.build()
with (
patch.object(
self.app.state.auth.audit, "write", side_effect=OSError("audit unavailable")
),
self.assertLogs("uvicorn.error", level="ERROR"),
):
r = self.activate(c)
self.assertEqual(r.status_code, 500)
self.assertEqual(r.json()["error"]["committed_build"], c["id"])
self.assertEqual(self.svc.current(), c["id"])
def test_auth_path_traversal_and_symlinks_are_rejected(self):
c = self.build()
for path in ("../.env", ".env", "/etc/passwd"):
self.assertIn(self.api(path="/document-history?path=" + path).status_code, (403, 422))
self.assertEqual(
self.api("POST", "/preview", {"id": "../bad", "route": "/"}).status_code, 422
)
link = self.site / "assets/outside.txt"
link.symlink_to("/etc/passwd")
self.assertEqual(self.api("POST", "/build").status_code, 403)
link.unlink()
self.app.state.api_credentials.pop("test")
self.assertEqual(self.api().status_code, 401)
self.app.state.auth.logout(self.principal)
self.assertEqual(self.ui("build").status_code, 401)
self.assertTrue((self.dist / c["id"]).exists())
def test_cli_compatibility_without_private_provenance(self):
a = build_site(self.site, self.dist)
state = self.api().json()
self.assertEqual(state["current"], a.build_id)
self.assertFalse(state["comparison_available"])
self.assertIsNone(state["history"][0]["author"])
self.edit()
b = self.build()
self.assertEqual(self.activate(b, base=a.build_id).status_code, 200)
self.assertEqual(
self.api("POST", "/rollback", {"id": a.build_id, "expected_live": b["id"]}).status_code,
200,
)
def test_release_details_show_actual_changed_outputs_and_real_document_history(self):
from site_engine.services.pages import PageService
a = self.build()
self.activate(a)
svc = PageService(self.site, self.app.state.auth.audit)
snap = svc.get("index")
svc.save_source(
"index",
snap.source.replace("Автоматизируем бизнес", "Обновлённый бизнес"),
snap.etag,
self.ctx,
)
history = self.api(path="/document-history?path=pages/index.md").json()
self.assertEqual(len(history["versions"]), 1)
b = self.build()
self.activate(b, base=a["id"])
details = self.api(path="/release?id=" + a["id"])
self.assertEqual(details.status_code, 200, details.text)
self.assertEqual(details.json()["base"], b["id"])
self.assertIn("index.html", [x["path"] for x in details.json()["changes"]])
self.assertEqual(self.api(path="/release?id=../bad").status_code, 404)
def test_built_candidate_audit_failure_is_explicit_and_does_not_activate(self):
with (
patch.object(
self.app.state.auth.audit, "write", side_effect=OSError("audit unavailable")
),
self.assertLogs("uvicorn.error", level="ERROR"),
):
response = self.api("POST", "/build")
self.assertEqual(response.status_code, 500)
detail = response.json()["error"]
self.assertEqual(detail["code"], "candidate_after_build")
self.assertTrue((self.dist / detail["committed_build"]).is_dir())
self.assertIsNone(self.svc.current())
self.assertEqual(self.api().json()["candidate"]["id"], detail["committed_build"])
def test_expired_session_read_is_json_and_requires_new_login(self):
self.app.state.auth.logout(self.principal)
response = self.client.get(
"/admin/publication/state", headers={"Accept": "application/json"}
)
self.assertEqual(response.status_code, 401)
self.assertEqual(response.json()["error"]["code"], "session_expired")
def test_starting_shell_allows_only_configured_preview_origin(self):
from site_engine.services.preview import PreviewConfig
initial = self.client.get("/admin/pages")
self.assertIn("frame-src 'self';", initial.headers["content-security-policy"])
config = PreviewConfig("http://127.0.0.1:9100", "http://127.0.0.1:9101")
with patch.object(self.app.state.previews, "config", config):
for path in (
"/admin/",
"/admin/pages",
"/admin/pages/index",
"/admin/content/services/bots",
"/admin/theme",
"/admin/publish",
):
response = self.client.get(path)
self.assertEqual(response.status_code, 200, path)
policy = response.headers["content-security-policy"]
directives = dict(
part.strip().split(" ", 1) for part in policy.split(";") if part.strip()
)
self.assertEqual(directives["frame-src"], "'self' " + config.preview, path)
self.assertEqual(directives["script-src"], "'self'", path)
self.assertEqual(directives["frame-ancestors"], "'none'", path)