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")
for bad in ("'")
for path in ("/pages", "/pages/privacy", "/"):
if path == "/":
continue
self.assertNotIn("", self.get(path).body, path)
self.assertIn("<script>", 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/b_[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("Важная оговорка", 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()