Files
phelex 88ac95dd19 Integrate Antirion admin with FastAPI and htmx
Add the shared document API, constructor and expert editors, isolated preview, and fragment catalog metadata with typed block IDs.

Include design references, specification 001, QA scripts, project guidance, and cached Docker dependency installation. Leave example sites for a separate commit.
2026-11-12 21:55:36 +03:00

484 lines
30 KiB
Python

import json
import unittest
from unittest import mock
from helpers import SiteTestCase
from helpers_html import scrape_form
from test_auth import PASSWORD, Clock, make_cfg
from site_engine.parsing import frontmatter
from site_engine.services.auth import AuthService
from site_engine.storage.history import list_versions
from site_engine.web.admin.editor import EditorHandlers
from site_engine.web.admin.forms import FormData
ORIGIN = {"host": "admin.example", "origin": "https://admin.example"}
class EditorTestCase(SiteTestCase):
def setUp(self):
super().setUp()
self.auth = AuthService(make_cfg(), self.tmp / "state", clock=Clock())
self.dist = self.tmp / "dist"
self.ed = EditorHandlers(self.auth, self.site, self.dist)
self.cookie = self.auth.login("admin", PASSWORD, "1.1.1.1")
self.csrf = self.auth.csrf_token(self.auth.authenticate(self.cookie))
# запросы
def get(self, path, query=None, cookie="default"):
cookie = self.cookie if cookie == "default" else cookie
return self.ed.dispatch("GET", path, query or {}, FormData(), cookie, ORIGIN, "1.1.1.1")
def post(self, path, data=None, *, csrf=True, headers=None, cookie="default"):
cookie = self.cookie if cookie == "default" else cookie
form = data if isinstance(data, FormData) else FormData({k: v if isinstance(v, list) else [v] for k, v in (data or {}).items()})
if csrf and "csrf" not in form:
form._d["csrf"] = [self.csrf]
return self.ed.dispatch("POST", path, {}, form, cookie, headers or ORIGIN, "1.1.1.1")
def form(self, path, action):
result = self.get(path)
self.assertEqual(result.status, 200, result.body[:300])
return FormData(scrape_form(result.body, action))
def submit_form(self, path, action, **changes):
"""Как человек: открыть страницу, поправить поля, отправить форму."""
form = self.form(path, action)
for key, value in changes.items():
form._d[key.replace("__", ".")] = value if isinstance(value, list) else [value]
return self.post(action.removeprefix("/admin"), form)
# файлы
def meta(self, rel):
return frontmatter.parse((self.site / rel).read_text(encoding="utf-8"))
def block(self, rel, block_id, region="main"):
meta, _ = self.meta(rel)
return next(b for b in meta["regions"][region] if b["id"] == block_id)
def audit_text(self):
return (self.tmp / "state" / "audit.jsonl").read_text(encoding="utf-8")
class AccessTest(EditorTestCase):
def test_everything_requires_login(self):
for method, path in (("GET", "/pages"), ("GET", "/pages/index"), ("POST", "/pages/new"),
("GET", "/preview/pages/index"), ("GET", "/publish"), ("POST", "/publish")):
result = self.ed.dispatch(method, path, {}, FormData(), None, ORIGIN, "1.1.1.1")
self.assertEqual((result.status, result.headers["Location"]), (303, "/admin/login"), path)
def test_post_needs_csrf_and_same_origin_and_changes_nothing(self):
before = (self.site / "pages/privacy.md").read_bytes()
form = {"etag": "x", "title": "Хак", "status": "published", "body": "x"}
self.assertEqual(self.post("/pages/privacy/meta", form, csrf=False).status, 403)
bad = {"csrf": "wrong", **form}
self.assertEqual(self.post("/pages/privacy/meta", bad).status, 403)
evil = {"host": "admin.example", "origin": "https://evil.example"}
self.assertEqual(self.post("/pages/privacy/meta", form, headers=evil).status, 403)
self.assertEqual((self.site / "pages/privacy.md").read_bytes(), before)
def test_unknown_and_malicious_paths(self):
for path in ("/nope", "/pages/../../site", "/pages/a/../b", "/pages/UPPER", "/content/services/../x", "/pages//x"):
self.assertEqual(self.get(path).status, 404, path)
self.assertEqual(self.get("/pages/no-such-page").status, 404)
self.assertEqual(self.get("/pages/index/blocks/nope").status, 404)
self.assertEqual(self.get("/content/nope").status, 404)
self.assertEqual(self.get("/content/services/nope").status, 404)
def test_editor_screens_keep_security_headers_and_no_inline_code(self):
for path in ("/pages", "/pages/index", "/pages/index/blocks/b_hero", "/content", "/content/services",
"/content/services/bots", "/publish"):
result = self.get(path)
self.assertEqual(result.status, 200, path)
self.assertIn("frame-ancestors 'none'", result.headers["Content-Security-Policy"], path)
self.assertEqual(result.headers["Cache-Control"], "no-store")
self.assertNotRegex(result.body, r"<script(?![^>]*\bsrc=)")
for bad in ("style=", "<style", "onclick="):
self.assertNotIn(bad, result.body, f"{path}: {bad}")
def test_htmx_is_enabled_only_when_the_file_is_present(self):
body = self.get("/pages").body
self.assertIn("hx-boost='true'", body)
self.assertIn("src='/admin/static/htmx.min.js'", body)
with mock.patch("site_engine.web.admin.editor.htmx_available", return_value=False):
fallback = self.get("/pages").body
self.assertNotIn("<body data-skin='light' hx-boost='true'", fallback)
self.assertNotIn("src='/admin/static/htmx.min.js'", fallback)
def test_titles_are_escaped(self):
self.edit("pages/privacy.md", "title: Политика обработки персональных данных", "title: '<script>alert(1)</script>'")
for path in ("/pages", "/pages/privacy", "/"):
if path == "/":
continue
self.assertNotIn("<script>alert(1)</script>", self.get(path).body, path)
self.assertIn("&lt;script&gt;", self.get(path).body)
class PageTest(EditorTestCase):
def test_pages_list_and_editor_screen(self):
body = self.get("/pages").body
for text in ("Главная", "Контакты", "drafts/next", "Новая страница"):
self.assertIn(text, body)
body = self.get("/pages/index").body
for text in ("Регион «main»", "b_hero", "hero", "collection_list", "Закреплены в layout", "site_header",
"name='etag'", "/admin/preview/pages/index", "+ Добавить блок"):
self.assertIn(text, body)
self.assertIn("sandbox", body) # предпросмотр в изолированном фрейме
def test_save_meta_writes_file_history_and_audit_without_content(self):
before = (self.site / "pages/privacy.md").read_text(encoding="utf-8")
result = self.submit_form("/pages/privacy", "/admin/pages/privacy/meta", title="Новый заголовок политики")
self.assertEqual((result.status, result.headers["Location"]), (303, "/admin/pages/privacy?msg=saved"))
meta, body = self.meta("pages/privacy.md")
self.assertEqual(meta["title"], "Новый заголовок политики")
self.assertIn("Текст политики добавляет", body)
self.assertEqual(list_versions(self.site, "pages/privacy.md")[0].read_text(encoding="utf-8"), before)
audit = self.audit_text()
self.assertIn('"event": "page_save"', audit)
self.assertNotIn("Новый заголовок политики", audit)
def test_noop_save_keeps_page_semantically_identical(self):
for page_id in ("index", "contacts", "services/index", "privacy", "drafts/next"):
rel = f"pages/{page_id}.md"
before = self.meta(rel)
self.assertEqual(self.submit_form(f"/pages/{page_id}", f"/admin/pages/{page_id}/meta").status, 303, page_id)
after = self.meta(rel)
self.assertEqual(after[0], before[0], page_id)
self.assertEqual(after[1].strip(), before[1].strip(), page_id)
def test_body_and_seo_and_status_and_route(self):
self.submit_form("/pages/privacy", "/admin/pages/privacy/meta", body="Новый **текст**", seo_description="Описание",
status="published", route="/legal/privacy/")
meta, body = self.meta("pages/privacy.md")
self.assertEqual((meta["seo"], meta["route"], meta["status"]), ({"description": "Описание"}, "/legal/privacy/", "published"))
self.assertEqual(body.strip(), "Новый **текст**")
self.submit_form("/pages/privacy", "/admin/pages/privacy/meta", seo_description="", route="")
meta, _ = self.meta("pages/privacy.md")
self.assertNotIn("seo", meta)
self.assertNotIn("route", meta)
def test_stale_etag_gives_409_and_keeps_foreign_edit(self):
form = self.form("/pages/privacy", "/admin/pages/privacy/meta")
self.edit("pages/privacy.md", "Текст политики", "Правка в другом окне")
form._d["title"] = ["Моя правка"]
result = self.post("/pages/privacy/meta", form)
self.assertEqual(result.status, 409)
self.assertIn("Файл изменился", result.body)
meta, body = self.meta("pages/privacy.md")
self.assertIn("Правка в другом окне", body)
self.assertNotEqual(meta["title"], "Моя правка")
def test_save_level_validation_blocks_invalid_layout(self):
before = (self.site / "pages/privacy.md").read_bytes()
result = self.submit_form("/pages/privacy", "/admin/pages/privacy/meta", layout="no_such_layout")
self.assertEqual(result.status, 422)
self.assertIn("E_LAYOUT_MISSING", result.body)
self.assertEqual((self.site / "pages/privacy.md").read_bytes(), before)
def test_empty_title_is_rejected(self):
result = self.submit_form("/pages/privacy", "/admin/pages/privacy/meta", title="")
self.assertEqual(result.status, 422)
def test_create_page(self):
result = self.post("/pages/new", {"page_id": "services/new-one", "title": "Новая услуга", "layout": "default"})
self.assertEqual((result.status, result.headers["Location"]), (303, "/admin/pages/services/new-one?msg=created"))
meta, _ = self.meta("pages/services/new-one.md")
self.assertEqual((meta["status"], meta["title"], meta["regions"]), ("draft", "Новая услуга", {"main": []}))
self.assertEqual(self.get("/pages/services/new-one").status, 200)
def test_create_page_rejects_bad_input(self):
for page_id in ["../x", "UPPER", "a//b", "blocks", "a/meta/b", "index", "", "a b", "ключ", "/../x", "a/../b"]:
result = self.post("/pages/new", {"page_id": page_id, "title": "T"})
self.assertEqual(result.status, 422, page_id)
self.assertEqual(self.post("/pages/new", {"page_id": "contacts", "title": "T"}).status, 422)
self.assertEqual(self.post("/pages/new", {"page_id": "ok-page", "title": ""}).status, 422)
self.assertEqual(self.post("/pages/new", {"page_id": "ok-page2", "title": "T", "layout": "nope"}).status, 422)
self.assertFalse((self.site / "pages" / "ok-page2.md").exists())
self.assertFalse((self.tmp / "x.md").exists())
before = sorted(p.relative_to(self.site).as_posix() for p in (self.site / "pages").rglob("*.md"))
self.post("/pages/new", {"page_id": "x/", "title": "T"}) # слеши по краям нормализуются
after = sorted(p.relative_to(self.site).as_posix() for p in (self.site / "pages").rglob("*.md"))
self.assertEqual(set(after) - set(before), {"pages/x.md"})
class BlockTest(EditorTestCase):
def test_block_screen_shows_fields_from_the_fragment_schema(self):
body = self.get("/pages/index/blocks/b_hero").body
for text in ("name='p.title'", "Telegram-боты, AI-системы и автоматизации", "name='p.variant'",
"name='p.actions.0.target'", "value='contacts'", "name='p.actions.1.target'", # вторая строка пустая
"name='p.subtitle._bind'", "name='s.hidden'", "feature.demo"):
self.assertIn(text, body)
def test_binding_is_preserved_through_the_form(self):
body = self.get("/pages/contacts/blocks/b_text").body
self.assertIn("name='p.content._bind' value='page.body'", body)
self.assertEqual(self.submit_form("/pages/contacts/blocks/b_text", "/admin/pages/contacts/blocks/b_text").status, 303)
self.assertEqual(self.block("pages/contacts.md", "b_text")["props"], {"content": {"bind": "page.body"}})
def test_noop_block_save_is_lossless_for_every_block_of_the_example(self):
for page_id in ("index", "contacts", "services/index"):
meta, _ = self.meta(f"pages/{page_id}.md")
for block in meta["regions"]["main"]:
action = f"/admin/pages/{page_id}/blocks/{block['id']}"
before = self.block(f"pages/{page_id}.md", block["id"])
result = self.submit_form(f"/pages/{page_id}/blocks/{block['id']}", action)
self.assertEqual(result.status, 303, f"{page_id}/{block['id']}: {result.body[:400]}")
self.assertEqual(self.block(f"pages/{page_id}.md", block["id"]), before, f"{page_id}/{block['id']}")
def test_edit_text_add_list_row_and_keep_other_props(self):
action = "/admin/pages/index/blocks/b_hero"
self.submit_form("/pages/index/blocks/b_hero", action, p__title="Новый заголовок",
**{"p.actions.1.kind": "url", "p.actions.1.target": "https://t.me/acme_studio",
"p.actions.1.label": "Telegram", "p.actions.1.new_tab": "1"})
props = self.block("pages/index.md", "b_hero")["props"]
self.assertEqual(props["title"], "Новый заголовок")
self.assertEqual(props["variant"], "dark")
self.assertEqual(props["actions"][0], {"page": "contacts", "label": "Обсудить задачу"})
self.assertEqual(props["actions"][1], {"url": "https://t.me/acme_studio", "label": "Telegram", "target": "_blank"})
def test_delete_list_row(self):
action = "/admin/pages/index/blocks/b_steps"
self.submit_form("/pages/index/blocks/b_steps", action, **{"p.items.0._del": "1", "p.items.4._del": "1"})
titles = [i["title"] for i in self.block("pages/index.md", "b_steps")["props"]["items"]]
self.assertEqual(titles, ["Постановка", "Разработка", "Запуск"])
def test_query_edit(self):
action = "/admin/pages/index/blocks/b_dirs"
self.submit_form("/pages/index/blocks/b_dirs", action, **{"p.source.limit": "2", "p.source.sort": "-order"})
self.assertEqual(self.block("pages/index.md", "b_dirs")["props"]["source"],
{"query": {"collection": "services", "sort": "-order", "limit": 2}})
def test_invalid_field_values_give_422_and_do_not_touch_the_file(self):
before = (self.site / "pages/index.md").read_bytes()
result = self.submit_form("/pages/index/blocks/b_dirs", "/admin/pages/index/blocks/b_dirs", **{"p.source.limit": "abc"})
self.assertEqual(result.status, 422)
self.assertIn("limit", result.body)
result = self.submit_form("/pages/index/blocks/b_hero", "/admin/pages/index/blocks/b_hero", **{"p.subtitle._bind": "os.environ"})
self.assertEqual(result.status, 422)
result = self.submit_form("/pages/index/blocks/b_hero", "/admin/pages/index/blocks/b_hero", p__title="{{ 7*7 }}")
self.assertEqual(result.status, 422)
self.assertIn("E_TEMPLATE_IN_DATA", result.body)
result = self.submit_form("/pages/index/blocks/b_hero", "/admin/pages/index/blocks/b_hero", **{"s.anchor": "1 bad"})
self.assertEqual(result.status, 422)
self.assertEqual((self.site / "pages/index.md").read_bytes(), before)
def test_error_response_keeps_what_the_user_typed(self):
result = self.submit_form("/pages/index/blocks/b_hero", "/admin/pages/index/blocks/b_hero",
p__title="Мой текст", **{"s.anchor": "1 bad"})
self.assertEqual(result.status, 422)
self.assertIn("Мой текст", result.body)
def test_block_settings(self):
action = "/admin/pages/index/blocks/b_cta"
self.submit_form("/pages/index/blocks/b_cta", action, **{"s.hidden": "1", "s.anchor": "contact", "s.note": "временно",
"s.requires": ["feature.demo"]})
block = self.block("pages/index.md", "b_cta")
self.assertEqual((block["hidden"], block["anchor"], block["note"], block["requires"]), (True, "contact", "временно", ["feature.demo"]))
def test_add_block_to_region_then_fill_it_and_see_it_in_preview(self):
result = self.post("/pages/privacy/add", {"etag": self.form("/pages/privacy", "/admin/pages/privacy/add").first("etag"),
"region": "main", "fragment": "disclaimer"})
self.assertEqual(result.status, 303)
location = result.headers["Location"]
self.assertRegex(location, r"^/admin/pages/privacy/blocks/disclaimer_[a-z0-9]{5}\?msg=added$")
block_id = location.split("/blocks/")[1].split("?")[0]
path = f"/pages/privacy/blocks/{block_id}"
self.submit_form(path, f"/admin{path}", p__text="Важная **оговорка**")
self.assertIn("Важная <strong>оговорка</strong>", self.get("/preview/pages/privacy").body)
def test_add_block_to_slot(self):
self.post("/pages/privacy/add", {"etag": self.form("/pages/privacy", "/admin/pages/privacy/add").first("etag"),
"region": "main", "fragment": "section"})
section = self.meta("pages/privacy.md")[0]["regions"]["main"][-1]["id"]
page = self.get("/pages/privacy").body
self.assertIn("Слот «content»", page)
etag = scrape_form(page, "/admin/pages/privacy/add")["etag"][0]
result = self.post("/pages/privacy/add", {"etag": etag, "parent": section, "slot": "content", "fragment": "richtext"})
self.assertEqual(result.status, 303)
children = self.block("pages/privacy.md", section)["slots"]["content"]
self.assertEqual(children[0]["fragment"], "richtext")
def test_adding_to_fixed_region_or_unknown_fragment_is_refused(self):
before = (self.site / "pages/privacy.md").read_bytes()
etag = self.form("/pages/privacy", "/admin/pages/privacy/add").first("etag")
self.assertEqual(self.post("/pages/privacy/add", {"etag": etag, "region": "header", "fragment": "hero"}).status, 422)
self.assertEqual(self.post("/pages/privacy/add", {"etag": etag, "region": "main", "fragment": "no_such"}).status, 422)
self.assertEqual(self.post("/pages/privacy/add", {"etag": etag, "fragment": "hero"}).status, 422)
self.assertEqual(self.post("/pages/privacy/add", {"etag": etag, "parent": "ghost", "slot": "x", "fragment": "hero"}).status, 422)
self.assertEqual((self.site / "pages/privacy.md").read_bytes(), before)
def _act(self, block_id, action, **extra):
etag = scrape_form(self.get("/pages/index").body, f"/admin/pages/index/blocks/{block_id}/{action}")["etag"][0]
return self.post(f"/pages/index/blocks/{block_id}/{action}", {"etag": etag, **extra})
def test_move_up_and_down_and_edges(self):
ids = lambda: [b["id"] for b in self.meta("pages/index.md")[0]["regions"]["main"]]
self.assertEqual(ids(), ["b_hero", "b_dirs", "b_demo", "b_steps", "b_cta"])
self.assertEqual(self._act("b_cta", "move", dir="up").status, 303)
self.assertEqual(ids(), ["b_hero", "b_dirs", "b_demo", "b_cta", "b_steps"])
self._act("b_hero", "move", dir="down")
self.assertEqual(ids()[:2], ["b_dirs", "b_hero"])
before = (self.site / "pages/index.md").read_bytes()
result = self._act("b_dirs", "move", dir="up") # уже первый
self.assertEqual((result.status, (self.site / "pages/index.md").read_bytes()), (303, before))
def test_delete_and_toggle_hidden_change_the_preview(self):
self.assertIn("Расскажите о задаче", self.get("/preview/pages/index").body)
self._act("b_cta", "toggle")
self.assertTrue(self.block("pages/index.md", "b_cta")["hidden"])
self.assertNotIn("Расскажите о задаче", self.get("/preview/pages/index").body)
self._act("b_cta", "toggle")
self.assertNotIn("hidden", self.block("pages/index.md", "b_cta"))
self._act("b_cta", "delete")
self.assertEqual([b["id"] for b in self.meta("pages/index.md")[0]["regions"]["main"]],
["b_hero", "b_dirs", "b_demo", "b_steps"])
def test_block_actions_use_if_match(self):
etag = scrape_form(self.get("/pages/index").body, "/admin/pages/index/blocks/b_cta/delete")["etag"][0]
self.edit("pages/index.md", "Расскажите о задаче", "Расскажите подробнее")
result = self.post("/pages/index/blocks/b_cta/delete", {"etag": etag})
self.assertEqual(result.status, 409)
self.assertEqual(self.block("pages/index.md", "b_cta")["props"]["title"], "Расскажите подробнее")
def test_missing_required_prop_is_saved_but_reported_and_blocks_publish(self):
self.submit_form("/pages/index/blocks/b_hero", "/admin/pages/index/blocks/b_hero", p__title="")
self.assertNotIn("title", self.block("pages/index.md", "b_hero")["props"])
page = self.get("/pages/index").body
self.assertIn("E_REQUIRED", page) # проверка страницы показывает проблему
result = self.post("/publish")
self.assertEqual(result.status, 422)
self.assertIn("E_REQUIRED", result.body)
self.assertFalse((self.dist / "current").exists())
class PreviewTest(EditorTestCase):
def test_preview_pages_entries_and_drafts(self):
result = self.get("/preview/pages/index")
self.assertEqual(result.status, 200)
self.assertIn("Telegram-боты, AI-системы и автоматизации", result.body)
self.assertIn("frame-ancestors 'self'", result.headers["Content-Security-Policy"])
self.assertEqual(result.headers["X-Frame-Options"], "SAMEORIGIN")
self.assertIn("Черновик", self.get("/preview/pages/drafts/next").body)
self.assertIn("Автоматизация общения", self.get("/preview/entries/services/bots").body)
self.assertEqual(self.get("/preview/pages/nope").status, 404)
self.assertEqual(self.get("/preview/entries/services/nope").status, 404)
def test_preview_requires_login(self):
self.assertEqual(self.get("/preview/pages/index", cookie=None).status, 303)
class EntryTest(EditorTestCase):
def test_collections_and_entries_screens(self):
self.assertIn("Услуги", self.get("/content").body)
body = self.get("/content/services").body
for text in ("bots", "Telegram-боты", "/services/bots/", "Новая запись"):
self.assertIn(text, body)
body = self.get("/content/services/bots").body
for text in ("name='p.title'", "name='p.tagline'", "name='p.order'", "name='status'", "name='body'", "Предпросмотр"):
self.assertIn(text, body)
def test_noop_entry_save_is_lossless(self):
for slug in ("bots", "ai", "automation"):
rel = f"content/services/{slug}.md"
before = self.meta(rel)
action = f"/admin/content/services/{slug}"
self.assertEqual(self.submit_form(f"/content/services/{slug}", action).status, 303, slug)
after = self.meta(rel)
self.assertEqual(after[0], before[0], slug)
self.assertEqual(after[1].strip(), before[1].strip(), slug)
def test_edit_entry_fields_status_and_body(self):
self.submit_form("/content/services/bots", "/admin/content/services/bots", p__tagline="Новый слоган",
p__order="5", status="draft", body="Новый **текст**")
meta, body = self.meta("content/services/bots.md")
self.assertEqual((meta["tagline"], meta["order"], meta["status"]), ("Новый слоган", 5, "draft"))
self.assertEqual(body.strip(), "Новый **текст**")
# запись-черновик не попадает в запросы коллекции
self.assertNotIn("Новый слоган", self.get("/preview/pages/index").body)
def test_invalid_entry_values(self):
before = (self.site / "content/services/bots.md").read_bytes()
result = self.submit_form("/content/services/bots", "/admin/content/services/bots", p__order="abc")
self.assertEqual(result.status, 422)
self.assertIn("ожидается число", result.body)
self.assertEqual((self.site / "content/services/bots.md").read_bytes(), before)
def test_entry_stale_etag(self):
form = self.form("/content/services/bots", "/admin/content/services/bots")
self.edit("content/services/bots.md", "Автоматизация общения", "Чужая правка")
form._d["p.tagline"] = ["Моя правка"]
self.assertEqual(self.post("/content/services/bots", form).status, 409)
self.assertIn("Чужая правка", (self.site / "content/services/bots.md").read_text(encoding="utf-8"))
def test_create_entry(self):
result = self.post("/content/services/new", {"slug": "mobile"})
self.assertEqual((result.status, result.headers["Location"]), (303, "/admin/content/services/mobile?msg=created"))
self.assertEqual(self.meta("content/services/mobile.md")[0], {"status": "draft"})
for slug in ("bots", "UPPER", "new", "a b", "../x", ""):
self.assertEqual(self.post("/content/services/new", {"slug": slug}).status, 422, slug)
def test_unknown_key_blocks_published_entry_but_not_draft(self):
self.edit("content/services/ai.md", "order: 2", "order: 2\nlegacy: 1")
result = self.submit_form("/content/services/ai", "/admin/content/services/ai")
self.assertEqual(result.status, 422)
self.assertIn("не описано схемой", result.body)
self.edit("content/services/ai.md", "status: published", "status: draft")
self.assertEqual(self.submit_form("/content/services/ai", "/admin/content/services/ai").status, 303)
self.assertEqual(self.meta("content/services/ai.md")[0]["legacy"], 1) # ничего не потеряно
class PublishTest(EditorTestCase):
def test_publish_and_rollback(self):
self.assertIn("Релизов пока нет", self.get("/publish").body)
self.assertEqual(self.post("/publish").headers["Location"], "/admin/publish?msg=published")
first = (self.dist / "current").resolve().name
self.assertTrue((self.dist / first / "index.html").is_file())
# меняем страницу и публикуем снова (имя релиза содержит время: ждём другую секунду через правку содержимого)
self.submit_form("/pages/index/blocks/b_hero", "/admin/pages/index/blocks/b_hero", p__title="Заголовок v2")
with mock.patch("site_engine.build.pipeline.dt") as fake_dt:
import datetime as real
fake_dt.datetime.now.return_value = real.datetime(2030, 1, 1, tzinfo=real.timezone.utc)
fake_dt.timezone = real.timezone
self.post("/publish")
second = (self.dist / "current").resolve().name
self.assertNotEqual(first, second)
self.assertIn("Заголовок v2", (self.dist / second / "index.html").read_text(encoding="utf-8"))
page = self.get("/publish").body
self.assertIn("текущий", page)
self.assertEqual(self.post(f"/publish/rollback/{first}").headers["Location"], "/admin/publish?msg=rolled_back")
self.assertEqual((self.dist / "current").resolve().name, first)
self.assertEqual(self.post("/publish/rollback/20300101T000000-deadbeef").status, 404)
def test_failed_publish_keeps_live_site(self):
self.post("/publish")
live = (self.dist / "current").resolve().name
self.submit_form("/pages/index/blocks/b_hero", "/admin/pages/index/blocks/b_hero", p__title="")
self.assertEqual(self.post("/publish").status, 422)
self.assertEqual((self.dist / "current").resolve().name, live)
def test_audit_trail_of_editor_actions_has_no_content(self):
self.post("/pages/new", {"page_id": "audit-test", "title": "СекретныйЗаголовок"})
self.submit_form("/pages/audit-test", "/admin/pages/audit-test/meta", body="СекретныйТекст")
self.post("/publish")
audit = self.audit_text()
events = [json.loads(line)["event"] for line in audit.splitlines()]
for event in ("page_create", "page_save", "publish"):
self.assertIn(event, events)
for secret in ("СекретныйЗаголовок", "СекретныйТекст"):
self.assertNotIn(secret, audit)
class WriteScopeTest(EditorTestCase):
def test_editor_never_writes_outside_pages_and_content(self):
snapshot = {p: p.read_bytes() for p in self.site.rglob("*") if p.is_file() and not any(
part in (".engine",) for part in p.parts) and p.relative_to(self.site).parts[0] not in ("pages", "content")}
self.post("/pages/new", {"page_id": "scope-test", "title": "T"})
self.submit_form("/pages/index/blocks/b_hero", "/admin/pages/index/blocks/b_hero", p__title="X")
self.post("/content/services/new", {"slug": "scope"})
after = {p: p.read_bytes() for p in snapshot}
self.assertEqual(after, snapshot)
if __name__ == "__main__":
unittest.main()