Add page editing and publish
This commit is contained in:
@@ -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
|
||||
@@ -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()
|
||||
|
||||
@@ -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("<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("Важная <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()
|
||||
@@ -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()
|
||||
Reference in New Issue
Block a user