Add page editing and publish

This commit is contained in:
Alexey Dudin
2026-11-09 15:45:11 +03:00
parent ecad6f183c
commit 53980a5558
25 changed files with 2402 additions and 33 deletions
+66
View File
@@ -0,0 +1,66 @@
"""Мини-«браузер» для тестов: вынимает значения формы из HTML так же, как это делает браузер."""
from html.parser import HTMLParser
class _FormScraper(HTMLParser):
def __init__(self, action: str):
super().__init__(convert_charrefs=True)
self.action, self.data = action, {}
self._in_target = False
self._select = None
self._select_options: list[tuple[str, bool]] = []
self._textarea = None
self._textarea_text: list[str] = []
self.found = False
def _put(self, name, value):
self.data.setdefault(name, []).append(value)
def handle_starttag(self, tag, attrs):
a = dict(attrs)
if tag == "form":
self._in_target = a.get("action") == self.action
self.found = self.found or self._in_target
return
if not self._in_target:
return
if tag == "input":
name, kind = a.get("name"), (a.get("type") or "text").lower()
if not name or kind in ("submit", "button", "file"):
return
if kind in ("checkbox", "radio"):
if "checked" in a:
self._put(name, a.get("value", "on"))
else:
self._put(name, a.get("value") or "")
elif tag == "select":
self._select, self._select_options = a.get("name"), []
elif tag == "option" and self._select is not None:
self._select_options.append((a.get("value", ""), "selected" in a))
elif tag == "textarea":
self._textarea, self._textarea_text = a.get("name"), []
def handle_data(self, data):
if self._textarea is not None:
self._textarea_text.append(data)
def handle_endtag(self, tag):
if tag == "form":
self._in_target = False
elif tag == "select" and self._select is not None:
chosen = next((v for v, sel in self._select_options if sel), self._select_options[0][0] if self._select_options else "")
if self._select_options:
self._put(self._select, chosen)
self._select = None
elif tag == "textarea" and self._textarea is not None:
self._put(self._textarea, "".join(self._textarea_text))
self._textarea = None
def scrape_form(html: str, action: str) -> dict[str, list[str]]:
scraper = _FormScraper(action)
scraper.feed(html)
if not scraper.found:
raise AssertionError(f"форма {action} не найдена в HTML")
return scraper.data
+55 -6
View File
@@ -14,6 +14,7 @@ from helpers import SiteTestCase
from test_auth import PASSWORD, Clock, make_cfg
from site_engine.services.auth import COOKIE_NAME, AuthService
from site_engine.web.admin.editor import EditorHandlers
from site_engine.web.admin.handlers import AdminHandlers
ORIGIN = {"host": "admin.example", "origin": "https://admin.example"}
@@ -50,11 +51,22 @@ class FakeRouter:
def post(self, path):
return self._register("POST", path)
def api_route(self, path, methods):
def deco(fn):
for method in methods:
self.routes[(method, self.prefix + path)] = fn
return fn
return deco
class FakeRequest:
def __init__(self, cookies=None, headers=None, ip="1.2.3.4"):
def __init__(self, cookies=None, headers=None, ip="1.2.3.4", method="GET", query=None, form=None):
self.cookies, self.headers = cookies or {}, headers or {}
self.client = types.SimpleNamespace(host=ip)
self.method, self.query_params, self._form = method, query or {}, form or []
async def form(self):
return types.SimpleNamespace(multi_items=lambda: list(self._form))
def fake_fastapi():
@@ -64,14 +76,25 @@ def fake_fastapi():
return mod
def fake_starlette():
pkg, conc = types.ModuleType("starlette"), types.ModuleType("starlette.concurrency")
async def run_in_threadpool(fn, *args):
return fn(*args)
conc.run_in_threadpool = run_in_threadpool
return {"starlette": pkg, "starlette.concurrency": conc}
class RoutesWiringTest(SiteTestCase):
def setUp(self):
super().setUp()
self.auth = AuthService(make_cfg(), self.tmp / "state", clock=Clock())
handlers = AdminHandlers(self.auth, self.site)
with mock.patch.dict(sys.modules, {"fastapi": fake_fastapi()}):
self.editor = EditorHandlers(self.auth, self.site, self.tmp / "dist")
with mock.patch.dict(sys.modules, {"fastapi": fake_fastapi(), **fake_starlette()}):
from site_engine.web.admin.routes import create_admin_router
self.router = create_admin_router(handlers)
self.router = create_admin_router(handlers, self.editor)
def route(self, method, path):
return self.router.routes[(method, path)]
@@ -79,8 +102,9 @@ class RoutesWiringTest(SiteTestCase):
def test_all_expected_routes_exist(self):
self.assertEqual(
sorted(self.router.routes),
[("GET", "/admin/"), ("GET", "/admin/login"), ("GET", "/admin/static/admin.css"),
("POST", "/admin/login"), ("POST", "/admin/logout")],
[("GET", "/admin/"), ("GET", "/admin/login"), ("GET", "/admin/static/{name}"),
("GET", "/admin/{rest:path}"), ("POST", "/admin/login"), ("POST", "/admin/logout"),
("POST", "/admin/{rest:path}")],
)
def test_login_flow_through_routes(self):
@@ -111,11 +135,36 @@ class RoutesWiringTest(SiteTestCase):
self.assertIn("Max-Age=0", out.headers.appended[0][1])
def test_static_and_login_page_routes(self):
css = self.route("GET", "/admin/static/admin.css")()
css = self.route("GET", "/admin/static/{name}")("admin.css")
self.assertTrue(css.media_type.startswith("text/css"))
self.assertEqual(self.route("GET", "/admin/static/{name}")("secret.txt").status_code, 404)
page = self.route("GET", "/admin/login")(FakeRequest())
self.assertEqual(page.status_code, 200)
def test_editor_catch_all_passes_method_path_query_form_and_cookie(self):
import asyncio
good = self.route("POST", "/admin/login")(FakeRequest(headers=ORIGIN), login="admin", password=PASSWORD)
value = good.headers.appended[0][1].split(";")[0].split("=", 1)[1]
cookies = {COOKIE_NAME: value}
get = self.route("GET", "/admin/{rest:path}")
response = asyncio.run(get(FakeRequest(cookies=cookies, query={"msg": "saved"}), rest="pages"))
self.assertEqual(response.status_code, 200)
self.assertIn("Новая страница", response.content)
self.assertIn("Сохранено", response.content) # query дошёл до обработчика
csrf = self.auth.csrf_token(self.auth.authenticate(value))
post = self.route("POST", "/admin/{rest:path}")
request = FakeRequest(cookies=cookies, headers=ORIGIN, method="POST",
form=[("csrf", csrf), ("page_id", "wired-page"), ("title", "Через адаптер")])
response = asyncio.run(post(request, rest="pages/new"))
self.assertEqual((response.status_code, response.headers["Location"]),
(303, "/admin/pages/wired-page?msg=created"))
self.assertTrue((self.site / "pages" / "wired-page.md").is_file())
nobody = asyncio.run(get(FakeRequest(), rest="pages"))
self.assertEqual((nobody.status_code, nobody.headers["Location"]), (303, "/admin/login"))
if __name__ == "__main__":
unittest.main()
+480
View File
@@ -0,0 +1,480 @@
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 ("<script", "style=", "<style", "onclick="):
self.assertNotIn(bad, result.body, f"{path}: {bad}")
def test_htmx_is_enabled_only_when_the_file_is_present(self):
self.assertNotIn("hx-boost", self.get("/pages").body)
with mock.patch("site_engine.web.admin.editor.htmx_available", return_value=True):
body = self.get("/pages").body
self.assertIn("hx-boost='true'", body)
self.assertIn("src='/admin/static/htmx.min.js'", body)
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/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("Важная <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()
+190
View File
@@ -0,0 +1,190 @@
import datetime as dt
import unittest
from site_engine.core import page_ops
from site_engine.core.models import FieldDef
from site_engine.web.admin.forms import UNSET, FormData, build_view, parse_field, parse_props
F = FieldDef
def form(**kw):
return FormData({k.replace("__", "."): ([v] if isinstance(v, str) else v) for k, v in kw.items()})
class ParseTest(unittest.TestCase):
def parse(self, fd, data, name="p.x"):
errors: list[str] = []
value = parse_field(fd, FormData(data), name, errors)
return value, errors
def test_empty_values_are_unset(self):
for fd in (F("x", "text"), F("x", "textarea"), F("x", "number"), F("x", "select", options=["a"]),
F("x", "boolean"), F("x", "list", of="text"), F("x", "link"), F("x", "query")):
self.assertIs(self.parse(fd, {})[0], UNSET, fd.type)
self.assertIs(self.parse(fd, {"p.x": [""]})[0], UNSET, fd.type)
def test_text_number_boolean_select(self):
self.assertEqual(self.parse(F("x", "text"), {"p.x": [" привет "]})[0], "привет")
self.assertEqual(self.parse(F("x", "number"), {"p.x": ["3"]})[0], 3)
self.assertEqual(self.parse(F("x", "number"), {"p.x": ["2,5"]})[0], 2.5)
self.assertEqual(self.parse(F("x", "boolean"), {"p.x": ["false"]})[0], False)
self.assertEqual(self.parse(F("x", "select", options=[2, 3, 4]), {"p.x": ["3"]})[0], 3) # тип варианта сохраняется
def test_errors_are_reported_not_raised(self):
value, errors = self.parse(F("x", "number", label="Число"), {"p.x": ["abc"]})
self.assertIs(value, UNSET)
self.assertIn("Число", errors[0])
self.assertTrue(self.parse(F("x", "select", options=["a"]), {"p.x": ["b"]})[1])
self.assertTrue(self.parse(F("x", "date"), {"p.x": ["31.12.2026"]})[1])
self.assertTrue(self.parse(F("x", "date"), {"p.x": ["2026-02-31"]})[1])
def test_date_becomes_date_object(self):
self.assertEqual(self.parse(F("x", "date"), {"p.x": ["2026-03-12"]})[0], dt.date(2026, 3, 12))
def test_textarea_normalizes_newlines(self):
self.assertEqual(self.parse(F("x", "markdown"), {"p.x": ["a\r\nb\r\n\r\n"]})[0], "a\nb")
def test_bind_wins_over_literal_and_is_validated(self):
value, _ = self.parse(F("x", "markdown"), {"p.x": ["текст"], "p.x._bind": ["page.body"]})
self.assertEqual(value, {"bind": "page.body"})
value, errors = self.parse(F("x", "text"), {"p.x._bind": ["os.environ"]})
self.assertIs(value, UNSET)
self.assertTrue(errors)
def test_link(self):
value, _ = self.parse(F("x", "link"), {"p.x.kind": ["page"], "p.x.target": ["contacts"], "p.x.label": ["Связь"]})
self.assertEqual(value, {"page": "contacts", "label": "Связь"})
value, _ = self.parse(F("x", "link"), {"p.x.kind": ["url"], "p.x.target": ["https://t.me/x"], "p.x.new_tab": ["1"]})
self.assertEqual(value, {"url": "https://t.me/x", "target": "_blank"})
self.assertTrue(self.parse(F("x", "link"), {"p.x.kind": ["file"], "p.x.target": ["a"]})[1])
def test_list_of_groups_skips_blank_and_deleted_rows(self):
fd = F("items", "list", fields=[F("title", "text", required=True), F("text", "markdown")])
data = {
"p.items.0.title": ["Один"], "p.items.0.text": ["a"],
"p.items.1.title": ["Удалить"], "p.items.1._del": ["1"],
"p.items.2.title": ["Три"],
"p.items.3.title": [""], "p.items.3.text": [""], # пустая строка «добавить»
}
value, errors = self.parse(fd, data, "p.items")
self.assertEqual(value, [{"title": "Один", "text": "a"}, {"title": "Три"}])
self.assertEqual(errors, [])
def test_list_of_primitives_and_links(self):
self.assertEqual(self.parse(F("t", "list", of="text"), {"p.t.0": ["a"], "p.t.1": [""], "p.t.2": ["b"]}, "p.t")[0], ["a", "b"])
value, _ = self.parse(F("a", "list", of="link"),
{"p.a.0.kind": ["page"], "p.a.0.target": ["contacts"], "p.a.1.target": [""]}, "p.a")
self.assertEqual(value, [{"page": "contacts"}])
def test_list_row_bind(self):
fd = F("meta", "list", of="text")
value, _ = self.parse(fd, {"p.meta.0._bind": ["entry.tagline"]}, "p.meta")
self.assertEqual(value, [{"bind": "entry.tagline"}])
def test_query(self):
data = {"p.s.collection": ["services"], "p.s.limit": ["3"], "p.s.sort": ["-date"], "p.s.where": ["featured: true"]}
value, errors = self.parse(F("s", "query"), data, "p.s")
self.assertEqual(value, {"query": {"collection": "services", "where": {"featured": True}, "sort": "-date", "limit": 3}})
self.assertEqual(errors, [])
self.assertTrue(self.parse(F("s", "query"), {"p.s.collection": ["a"], "p.s.limit": ["0"]}, "p.s")[1])
self.assertTrue(self.parse(F("s", "query"), {"p.s.collection": ["a"], "p.s.where": ["x: {contains: 1}"]}, "p.s")[1])
def test_refs_and_multiselect(self):
self.assertEqual(self.parse(F("r", "refs", to="s"), {"p.r": ["a, b c"]}, "p.r")[0], ["a", "b", "c"])
self.assertEqual(self.parse(F("m", "multiselect", options=["a", "b"]), {"p.m": ["a", "b"]}, "p.m")[0], ["a", "b"])
def test_parse_props_omits_unset(self):
errors: list[str] = []
props = parse_props([F("a", "text"), F("b", "text")], form(p__a="x"), "p", errors)
self.assertEqual(props, {"a": "x"})
class ViewTest(unittest.TestCase):
CTX = {"collections": ["services"], "assets": ["assets/hero.svg"], "entries": {"services": ["bots"]}, "pages": ["contacts"]}
def test_parse_of_view_roundtrip(self):
# значения → форма → значения: ничего не теряется
fields = [
F("title", "text"), F("variant", "select", options=["light", "dark"]),
F("actions", "list", of="link"),
F("items", "list", fields=[F("title", "text"), F("text", "markdown")]),
F("src", "query"), F("flag", "boolean"),
]
props = {
"title": "Привет", "variant": "dark", "flag": False,
"actions": [{"page": "contacts", "label": "Связь"}, {"url": "https://t.me/x", "target": "_blank"}],
"items": [{"title": "Один", "text": "x"}, {"title": "Два"}],
"src": {"query": {"collection": "services", "limit": 3}},
}
views = {f.key: build_view(f, props.get(f.key), f"p.{f.key}", self.CTX) for f in fields}
self.assertEqual(views["title"]["value"], "Привет")
self.assertEqual([r["blank"] for r in views["items"]["rows"]], [False, False, True])
self.assertEqual(views["actions"]["rows"][0]["item"]["target"], "contacts")
self.assertEqual(views["src"]["limit"], "3")
def test_bind_is_exposed_separately(self):
view = build_view(F("content", "markdown"), {"bind": "page.body"}, "p.content", self.CTX)
self.assertEqual((view["bind"], view["value"]), ("page.body", ""))
def test_select_marks_current_option(self):
view = build_view(F("v", "select", options=["a", "b"]), "b", "p.v", self.CTX)
self.assertEqual([o["selected"] for o in view["options"]], [False, False, True])
class PageOpsTest(unittest.TestCase):
def meta(self):
return {"title": "T", "regions": {"main": [
{"id": "b_a", "fragment": "hero"},
{"id": "b_s", "fragment": "section", "slots": {"content": [
{"id": "b_x", "fragment": "richtext"}, {"id": "b_y", "fragment": "faq"}]}},
{"id": "b_c", "fragment": "cta_banner"},
]}}
def test_find_in_slots(self):
siblings, index, block = page_ops.find_block(self.meta(), "b_y")
self.assertEqual((index, block["fragment"]), (1, "faq"))
self.assertIsNone(page_ops.find_block(self.meta(), "nope"))
def test_move_within_own_list(self):
m = self.meta()
self.assertTrue(page_ops.move_block(m, "b_y", "up"))
self.assertEqual([b["id"] for b in m["regions"]["main"][1]["slots"]["content"]], ["b_y", "b_x"])
self.assertFalse(page_ops.move_block(m, "b_y", "up")) # уже первый
self.assertFalse(page_ops.move_block(m, "b_c", "down")) # уже последний
self.assertFalse(page_ops.move_block(m, "b_c", "sideways"))
def test_delete_nested_and_unknown(self):
m = self.meta()
page_ops.delete_block(m, "b_x")
self.assertEqual([b["id"] for b in m["regions"]["main"][1]["slots"]["content"]], ["b_y"])
with self.assertRaises(KeyError):
page_ops.delete_block(m, "b_x")
def test_add_to_region_and_slot_with_unique_ids(self):
m = self.meta()
a = page_ops.add_block(m, "image", region="main")
b = page_ops.add_block(m, "disclaimer", parent="b_s", slot="content")
c = page_ops.add_block(m, "image", region="new_region")
self.assertEqual(len({a, b, c, "b_a", "b_s", "b_x", "b_y", "b_c"}), 8)
self.assertEqual(m["regions"]["main"][-1]["id"], a)
self.assertEqual(m["regions"]["main"][1]["slots"]["content"][-1]["id"], b)
self.assertIn("new_region", m["regions"])
with self.assertRaises(KeyError):
page_ops.add_block(m, "image", parent="missing", slot="content")
def test_hidden_and_field_replace_keep_unknown_props(self):
m = self.meta()
block = page_ops.find_block(m, "b_a")[2]
block["props"] = {"title": "Старый", "legacy": 1}
page_ops.replace_block_fields(block, props={"title": "Новый"}, manifest_keys={"title"}, hidden=True,
anchor="top", note=None, requires=["feature.demo"])
self.assertEqual(block["props"], {"title": "Новый", "legacy": 1})
self.assertEqual((block["hidden"], block["anchor"], block["requires"]), (True, "top", ["feature.demo"]))
page_ops.replace_block_fields(block, props={}, manifest_keys={"title", "legacy"}, hidden=False,
anchor=None, note=None, requires=[])
self.assertEqual(block, {"id": "b_a", "fragment": "hero"})
if __name__ == "__main__":
unittest.main()