Files
flexly-cms/tests/test_fragment_catalog_ui.py
phelex 0d171915d7 Add Site Studio themes and Theme Manager
Support categorized fragments, theme presets, block widths, and server-backed theme editing with onboarding and preview.

Include Site Studio, design sources, specification and verification reports; remove the legacy studio-site example.
2026-11-13 14:04:49 +03:00

412 lines
22 KiB
Python

"""Stage 1: real login -> HTML adapter -> API, with an independent file fixture.
Run: PYTHONPATH=src python -m unittest discover -s tests -p test_fragment_catalog_ui.py -v
The browser acceptance script reuses only the disposable fixture helpers below.
"""
from __future__ import annotations
import os
import tempfile
import unittest
from html.parser import HTMLParser
from pathlib import Path
from unittest.mock import patch
from fastapi.testclient import TestClient
from site_engine.build.pipeline import build_site
from site_engine.core.registry import load_site
from site_engine.parsing import frontmatter
from site_engine.parsing.yamlio import dump_yaml
from site_engine.services.auth import hash_password
from site_engine.web.app import create_app
LABELS = {
"content": "Контент", "data": "Данные", "forms": "Формы",
"marketing": "Маркетинг", "media": "Медиа", "system": "Системные", "misc": "Прочее",
}
ALIASES = {
"Контент": "content", "Компоновка": "content", "Данные": "data",
"Первый экран": "marketing", "Конверсия": "marketing", "Медиа": "media", "Каркас": "system",
"Формы": "forms", "Маркетинг": "marketing", "Системные": "system", "Прочее": "misc",
}
PREVIEW = {"title": "Sidecar heading", "note": "Inline retained", "count": 0, "enabled": False}
PAGE_ID = "catalog-check"
NESTED_DIR = "fragments/marketing/deeper/qa_nested"
def write(site: Path, relative: str, text: str) -> None:
path = site / relative
path.parent.mkdir(parents=True, exist_ok=True)
path.write_text(text, encoding="utf-8")
def seed_catalog(site: Path) -> dict[str, tuple[str, str]]:
"""Add local nested + legacy-flat fragments, aliases and restricted targets."""
expected = {}
for index, (raw, group) in enumerate([*[(x, x) for x in LABELS], *ALIASES.items()]):
fid = f"qa_category_{index}"
write(site, f"fragments/{fid}/fragment.yaml", dump_yaml({
"id": fid, "name": f"Category probe {index}", "category": raw,
"description": f"Category description {index}", "fields": [], "slots": {},
}))
write(site, f"fragments/{fid}/template.html.j2", "<p>Category probe</p>")
expected[fid] = (raw, group)
write(site, f"{NESTED_DIR}/fragment.yaml", dump_yaml({
"id": "qa_nested", "name": "Nested catalog card", "description": "Sidecar defaults probe",
# The directory wins, while API category must keep its computed raw value.
"category": "Данные", "version": 1,
"fields": [
{"key": "title", "type": "text", "required": True},
{"key": "note", "type": "text"},
{"key": "count", "type": "number"},
{"key": "enabled", "type": "boolean"},
{"key": "fallback", "type": "text", "default": "Schema fallback"},
],
"slots": {},
"preview": {"title": "Inline heading", "note": PREVIEW["note"], "count": 7, "enabled": True},
}))
write(site, f"{NESTED_DIR}/preview.yaml", dump_yaml({
"name": "Preview metadata must not rename the fragment",
"props": {"title": PREVIEW["title"], "count": 0, "enabled": False},
}))
write(site, f"{NESTED_DIR}/template.html.j2", """<section class="qa-nested"><h2>{{ props.title }}</h2><p>{{ props.note }}</p><span>{{ props.count }}</span></section>""")
write(site, f"{NESTED_DIR}/style.css", ".qa-nested { border-top: 7px solid rgb(17, 83, 149); }\n")
write(site, "fragments/qa_legacy/fragment.yaml", dump_yaml({
"id": "qa_legacy", "name": "Legacy flat card", "category": "Контент",
"description": "Flat fragment stays usable", "fields": [], "slots": {},
}))
write(site, "fragments/qa_legacy/template.html.j2", '<p class="qa-legacy">Legacy flat content</p>')
write(site, "fragments/qa_legacy/style.css", ".qa-legacy { padding-top: 11px; }\n")
write(site, "fragments/content/qa_container/fragment.yaml", dump_yaml({
"id": "qa_container", "name": "Restricted container", "category": "system",
"fields": [], "slots": {"body": {"allow": ["qa_nested"]}},
}))
write(site, "fragments/content/qa_container/template.html.j2", '<section class="qa-container">{{ slots.body }}</section>')
write(site, "layouts/qa_catalog/layout.yaml", dump_yaml({
"id": "qa_catalog", "name": "Catalog checks", "regions": [
{"id": "main", "allow": ["*"]}, {"id": "restricted", "allow": ["qa_legacy"]},
],
}))
write(site, "layouts/qa_catalog/layout.html.j2", """<!doctype html><html lang="ru"><head><meta charset="utf-8">{{ seo_head() }}{{ assets_head() }}</head><body><main>{{ region('main') }}</main><aside>{{ region('restricted') }}</aside>{{ assets_body() }}</body></html>""")
write(site, f"pages/{PAGE_ID}.md", frontmatter.dumps({
"schema": 1, "title": "Catalog stage 1", "status": "published", "layout": "qa_catalog",
"regions": {"main": [
{"id": "qa_container_block", "fragment": "qa_container", "slots": {"body": []}},
{"id": "qa_legacy_block", "fragment": "qa_legacy"},
]},
}, ""))
expected.update({"qa_nested": ("marketing", "marketing"), "qa_legacy": ("Контент", "content"), "qa_container": ("content", "content")})
return expected
def minimal_site(site: Path) -> dict[str, tuple[str, str]]:
write(site, "site.yaml", dump_yaml({
"schema": 1, "name": "Catalog integration fixture", "base_url": "https://catalog.example",
"default_locale": "ru", "locales": ["ru"], "defaults": {"layout": "qa_catalog"},
}))
return seed_catalog(site)
def environment(site: Path, work: Path, password_hash: str) -> dict[str, str]:
return {
"SITE_ROOT": str(site), "SITE_DIST": str(work / "dist"),
"SITE_STATE_DIR": str(work / "state"), "SITE_ADMIN_LOGIN": "admin",
"SITE_ADMIN_PASSWORD_HASH": password_hash, "SITE_SECRET_KEY": "fragments-002-temporary-secret-" * 2,
"SITE_COOKIE_SECURE": "0", "SITE_ADMIN_ORIGIN": "", "SITE_PREVIEW_ORIGIN": "",
}
class CatalogHTML(HTMLParser):
"""Inspect server-rendered controls without a browser or HTML dependencies."""
def __init__(self, html: str):
super().__init__()
self.items, self.categories, self.forms = {}, {}, {}
self._item = self._category = self._form = None
self._badge_depth = 0
self._textarea = None
self.feed(html)
def handle_starttag(self, tag, attrs):
attrs = dict(attrs)
if tag == "button" and "data-fragment" in attrs:
self._item = attrs["data-fragment"]
self.items[self._item] = {"attrs": attrs, "text": "", "badge": ""}
if self._item and "data-fragment-category" in attrs:
self._badge_depth = 1
elif self._badge_depth:
self._badge_depth += 1
if tag == "button" and "data-catalog-category" in attrs:
self._category = attrs["data-catalog-category"]
self.categories[self._category] = ""
if tag == "form" and ("data-catalog-form" in attrs or attrs.get("id") == "buffer-form"):
self._form = attrs.get("data-catalog-form", "buffer-form")
self.forms[self._form] = {"attrs": attrs, "fields": {}}
if self._form and tag in ("input", "textarea") and "name" in attrs:
self.forms[self._form]["fields"][attrs["name"]] = attrs.get("value", "")
if tag == "textarea":
self._textarea = attrs["name"]
if self._form and tag == "select":
self._select = attrs.get("name")
if self._form and tag == "option" and "selected" in attrs:
self.forms[self._form]["fields"][self._select] = attrs.get("value", "")
def handle_data(self, data):
if self._item:
self.items[self._item]["text"] += data
if self._badge_depth:
self.items[self._item]["badge"] += data
if self._category is not None:
self.categories[self._category] += data
if self._form and self._textarea:
self.forms[self._form]["fields"][self._textarea] += data
def handle_endtag(self, tag):
if self._badge_depth:
self._badge_depth -= 1
if tag == "button":
self._item = self._category = None
if tag == "form":
self._form = None
if tag == "textarea":
self._textarea = None
class FragmentCatalogUITests(unittest.TestCase):
@classmethod
def setUpClass(cls):
cls.password = "temporary catalog password"
cls.password_hash = hash_password(cls.password, n=2**10)
def setUp(self):
temp = tempfile.TemporaryDirectory(prefix="catalog-002-test-")
self.addCleanup(temp.cleanup)
self.work = Path(temp.name)
self.site = self.work / "site"
self.expected = minimal_site(self.site)
env = patch.dict(os.environ, environment(self.site, self.work, self.password_hash))
env.start()
self.addCleanup(env.stop)
self.app = create_app()
self.client = TestClient(self.app)
self.addCleanup(self.client.close)
self.assertEqual(self.client.get("/admin/login").status_code, 200)
response = self.client.post("/admin/login", data={"login": "admin", "password": self.password},
headers={"Origin": "http://testserver"}, follow_redirects=False)
self.assertEqual(response.status_code, 303, response.text)
self.assertIn("se_session", self.client.cookies)
self.snapshots = []
# Observe the actual internal HTTP responses, preserving ASGI auth and serialization.
original = self.app.state.api_calls
import httpx
send = httpx.AsyncClient.send
async def observe(client, request, *args, **kwargs):
response = await send(client, request, *args, **kwargs)
if request.url.path == f"/admin/api/v1/pages/{PAGE_ID}/source" and response.status_code == 200:
self.snapshots.append(response.json())
return response
probe = patch.object(httpx.AsyncClient, "send", observe)
probe.start()
self.addCleanup(probe.stop)
self.response = self.client.get(f"/admin/pages/{PAGE_ID}")
self.assertEqual(self.response.status_code, 200, self.response.text[:2000])
self.assertGreater(self.app.state.api_calls, original)
self.assertTrue(self.snapshots, "HTML must obtain the document over the internal API")
self.html = CatalogHTML(self.response.text)
self.source = self.snapshots[-1]
def post(self, operation: str, fields: dict):
defaults = self.html.forms["buffer-form"]["fields"]
return self.client.post(f"/admin/editor/pages/{PAGE_ID}/{operation}", data={
**{key: defaults[key] for key in ("csrf", "etag", "revision", "source")}, **fields,
}, headers={"Origin": "http://testserver", "HX-Request": "true"})
def test_raw_api_categories_and_localized_catalog_aliases(self):
fragments = self.source["schema"]["fragments"]
self.assertEqual({k: v.strip() for k, v in self.html.categories.items() if k}, LABELS)
for fid, (raw, group) in self.expected.items():
with self.subTest(fragment=fid):
self.assertEqual(fragments[fid]["category"], raw)
item = self.html.items[fid]
self.assertEqual(item["attrs"]["data-category"], group)
self.assertEqual(item["badge"].strip(), LABELS[group])
self.assertEqual(item["attrs"]["title"], fid)
self.assertIn(fragments[fid]["name"], item["text"])
self.assertIn(fragments[fid]["description"], item["text"])
for fid, (name, description) in {
"collection_list": ("Список коллекций", "Карточки, получаемые из collection"),
"section": ("Текстовая секция", "Заголовок и содержимое секции"),
"richtext": ("Markdown body", "Выводит Markdown из файла страницы"),
"card_grid": ("Карточки", "Сетка преимуществ"),
}.items():
with self.subTest(builtin=fid):
self.assertEqual(fragments[fid]["name"], name)
self.assertEqual(fragments[fid]["description"], description)
self.assertIn(name, self.html.items[fid]["text"])
self.assertIn(description, self.html.items[fid]["text"])
self.assertEqual(self.app.state.api_credentials, {})
self.assertEqual(self.client.get(f"/admin/api/v1/pages/{PAGE_ID}/source").status_code, 401)
def test_sidecar_overrides_per_key_and_catalog_form_preserves_contract(self):
fragment = self.source["schema"]["fragments"]["qa_nested"]
self.assertEqual(fragment["preview"], PREVIEW)
self.assertEqual(fragment["name"], "Nested catalog card")
form = self.html.forms["qa_nested"]
self.assertEqual(form["attrs"]["method"], "post")
self.assertEqual(form["attrs"]["action"], f"/admin/editor/pages/{PAGE_ID}/transform")
for key, value in {"title": PREVIEW["title"], "note": PREVIEW["note"], "count": "0", "enabled": "false", "fallback": "Schema fallback"}.items():
self.assertEqual(form["fields"]["p." + key], value, key)
# Builtins still use inline previews; adding a sidecar facility must preserve them.
inline = self.source["schema"]["fragments"]["hero"]["preview"]
self.assertTrue(inline["title"])
self.assertEqual(self.html.forms["hero"]["fields"]["p.title"], inline["title"])
for field in ("csrf", "etag", "source", "revision", "fragment", "region", "parent", "slot"):
self.assertIn(field, form["fields"])
def test_add_to_slot_buffers_then_save_and_reopen_nested_and_flat(self):
path = self.site / f"pages/{PAGE_ID}.md"
original = path.read_bytes()
fields = self.html.forms["qa_nested"]["fields"]
response = self.post("transform", {**fields, "region": "", "parent": "qa_container_block", "slot": "body"})
self.assertEqual(response.status_code, 200, response.text[:2000])
transformed = CatalogHTML(response.text)
source = transformed.forms["qa_nested"]["fields"]["source"]
self.assertEqual(path.read_bytes(), original)
self.assertFalse((self.site / ".engine/history").exists())
meta, _ = frontmatter.parse(source)
blocks = meta["regions"]["main"]
added = blocks[0]["slots"]["body"][-1]
self.assertEqual(added["fragment"], "qa_nested")
self.assertRegex(added["id"], r"^qa_nested_[a-z0-9]{5}$")
self.assertEqual({key: added["props"][key] for key in PREVIEW}, PREVIEW)
self.assertEqual(blocks[1]["fragment"], "qa_legacy")
saved = self.post("save", {"source": source})
self.assertEqual(saved.status_code, 200, saved.text[:2000])
self.assertEqual(path.read_text(), source)
self.assertTrue(list((self.site / ".engine/history").rglob("*.md")))
reopened = self.client.get(f"/admin/pages/{PAGE_ID}")
self.assertEqual(reopened.status_code, 200)
self.assertEqual(self.snapshots[-1]["source"], source)
self.assertEqual(self.snapshots[-1]["model"]["meta"]["regions"]["main"], blocks)
def test_slot_and_region_restrictions_reject_forged_add_without_writing(self):
original = (self.site / f"pages/{PAGE_ID}.md").read_bytes()
for fid, target in [
("qa_legacy", {"region": "", "parent": "qa_container_block", "slot": "body"}),
("qa_nested", {"region": "restricted", "parent": "", "slot": ""}),
]:
with self.subTest(fragment=fid, target=target):
response = self.post("transform", {**self.html.forms[fid]["fields"], **target})
self.assertEqual(response.status_code, 422, response.text[:2000])
self.assertEqual((self.site / f"pages/{PAGE_ID}.md").read_bytes(), original)
def test_invalid_sidecar_reaches_workspace_and_publish_preserves_current(self):
csrf = self.html.forms["buffer-form"]["fields"]["csrf"]
headers = {"Origin": "http://testserver"}
published = self.client.post("/admin/publish", data={"csrf": csrf}, headers=headers)
self.assertEqual(published.status_code, 200, published.text[:2000])
dist = self.work / "dist"
current = dist / "current"
self.assertTrue(current.is_symlink())
target = current.readlink()
public = (current / PAGE_ID / "index.html").read_bytes()
manifest = (current / "manifest.json").read_bytes()
releases = {path.name for path in dist.iterdir()}
document = (self.site / f"pages/{PAGE_ID}.md").read_bytes()
preview_path = f"{NESTED_DIR}/preview.yaml"
token = "catalog-test-credential"
self.app.state.api_credentials[token] = (self.client.cookies["se_session"], "testclient")
self.addCleanup(self.app.state.api_credentials.pop, token, None)
api_headers = {"Authorization": "Bearer " + token}
for invalid, code, issue_path in (
("props: [unclosed\n", "E_YAML", preview_path),
("props: []\n", "E_FRAGMENT_PREVIEW", preview_path + ":props"),
):
with self.subTest(code=code):
write(self.site, preview_path, invalid)
workspace = self.client.get("/admin/api/v1/site", headers=api_headers)
self.assertEqual(workspace.status_code, 200, workspace.text)
matching = [issue for issue in workspace.json()["issues"]
if issue["code"] == code and issue["path"] == issue_path]
self.assertTrue(matching, workspace.json()["issues"])
issue = matching[0]
self.assertEqual(issue["severity"], "error")
self.assertTrue(issue["message"])
rejected = self.client.post("/admin/api/v1/publish", headers=api_headers)
self.assertEqual(rejected.status_code, 422, rejected.text)
error = rejected.json()["error"]
self.assertEqual(error["code"], "validation")
self.assertEqual(error["request_id"], rejected.headers["x-request-id"])
self.assertIn(issue, error["issues"])
visible = self.client.post("/admin/publish", data={"csrf": csrf}, headers=headers)
self.assertEqual(visible.status_code, 422, visible.text[:2000])
self.assertEqual(visible.headers["x-error-code"], "validation")
self.assertIn("role='alert'", visible.text)
self.assertIn("Проблемы сборки", visible.text)
self.assertIn(code, visible.text)
self.assertIn(issue_path, visible.text)
self.assertIn(visible.headers["x-request-id"], visible.text)
self.assertEqual(current.readlink(), target)
self.assertEqual((current / PAGE_ID / "index.html").read_bytes(), public)
self.assertEqual((current / "manifest.json").read_bytes(), manifest)
self.assertEqual({path.name for path in dist.iterdir()}, releases)
self.assertEqual((self.site / f"pages/{PAGE_ID}.md").read_bytes(), document)
def test_custom_category_text_is_escaped_in_catalog_markup(self):
category = '<img src=x onerror="window.__category_injected=1"> & "special"'
write(self.site, "fragments/qa_legacy/fragment.yaml", dump_yaml({
"id": "qa_legacy", "name": "Legacy flat card", "category": category,
"description": "Flat fragment stays usable", "fields": [], "slots": {},
}))
response = self.client.get(f"/admin/pages/{PAGE_ID}")
self.assertEqual(response.status_code, 200, response.text[:2000])
catalog = CatalogHTML(response.text)
self.assertEqual(self.snapshots[-1]["schema"]["fragments"]["qa_legacy"]["category"], category)
item = catalog.items["qa_legacy"]
self.assertEqual(item["attrs"]["data-category-source"], category)
self.assertEqual(item["attrs"]["data-category"], category)
self.assertEqual(item["badge"].strip(), category)
self.assertEqual(catalog.categories[category].strip(), category)
self.assertIn("&lt;img", response.text)
self.assertNotIn("<img src=x", response.text)
def test_nested_and_flat_styles_enter_public_bundle_with_categorized_builtins(self):
reg = load_site(self.site)
self.assertEqual(reg.report.errors, [])
self.assertEqual(sum(fragment.builtin for fragment in reg.fragments.values()), 17)
for fragment in reg.fragments.values():
if fragment.builtin:
with self.subTest(fragment=fragment.id):
self.assertIn(fragment.category, LABELS)
self.assertEqual(fragment.dir.parent.name, fragment.category)
self.assertTrue(fragment.style)
path = self.site / f"pages/{PAGE_ID}.md"
meta, body = frontmatter.parse(path.read_text())
meta["regions"]["main"][0]["slots"]["body"] = [{"id": "qa_nested_saved", "fragment": "qa_nested", "props": PREVIEW}]
path.write_text(frontmatter.dumps(meta, body), encoding="utf-8")
build_site(self.site, self.work / "dist")
current = self.work / "dist/current"
public = (current / PAGE_ID / "index.html").read_text()
css_paths = list((current / "assets").glob("site.*.css"))
self.assertEqual(len(css_paths), 1)
self.assertIn("/assets/" + css_paths[0].name, public)
css = css_paths[0].read_text()
for fid in ("qa_nested", "qa_legacy"):
self.assertIn(f"/* fragment: {fid} */", css)
self.assertIn(reg.fragments[fid].style.strip(), css)
self.assertIn(PREVIEW["title"], public)
self.assertIn("Legacy flat content", public)
self.assertNotIn("data-preview-", public)
self.assertNotIn("data-fragment-category", public)
if __name__ == "__main__":
unittest.main()