Integrate Content Editor and Publication workflow
This commit is contained in:
@@ -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()
|
||||
@@ -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)
|
||||
Reference in New Issue
Block a user