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.
This commit is contained in:
2026-11-13 14:04:49 +03:00
parent 231490bb7c
commit 0d171915d7
408 changed files with 11812 additions and 550 deletions
+232
View File
@@ -0,0 +1,232 @@
"""Width contract through parsing, document operations and real HTTP boundaries."""
import os
import tempfile
import unittest
from dataclasses import asdict
from html.parser import HTMLParser
from pathlib import Path
from unittest.mock import patch
from fastapi.testclient import TestClient
from test_fragment_catalog_ui import environment
from theme_fixture import seed, write
from site_engine.build.pipeline import build_site, make_views
from site_engine.core.block_layout import BlockLayout, default_layout
from site_engine.core.layout_marks import apply_layout
from site_engine.core.models import parse_block
from site_engine.core.page_ops import find_block
from site_engine.core.registry import load_site
from site_engine.core.render import Renderer
from site_engine.core.routes import build_route_table
from site_engine.core.validate import validate_workspace
from site_engine.errors import Report
from site_engine.parsing.yamlio import dump_yaml
from site_engine.services.auth import hash_password
from site_engine.services.documents import DocumentService, EditorContext
class Elements(HTMLParser):
def __init__(self, html):
super().__init__()
self.items = []
self.feed(html)
def handle_starttag(self, tag, attrs):
self.items.append((tag, dict(attrs)))
class BlockLayoutTest(unittest.TestCase):
def test_strict_shapes_modes_and_unknown_keys(self):
for raw in (None, False, [], "full", {"width": "boxed"}, {"section_width": []},
{"section_width": "wide"}, {"content_width": 1080}, {"content_width": None}):
with self.subTest(layout=raw):
report = Report()
block = parse_block({"id": "test_block", "fragment": "hero", "layout": raw}, "test", report)
self.assertIsNone(block)
self.assertIn("E_BLOCK_LAYOUT", report.codes())
self.assertTrue(all(".layout" in i.path for i in report.errors))
def test_all_modes_defaults_and_explicit_inheritance(self):
for fragment in ("hero", "cta_banner", "site_header", "site_footer", "richtext", "columns"):
block = parse_block({"id": "test_block", "fragment": fragment}, "test", Report())
self.assertIsNone(block.layout)
expected = "full" if fragment in ("hero", "cta_banner", "site_header", "site_footer") else "inherit"
self.assertEqual(default_layout(fragment).section_width, expected)
for section in ("inherit", "boxed", "fluid", "full"):
for content in ("inherit", "boxed", "fluid", "full"):
report = Report()
block = parse_block({"id": "test_block", "fragment": "hero", "layout": {"section_width": section, "content_width": content}}, "test", report)
self.assertTrue(report.ok)
effective = block.layout.resolve("fluid")
self.assertEqual(effective.section_width, "fluid" if section == "inherit" else section)
self.assertEqual(effective.content_width, "fluid" if content == "inherit" else content)
def test_layout_marks_do_not_change_roots_or_overwrite_nested_block_containers(self):
child = apply_layout('<section class="child"><div class="container"><img src="x"></div></section>', BlockLayout("boxed", "fluid"))
source = '<header class="sticky"><div class="f-container">' + child + '</div></header><aside>Second root</aside>'
html = apply_layout(source, BlockLayout("full", "boxed"))
self.assertEqual(html.count("<header"), 1)
self.assertEqual(html.count("<section"), 1)
self.assertEqual(html.count("<div"), 2)
elements = Elements(html).items
self.assertEqual(elements[0][1]["data-section-width"], "full")
self.assertEqual(elements[1][1]["data-engine-container"], "boxed")
self.assertEqual(elements[2][1]["data-section-width"], "boxed")
self.assertEqual(elements[3][1]["data-engine-container"], "fluid")
self.assertEqual(elements[-1][1]["data-section-width"], "full")
class LayoutIntegrationTest(unittest.TestCase):
@classmethod
def setUpClass(cls):
cls.password = "temporary layout password"
cls.password_hash = hash_password(cls.password, n=2**10)
def setUp(self):
temp = tempfile.TemporaryDirectory()
self.addCleanup(temp.cleanup)
self.work = Path(temp.name)
self.site, self.out = self.work / "site", self.work / "dist"
seed(self.site)
env = patch.dict(os.environ, environment(self.site, self.work, self.password_hash))
env.start()
self.addCleanup(env.stop)
from site_engine.web.app import create_app
self.app = create_app()
self.client = TestClient(self.app)
self.addCleanup(self.client.close)
self.cookie = self.app.state.auth.login("admin", self.password, "testclient")
self.client.cookies.set("se_session", self.cookie)
self.principal = self.app.state.auth.authenticate(self.cookie)
self.csrf = self.app.state.auth.csrf_token(self.principal)
self.app.state.api_credentials["test-layout"] = (self.cookie, "testclient")
self.headers = {"Authorization": "Bearer test-layout"}
self.service = DocumentService(self.site)
def api(self, method, path, data=None):
return self.client.request(method, "/admin/api/v1" + path, json=data, headers=self.headers)
def test_page_display_fixed_entry_and_slots_share_renderer_contract(self):
reg = load_site(self.site)
self.assertTrue(validate_workspace(reg).ok)
table = build_route_table(reg, Report())
renderer = Renderer(reg, table, Report(), preview_mode=True)
views = make_views(reg, table, Report())
attrs = []
for view in views:
html, _ = renderer.render(view)
attrs.extend(a for _, a in Elements(html).items if a.get("data-preview-id"))
by_id = {a["data-preview-id"]: a for a in attrs}
for identity, section, content, scope in (
("hero_home", "full", "boxed", "page"), ("section_outer", "fluid", "full", "page"),
("richtext_child", "boxed", "fluid", "page"), ("header_fixed", "full", "boxed", "layout"),
("display_text", "full", "boxed", "display"), ("entry_text", "fluid", "full", "entry"),
):
self.assertEqual(by_id[identity]["data-section-width"], section)
self.assertEqual(by_id[identity]["data-content-width"], content)
self.assertEqual(by_id[identity]["data-preview-scope"], scope)
def test_snapshot_has_typed_layout_for_fixed_display_and_raw_page(self):
snap = self.service.get("index")
self.assertEqual(snap.schema["container"]["gutter"]["mobile"], 16)
self.assertEqual(snap.model["meta"]["regions"]["main"][0]["layout"]["content_width"], "boxed")
# Fixed layout omitted in YAML is still absent/default, not explicit inherit.
self.assertIsNone(snap.schema["regions"]["header"]["fixed"][0]["layout"])
entry = DocumentService(self.site, collection="articles")
entry.kind = "entry"
self.assertEqual(entry.get("first").schema["display"]["main"][0]["layout"], {"section_width": "full", "content_width": "boxed"})
def test_transform_props_duplicate_move_save_and_reopen_preserve_layout(self):
snap = self.service.get("index")
original = (self.site / "pages/index.md").read_bytes()
layout = {"section_width": "boxed", "content_width": "full"}
for action in (
{"type": "block", "block_id": "hero_home", "values": {"layout": layout}},
{"type": "block", "block_id": "hero_home", "values": {"props": {"title": "Новое название"}}},
{"type": "duplicate", "block_id": "hero_home"},
{"type": "move", "block_id": "hero_home", "after": "section_outer"},
{"type": "toggle", "block_id": "hero_home"},
{"type": "add", "fragment": "richtext", "region": "main"},
):
snap = self.service.transform_buffer("index", snap.source, snap.etag, action)
self.assertTrue(snap.report.ok, snap.report.issues)
self.assertEqual(find_block(snap.model["meta"], "hero_home")[2]["layout"], layout)
self.assertEqual((self.site / "pages/index.md").read_bytes(), original)
copies = [b for b in snap.model["meta"]["regions"]["main"] if b["fragment"] == "hero"]
self.assertEqual(len(copies), 2)
self.assertTrue(all(b["layout"] == layout for b in copies))
self.service.save_source("index", snap.source, snap.etag, EditorContext(self.principal))
self.assertEqual(find_block(self.service.get("index").model["meta"], "hero_home")[2]["layout"], layout)
def test_api_transform_rejects_bad_width_and_keeps_explicit_null_fields(self):
snap = self.api("GET", "/pages/index/source").json()
data = {k: snap[k] for k in ("source", "etag", "revision")}
data["action"] = {"type": "block", "block_id": "hero_home", "values": {"layout": {"section_width": "full", "content_width": "fluid"}, "anchor": "hero-anchor"}}
response = self.api("POST", "/pages/index/transform", data)
self.assertEqual(response.status_code, 200, response.text)
data["source"] = response.json()["source"]
data["action"]["values"] = {"anchor": None}
response = self.api("POST", "/pages/index/transform", data)
self.assertEqual(response.status_code, 200, response.text)
block = response.json()["model"]["meta"]["regions"]["main"][0]
self.assertIsNone(block["anchor"])
self.assertEqual(block["layout"]["content_width"], "fluid")
for layout in (None, [], {"section_width": "bad"}, {"content_width": False}, {"width": "full"}):
data["action"]["values"] = {"layout": layout}
response = self.api("POST", "/pages/index/transform", data)
self.assertEqual(response.status_code, 422, response.text)
self.assertTrue(response.json()["error"]["request_id"])
def test_expert_and_core_refuse_invalid_layout_without_mutating_source(self):
snap = self.service.get("index")
changed = self.service.transform_buffer("index", snap.source, snap.etag, {"type": "block", "block_id": "richtext_child", "values": {"layout": {"content_width": "bad"}}})
self.assertIn("E_BLOCK_LAYOUT", changed.report.codes())
self.assertEqual(changed.source, snap.source)
invalid = snap.source.replace("section_width: full", "section_width: wide", 1)
checked = self.service.validate_source("index", invalid, snap.etag)
self.assertIsNone(checked.model)
self.assertIn("E_BLOCK_LAYOUT", checked.report.codes())
def test_html_inspector_posts_through_api_without_saving(self):
snap = self.service.get("index")
response = self.client.get("/admin/pages/index")
self.assertEqual(response.status_code, 200, response.text)
self.assertIn("Макет блока · ширина", response.text)
self.assertIn("data-block-width='section_width'", response.text)
data = {"csrf": self.csrf, "etag": snap.etag, "revision": 1, "source": snap.source,
"selection": "hero_home", "block_id": "hero_home", "mode": "constructor",
"operation": "block", "p.title": "Новое название",
"block_layout.section_width": "fluid", "block_layout.content_width": "full"}
response = self.client.post("/admin/editor/pages/index/transform", data=data,
headers={"Origin": "http://testserver", "HX-Request": "true"})
self.assertEqual(response.status_code, 200, response.text)
self.assertIn("section_width: fluid", response.text)
self.assertEqual((self.site / "pages/index.md").read_text(), snap.source)
data["block_layout.section_width"] = "bad"
response = self.client.post("/admin/editor/pages/index/transform", data=data,
headers={"Origin": "http://testserver", "HX-Request": "true"})
self.assertEqual(response.status_code, 422, response.text)
self.assertEqual((self.site / "pages/index.md").read_text(), snap.source)
def test_theme_error_reaches_api_html_preview_and_publish_without_switching_live(self):
live = build_site(self.site, self.out)
snap = self.service.get("index")
write(self.site, "theme.yaml", dump_yaml({"schema": 1, "preset": "unknown", "preset_version": 1, "overrides": {}}))
response = self.api("POST", "/pages/index/preview", {k: asdict(snap)[k] for k in ("source", "etag", "revision")})
self.assertEqual(response.status_code, 422, response.text)
self.assertIn("E_THEME_VALUE", response.text)
response = self.api("POST", "/publish")
self.assertEqual(response.status_code, 422)
self.assertIn("E_THEME_VALUE", response.text)
response = self.client.post("/admin/publish", data={"csrf": self.csrf},
headers={"Origin": "http://testserver", "HX-Request": "true"})
self.assertEqual(response.status_code, 422, response.text)
self.assertIn("E_THEME_VALUE", response.text)
self.assertEqual(os.readlink(self.out / "current"), live.build_id)
def test_openapi_exposes_layout_enum(self):
schema = self.app.openapi()["components"]["schemas"]["BlockLayoutDTO"]
self.assertEqual(schema["properties"]["section_width"]["enum"], ["inherit", "boxed", "fluid", "full"])
self.assertFalse(schema["additionalProperties"])
+379
View File
@@ -0,0 +1,379 @@
"""Core catalog contracts, independent of the editable example sites."""
import unittest
from pathlib import Path
from tempfile import TemporaryDirectory
from unittest.mock import patch
from site_engine.core.models import parse_fragment
from site_engine.core.registry import BUILTIN_DIR, load_site
from site_engine.errors import Report
from site_engine.parsing.yamlio import dump_yaml
class FragmentCatalogTest(unittest.TestCase):
def setUp(self):
temporary = TemporaryDirectory()
self.addCleanup(temporary.cleanup)
self.root = Path(temporary.name)
self.site = self.root / "site"
self.builtin = self.root / "builtin"
self.write(self.site / "site.yaml", "name: Catalog test\n")
def write(self, path, text):
path.parent.mkdir(parents=True, exist_ok=True)
path.write_text(text, encoding="utf-8")
def fragment(self, folder, fid="sample", *, builtin=False, **values):
base = self.builtin if builtin else self.site
directory = base / "fragments" / folder
manifest = directory / "fragment.yaml"
self.write(manifest, dump_yaml({"id": fid, "name": "Catalog name", **values}))
self.write(directory / "template.html.j2", "<section>{{ props.title }}</section>")
return manifest
def sidecar(self, manifest, raw):
self.write(manifest.with_name("preview.yaml"), dump_yaml(raw))
def load(self):
return load_site(self.site, builtin_dir=self.builtin)
def assert_issues(self, reg, expected):
self.assertEqual([(i.code, i.path) for i in reg.report.issues], expected)
def test_flat_discovery_keeps_yaml_category_and_misc(self):
self.fragment("folder", "flat", category="Legacy category")
self.fragment("no_category", "uncategorized")
self.fragment("", "root_fragment")
reg = self.load()
self.assertTrue(reg.report.ok, reg.report.issues)
self.assertEqual(
{fid: f.category for fid, f in reg.fragments.items()},
{"flat": "Legacy category", "uncategorized": "misc", "root_fragment": "misc"},
)
def test_categorized_discovery_uses_first_arbitrary_folder(self):
self.fragment("Произвольная категория/card", "one", category="Ignored")
self.fragment("Second category/another", "two")
reg = self.load()
self.assertTrue(reg.report.ok, reg.report.issues)
self.assertEqual(reg.fragments["one"].category, "Произвольная категория")
self.assertEqual(reg.fragments["two"].category, "Second category")
def test_mixed_and_deeper_discovery_keeps_manifest_ids_and_assets(self):
self.fragment("flat", "legacy", category="Old")
manifest = self.fragment("marketing/subgroup/deeper/folder", "different_id")
self.write(manifest.with_name("style.css"), ".sample { color: red; }")
self.write(manifest.with_name("script.js"), "// sample script")
self.fragment("marketing/other", "other")
reg = self.load()
self.assertTrue(reg.report.ok, reg.report.issues)
self.assertEqual(set(reg.fragments), {"legacy", "different_id", "other"})
fragment = reg.fragments["different_id"]
self.assertEqual(fragment.category, "marketing")
self.assertEqual(fragment.dir, manifest.parent)
self.assertEqual(fragment.style, ".sample { color: red; }")
self.assertEqual(fragment.script, "// sample script")
self.assertIn("props.title", fragment.template)
self.assertFalse(fragment.builtin)
def test_builtin_and_site_have_same_category_rules(self):
self.fragment("flat", "builtin_flat", builtin=True, category="Original")
self.fragment("New/deeper/folder", "builtin_nested", builtin=True, category="Old")
self.fragment("New/site", "site_nested", category="Old")
reg = self.load()
self.assertTrue(reg.report.ok, reg.report.issues)
self.assertEqual(reg.fragments["builtin_flat"].category, "Original")
self.assertEqual(reg.fragments["builtin_nested"].category, "New")
self.assertEqual(reg.fragments["site_nested"].category, "New")
self.assertTrue(reg.fragments["builtin_nested"].builtin)
self.assertFalse(reg.fragments["site_nested"].builtin)
def test_duplicate_ids_across_directories_are_errors(self):
first = self.fragment("A/one", "duplicate")
self.fragment("B/deeper/two", "duplicate")
reg = self.load()
self.assertEqual(reg.fragments["duplicate"].dir, first.parent)
self.assert_issues(reg, [("E_FRAGMENT_DUP", "fragments/B/deeper/two/fragment.yaml")])
def test_site_cannot_shadow_builtin_id_in_another_directory(self):
first = self.fragment("Builtin/deeper/folder", "duplicate", builtin=True)
self.fragment("Site/another", "duplicate")
reg = self.load()
self.assertEqual(reg.fragments["duplicate"].dir, first.parent)
self.assertTrue(reg.fragments["duplicate"].builtin)
self.assert_issues(reg, [("E_FRAGMENT_DUP", "fragments/Site/another/fragment.yaml")])
def test_duplicate_ids_between_builtin_directories_are_errors(self):
self.fragment("A/one", "duplicate", builtin=True)
self.fragment("B/two", "duplicate", builtin=True)
self.assert_issues(self.load(), [("E_FRAGMENT_DUP", "builtin/B/two/fragment.yaml")])
def test_only_manifests_are_discovered_but_malformed_ones_are_reported(self):
self.write(self.site / "fragments/unused/preview.yaml", "props: {}\n")
self.write(self.site / "fragments/unused/template.html.j2", "<p>Unused</p>")
malformed = {
"empty": "",
"null": "null\n",
"scalar": "false\n",
"list": "- item\n",
"no_id": "name: Missing ID\n",
"yaml": "id: [\n",
}
for name, text in malformed.items():
self.write(self.site / f"fragments/category/{name}/fragment.yaml", text)
reg = self.load()
self.assertEqual(reg.fragments, {})
expected = {
("E_FRAGMENT_ID" if name == "no_id" else
"E_YAML" if name == "yaml" else "E_FRAGMENT_SHAPE",
f"fragments/category/{name}/fragment.yaml")
for name in malformed
}
self.assertEqual({(i.code, i.path) for i in reg.report.issues}, expected)
self.assertEqual(len(reg.report.issues), len(malformed))
def test_missing_template_reports_discovered_nested_manifest(self):
manifest = self.fragment("Category/group/item")
manifest.with_name("template.html.j2").unlink()
self.assert_issues(self.load(), [
("E_FRAGMENT_TEMPLATE", "fragments/Category/group/item/fragment.yaml"),
])
def test_inline_preview_compatibility_and_defaults_are_not_materialized(self):
self.fragment("flat", fields=[
{"key": "title", "type": "text", "required": True},
{"key": "variant", "type": "select", "options": ["light", "dark"],
"default": "light"},
], preview={"title": "Inline"})
reg = self.load()
self.assertTrue(reg.report.ok, reg.report.issues)
fragment = reg.fragments["sample"]
self.assertEqual(fragment.preview, {"title": "Inline"})
self.assertEqual(fragment.fields[1].default, "light")
def test_sidecar_merge_is_per_prop_and_name_does_not_rename_fragment(self):
manifest = self.fragment("Category/item", fields=[
{"key": "title", "type": "text"},
{"key": "keep", "type": "text"},
{"key": "name", "type": "text"},
{"key": "settings", "type": "group", "fields": [
{"key": "a", "type": "number"}, {"key": "b", "type": "number"},
]},
{"key": "enabled", "type": "boolean", "default": True},
], preview={"title": "Inline", "keep": "Kept", "settings": {"a": 1, "b": 2}})
self.sidecar(manifest, {"name": "Preview label", "props": {
"title": "Sidecar", "name": "Name prop", "settings": {"a": 3}, "enabled": False,
}})
reg = self.load()
self.assertTrue(reg.report.ok, reg.report.issues)
fragment = reg.fragments["sample"]
self.assertEqual(fragment.name, "Catalog name")
self.assertEqual(fragment.preview, {
"title": "Sidecar", "keep": "Kept", "name": "Name prop",
"settings": {"a": 3}, "enabled": False,
})
self.assertNotIn("props", fragment.preview)
self.assertTrue(fragment.fields[-1].default)
def test_sidecar_without_name_or_inline_preview_for_builtin_and_site(self):
for builtin, fid in ((True, "builtin_sample"), (False, "site_sample")):
manifest = self.fragment("Category/item", fid, builtin=builtin,
fields=[{"key": "title", "type": "text"}])
self.sidecar(manifest, {"props": {"title": fid}})
reg = self.load()
self.assertTrue(reg.report.ok, reg.report.issues)
for fid in ("builtin_sample", "site_sample"):
self.assertEqual(reg.fragments[fid].preview, {"title": fid})
self.assertEqual(reg.fragments[fid].name, "Catalog name")
def test_invalid_inline_preview_is_diagnosed_and_normalized_by_parser(self):
manifest = self.fragment("item")
for bad in (None, False, 0, "", "text", [], ["title"]):
with self.subTest(preview=bad):
report = Report()
fragment = parse_fragment({"id": "sample", "preview": bad},
"fragments/item/fragment.yaml", manifest.parent,
False, report)
self.assertIsNotNone(fragment)
self.assertEqual(fragment.preview, {})
self.assertEqual(fragment.preview.get("title"), None)
self.assertEqual([(i.code, i.path) for i in report.issues], [
("E_FRAGMENT_PREVIEW", "fragments/item/fragment.yaml:preview"),
])
def test_invalid_inline_does_not_prevent_valid_sidecar_loading(self):
manifest = self.fragment("item", preview=["bad"],
fields=[{"key": "title", "type": "text"}])
self.sidecar(manifest, {"props": {"title": "Valid"}})
reg = self.load()
self.assertEqual(reg.fragments["sample"].preview, {"title": "Valid"})
self.assert_issues(reg, [("E_FRAGMENT_PREVIEW", "fragments/item/fragment.yaml:preview")])
def test_invalid_sidecar_envelope_and_props_shapes(self):
manifest = self.fragment("Category/deeper/item", preview={"title": "Inline"},
fields=[{"key": "title", "type": "text"}])
rel = "fragments/Category/deeper/item/preview.yaml"
cases = [(None, rel), (False, rel), ("text", rel), ([], rel),
({}, rel + ":props"), ({"name": "Only a label"}, rel + ":props")]
cases += [({"props": bad}, rel + ":props")
for bad in (None, False, 0, "", "text", [], ["item"])]
for raw, path in cases:
with self.subTest(raw=raw):
self.sidecar(manifest, raw)
reg = self.load()
self.assertEqual(reg.fragments["sample"].preview, {"title": "Inline"})
self.assert_issues(reg, [("E_FRAGMENT_PREVIEW", path)])
def test_sidecar_name_and_unknown_keys_have_precise_paths(self):
manifest = self.fragment("item")
for name in (None, False, 12, [], {}):
with self.subTest(name=name):
self.sidecar(manifest, {"name": name, "props": {}})
self.assert_issues(self.load(), [
("E_FRAGMENT_PREVIEW", "fragments/item/preview.yaml:name"),
])
self.sidecar(manifest, {"props": {}, "unknown": True})
self.assert_issues(self.load(), [
("E_FRAGMENT_PREVIEW", "fragments/item/preview.yaml:unknown"),
])
def test_sidecar_yaml_errors_use_existing_yaml_diagnostics(self):
manifest = self.fragment("Group/item", builtin=True,
fields=[{"key": "title", "type": "text"}],
preview={"title": "Inline"})
for text in ("props: [\n", "props: {}\nprops: {}\n", "props: &x {}\nname: *x\n", ""):
with self.subTest(text=text):
self.write(manifest.with_name("preview.yaml"), text)
reg = self.load()
self.assertEqual(reg.fragments["sample"].preview, {"title": "Inline"})
self.assert_issues(reg, [
("E_FRAGMENT_PREVIEW" if text == "" else "E_YAML",
"builtin/Group/item/preview.yaml"),
])
def test_sidecar_read_errors_are_reported_without_swallowing_them(self):
manifest = self.fragment("item")
sidecar = manifest.with_name("preview.yaml")
self.sidecar(manifest, {"props": {}})
read_text = Path.read_text
def unreadable(path, *args, **kwargs):
if path == sidecar:
raise PermissionError("test read denied")
return read_text(path, *args, **kwargs)
with patch.object(Path, "read_text", unreadable):
reg = self.load()
self.assert_issues(reg, [("E_YAML", "fragments/item/preview.yaml")])
self.assertIn("test read denied", reg.report.issues[0].message)
self.assertEqual(reg.fragments["sample"].preview, {})
sidecar.write_bytes(b"props: \xff")
self.assert_issues(self.load(), [("E_YAML", "fragments/item/preview.yaml")])
def test_preview_values_accept_core_types_without_resolving_references(self):
fields, props = [], {}
examples = {
"text": "Title", "textarea": "Paragraph", "markdown": "**Text**",
"slug": "a-slug", "color": "#fff", "icon": "star", "asset": "/missing.png",
"number": 2.5, "boolean": False, "date": "2026-11-13",
"datetime": "2026-11-13T10:00:00Z", "select": "one", "multiselect": ["one"],
"ref": "missing-entry", "refs": ["missing-entry"],
"link": {"page": "missing-page"},
"query": {"query": {"collection": "missing-collection", "limit": 2}},
"json": {"anything": [1, False]},
}
for kind, value in examples.items():
field = {"key": kind, "type": kind}
if kind in ("select", "multiselect"):
field["options"] = ["one", "two"]
if kind in ("ref", "refs"):
field["to"] = "missing-collection"
fields.append(field)
props[kind] = value
fields += [
{"key": "group", "type": "group", "fields": [{"key": "x", "type": "number"}]},
{"key": "list", "type": "list", "fields": [{"key": "x", "type": "boolean"}]},
{"key": "strings", "type": "list", "of": "text"},
{"key": "binding", "type": "text"},
{"key": "omitted_required", "type": "text", "required": True},
]
props.update(group={"x": 1}, list=[{"x": True}], strings=["a", "b"],
binding={"bind": "entry.missing"})
for source in ("inline", "sidecar"):
with self.subTest(source=source):
manifest = self.fragment("item", fields=fields,
**({"preview": props} if source == "inline" else {}))
if source == "sidecar":
self.sidecar(manifest, {"props": props})
reg = self.load()
self.assertTrue(reg.report.ok, reg.report.issues)
self.assertEqual(reg.fragments["sample"].preview, props)
def test_invalid_preview_values_use_core_schema_paths_for_both_sources(self):
cases = [
({"type": "text"}, 12, "", "E_TYPE"),
({"type": "number"}, True, "", "E_TYPE"),
({"type": "boolean"}, "true", "", "E_TYPE"),
({"type": "select", "options": ["a", "b"]}, "c", "", "E_SELECT_VALUE"),
({"type": "multiselect", "options": ["a"]}, ["b"], "", "E_SELECT_VALUE"),
({"type": "date"}, 5, "", "E_TYPE"),
({"type": "datetime"}, [], "", "E_TYPE"),
({"type": "ref", "to": "missing"}, 12, "", "E_TYPE"),
({"type": "refs", "to": "missing"}, [1], "", "E_TYPE"),
({"type": "query"}, {"collection": "missing"}, "", "E_VALUE_SHAPE"),
({"type": "link"}, {"page": 12}, "", "E_VALUE_SHAPE"),
({"type": "text"}, {"bind": "unknown.x"}, "", "E_VALUE_SHAPE"),
({"type": "text"}, "{{ page.title }}", "", "E_TEMPLATE_IN_DATA"),
({"type": "group", "fields": [{"key": "n", "type": "number"}]},
{"n": "bad"}, ".n", "E_TYPE"),
({"type": "group", "fields": [{"key": "n", "type": "number"}]},
{"unknown": 1}, ".unknown", "E_PROP_UNKNOWN"),
({"type": "list", "of": "number"}, [1, "bad"], "[1]", "E_TYPE"),
({"type": "list", "fields": [{"key": "flag", "type": "boolean"}]},
[{"flag": "bad"}], "[0].flag", "E_TYPE"),
]
for source in ("inline", "sidecar"):
for schema, value, suffix, code in cases:
with self.subTest(source=source, schema=schema, value=value):
manifest = self.fragment("item", fields=[{"key": "value", **schema}],
**({"preview": {"value": value}}
if source == "inline" else {}))
sidecar = manifest.with_name("preview.yaml")
if source == "inline":
sidecar.unlink(missing_ok=True)
else:
self.sidecar(manifest, {"props": {"value": value}})
reg = self.load()
prefix = ("fragment.yaml:preview" if source == "inline"
else "preview.yaml:props")
self.assert_issues(reg, [(code, f"fragments/item/{prefix}.value{suffix}")])
def test_unknown_preview_props_are_diagnosed(self):
manifest = self.fragment("item", preview={"unknown_inline": True})
self.sidecar(manifest, {"props": {"unknown_sidecar": True}})
self.assert_issues(self.load(), [
("E_PROP_UNKNOWN", "fragments/item/fragment.yaml:preview.unknown_inline"),
("E_PROP_UNKNOWN", "fragments/item/preview.yaml:props.unknown_sidecar"),
])
def test_invalid_inline_value_is_reported_even_if_sidecar_overrides_it(self):
manifest = self.fragment("item", fields=[{"key": "title", "type": "text"}],
preview={"title": 42})
self.sidecar(manifest, {"props": {"title": "Override"}})
reg = self.load()
self.assertEqual(reg.fragments["sample"].preview, {"title": "Override"})
self.assert_issues(reg, [("E_TYPE", "fragments/item/fragment.yaml:preview.title")])
def test_shipped_builtins_still_load_with_valid_flat_previews(self):
reg = load_site(self.site, builtin_dir=BUILTIN_DIR)
self.assertTrue(reg.report.ok, reg.report.issues)
self.assertEqual(len(reg.fragments), len(list((BUILTIN_DIR / "fragments").rglob("fragment.yaml"))))
self.assertTrue(reg.fragments)
for fragment in reg.fragments.values():
self.assertTrue(fragment.builtin)
self.assertIsInstance(fragment.preview, dict)
if __name__ == "__main__":
unittest.main()
+411
View File
@@ -0,0 +1,411 @@
"""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()
+2 -8
View File
@@ -1,7 +1,6 @@
import shutil
import unittest
from helpers import NOW, ROOT, SiteTestCase
from helpers import NOW, SiteTestCase
from site_engine.core.registry import load_site
from site_engine.core.render import Renderer
@@ -10,7 +9,7 @@ from site_engine.errors import Report
CORE_FRAGMENTS = {
"site_header", "site_footer", "hero", "page_header", "section", "columns", "richtext",
"image", "card_grid", "collection_list", "entry_header", "cta_banner", "form", "faq", "disclaimer",
"image", "card_grid", "collection_list", "entry_header", "cta_banner", "form", "faq", "disclaimer", "steps", "entry_card",
}
@@ -33,11 +32,6 @@ class BuiltinFragmentsTest(SiteTestCase):
self.assertTrue(reg.fragments[fid].style, fid)
def test_steps_support_more_than_three_items_and_escape_titles(self):
shutil.copytree(
ROOT / "examples/ai-studio/fragments/steps",
self.site / "fragments/steps",
dirs_exist_ok=True,
)
self.write("pages/process.md", """---
schema: 1
title: Процесс
+10 -2
View File
@@ -37,7 +37,7 @@ class PackagingTest(unittest.TestCase):
shutil.copytree(ROOT, project, ignore=shutil.ignore_patterns(
"build", "*.egg-info", "__pycache__", ".git", "tests", "docs", "examples", "dist", ".engine"))
result = subprocess.run([sys.executable, "-m", "pip", "wheel", str(project), "--no-deps", "--no-build-isolation",
"-q", "-w", str(Path(tmp) / "out")], capture_output=True, text=True, timeout=180)
"-q", "-w", str(Path(tmp) / "out")], check=False, capture_output=True, text=True, timeout=180)
wheels = glob.glob(f"{tmp}/out/*.whl")
if result.returncode != 0 or not wheels:
self.skipTest(f"wheel не собрался в этом окружении: {result.stderr[-200:]}")
@@ -50,8 +50,16 @@ class PackagingTest(unittest.TestCase):
"site_engine/web/admin/static/editor.js", "site_engine/web/admin/static/preview.js",
"site_engine/web/admin/templates/document.html.j2", "site_engine/web/admin/templates/editor_result.html.j2",
"site_engine/web/admin/templates/preview_result.html.j2", "site_engine/builtin/base.css",
"site_engine/builtin/fragments/hero/template.html.j2"):
"site_engine/builtin/fragments/marketing/hero/template.html.j2",
"site_engine/builtin/containers.css", "site_engine/builtin/themes/v1/fonts.json",
*(f"site_engine/builtin/themes/v1/{name}.json" for name in ("minimal", "dark", "editorial", "bold", "natural", "custom"))):
self.assertIn(needed, names)
fragment_files = {
"site_engine/" + p.relative_to(PKG).as_posix()
for p in (PKG / "builtin/fragments").rglob("*")
if p.is_file() and p.suffix != ".pyc" and "__pycache__" not in p.parts
}
self.assertTrue(fragment_files.issubset(names), sorted(fragment_files - set(names)))
if __name__ == "__main__":
+2 -2
View File
@@ -58,10 +58,10 @@ class SecurityTest(SiteTestCase):
from site_engine.build.pipeline import build_site
from site_engine.errors import EngineError
self.edit("site.yaml", "color.dark: '#14213d'", "color.dark: 'red; } body { display:none'")
self.edit("theme.yaml", "hero_dark: '#14213d'", "hero_dark: 'red; } body { display:none'")
with self.assertRaises(EngineError) as ctx:
build_site(self.site, self.out, now=NOW)
self.assertIn("E_THEME_TOKEN", ctx.exception.report.codes())
self.assertIn("E_THEME_COLOR", ctx.exception.report.codes())
def test_duplicate_fragment_id_cannot_shadow_builtin(self):
self.write("fragments/mine/hero/fragment.yaml", "id: hero\nname: Мой hero\nfields: []\n")
+319
View File
@@ -0,0 +1,319 @@
"""Stage 4 contracts: universal refs, shared fragments and the clean Site Studio example."""
import shutil
import tempfile
import unittest
from pathlib import Path
from theme_fixture import seed, write
from site_engine.build.pipeline import build_site, preview_page
from site_engine.core.models import FieldDef, parse_fields
from site_engine.core.registry import load_site
from site_engine.core.resolve import Resolver
from site_engine.core.routes import build_route_table
from site_engine.core.validate import check_value, validate_release, validate_workspace
from site_engine.core.values import Query
from site_engine.errors import EngineError, Report
from site_engine.parsing import frontmatter
from site_engine.parsing.yamlio import dump_yaml, load_yaml
from site_engine.services.documents import DocumentService
from site_engine.web.admin.forms import FormData, build_view, parse_field
ROOT = Path(__file__).resolve().parents[1]
class GenericReferenceTest(unittest.TestCase):
def setUp(self):
self.tmp = tempfile.TemporaryDirectory()
self.addCleanup(self.tmp.cleanup)
self.root = Path(self.tmp.name)
self.site, self.out = self.root / "site", self.root / "dist"
seed(self.site)
def resolver(self, strict=True):
self.reg = load_site(self.site)
self.report = Report()
return Resolver(self.reg, build_route_table(self.reg, self.report), self.report, strict)
def card(self, ref):
write(
self.site,
"pages/card.md",
frontmatter.dumps(
{
"title": "Рекомендация",
"status": "published",
"regions": {
"main": [
{
"id": "entry_card_test",
"fragment": "entry_card",
"props": {"title": "Рекомендуем", "entry": ref},
},
]
},
}
),
)
def test_generic_and_fixed_ref_resolve_same_entry(self):
resolver = self.resolver()
self.assertEqual(
resolver.ref_entry("*", "articles/first", "ref"),
resolver.ref_entry("articles", "first", "ref"),
)
self.assertEqual(self.report.errors, [])
def test_generic_ref_shape_rejects_partial_paths_and_non_strings(self):
for value in (
"first",
"articles/first/extra",
"../first",
"articles/../first",
"1bad/first",
"articles/UPPER",
{},
42,
):
with self.subTest(value=value):
resolver = self.resolver()
self.assertIsNone(resolver.ref_entry("*", value, "ref"))
self.assertIn("E_REF_FORMAT", self.report.codes())
def test_missing_collection_and_slug_have_distinct_diagnostics(self):
for value, code in (
("missing/first", "E_REF_COLLECTION"),
("articles/missing", "E_REF_MISSING"),
):
resolver = self.resolver()
self.assertIsNone(resolver.ref_entry("*", value, "ref"))
self.assertIn(code, self.report.codes())
def test_generic_ref_requires_published_target_while_fixed_contract_is_preserved(self):
path = self.site / "content/articles/first.md"
meta, body = frontmatter.parse(path.read_text())
meta["status"] = "draft"
path.write_text(frontmatter.dumps(meta, body))
resolver = self.resolver()
self.assertTrue(resolver.ref_entry("*", "articles/first", "ref"))
self.assertIn("E_REF_UNPUBLISHED", self.report.codes())
resolver = self.resolver(strict=False)
self.assertTrue(resolver.ref_entry("*", "articles/first", "ref"))
self.assertFalse(self.report.errors)
self.assertTrue(self.report.warnings)
resolver = self.resolver()
self.assertTrue(resolver.ref_entry("articles", "first", "ref"))
self.assertFalse(self.report.issues)
def test_static_shape_and_schema_parser_support_wildcard_without_changing_fixed_targets(self):
report = Report()
fields = parse_fields(
[
{"key": "entry", "type": "ref", "to": "*"},
{"key": "old", "type": "refs", "to": "not-yet-present"},
],
"fields",
report,
)
self.assertTrue(report.ok)
check_value(fields[0], "first", "props.entry", report)
self.assertIn("E_REF_FORMAT", report.codes())
report = Report()
check_value(
FieldDef("items", "refs", to="*"), ["articles/first", "first"], "props.items", report
)
self.assertEqual(len(report.errors), 1)
self.assertIn("[1]", report.errors[0].path)
report = Report()
parse_fields([{"key": "entry", "type": "ref", "to": 3}], "fields", report)
self.assertIn("E_FIELD_REF", report.codes())
def test_choices_prefix_only_generic_refs_and_only_published_candidates(self):
ctx = {
"entries": {"articles": ["first", "draft"], "cases": ["case"]},
"published_entries": {"articles": ["first"]},
}
generic = build_view(FieldDef("entry", "ref", to="*"), "articles/first", "p.entry", ctx)
self.assertEqual(generic["datalist"], ["articles/first"])
fixed = build_view(FieldDef("entry", "ref", to="articles"), "first", "p.entry", ctx)
self.assertEqual(fixed["datalist"], ["first", "draft"])
errors = []
value = parse_field(
FieldDef("entry", "ref", to="*"),
FormData.from_pairs([("p.entry", "articles/first")]),
"p.entry",
errors,
)
self.assertEqual(value, "articles/first")
self.assertFalse(errors)
def test_entry_card_build_and_failed_publish_preserves_current(self):
self.card("articles/first")
result = build_site(self.site, self.out)
html = (self.out / "current/card/index.html").read_text()
self.assertIn('href="/articles/first/"', html)
self.assertIn("Первая статья", html)
self.card("articles/missing")
with self.assertRaises(EngineError) as err:
build_site(self.site, self.out)
self.assertIn("E_REF_MISSING", err.exception.report.codes())
self.assertEqual((self.out / "current").resolve(), result.output_dir.resolve())
def test_generic_refs_in_unused_collection_fields_are_validated_recursively(self):
p = self.site / "collections/articles.yaml"
v = load_yaml(p.read_text())
v["fields"].append(
{
"key": "related",
"type": "group",
"fields": [{"key": "items", "type": "refs", "to": "*"}],
}
)
p.write_text(dump_yaml(v))
p = self.site / "content/articles/first.md"
meta, body = frontmatter.parse(p.read_text())
meta["related"] = {"items": ["articles/missing"]}
p.write_text(frontmatter.dumps(meta, body))
reg = load_site(self.site)
self.assertIn("E_REF_MISSING", validate_workspace(reg).codes())
meta["status"] = "draft"
p.write_text(frontmatter.dumps(meta, body))
reg = load_site(self.site)
report = validate_workspace(reg)
self.assertFalse(report.errors)
self.assertIn("E_REF_MISSING", report.codes())
def test_disabled_collection_excluded_from_queries_routes_refs_and_release_completeness(self):
p = self.site / "site.yaml"
v = load_yaml(p.read_text())
v["features"] = {"articles": False}
p.write_text(dump_yaml(v))
p = self.site / "collections/articles.yaml"
v = load_yaml(p.read_text())
v["requires"] = ["feature.articles"]
v["fields"].append({"key": "missing", "type": "text", "required": True})
p.write_text(dump_yaml(v))
resolver = self.resolver()
self.assertEqual(resolver.query(Query("articles"), "query"), [])
resolver.ref_entry("*", "articles/first", "ref")
self.assertIn("E_REF_UNPUBLISHED", self.report.codes())
table = build_route_table(self.reg, Report())
self.assertFalse(table["/articles/first/"].published)
self.assertFalse(validate_release(self.reg, table).errors)
result = build_site(self.site, self.out)
self.assertEqual(result.pages, 1)
self.assertFalse((self.out / "current/articles/first").exists())
def test_unknown_feature_requirement_is_diagnosed(self):
p = self.site / "collections/articles.yaml"
v = load_yaml(p.read_text())
v["requires"] = ["feature.unknown"]
p.write_text(dump_yaml(v))
self.assertIn("E_REQUIRES_UNKNOWN", validate_workspace(load_site(self.site)).codes())
def test_malformed_collection_requirements_are_not_silently_ignored(self):
path = self.site / "collections/articles.yaml"
value = load_yaml(path.read_text())
for bad in (None, False, 0, "feature.articles", {"feature.articles": True}, [3]):
with self.subTest(value=bad):
value["requires"] = bad
path.write_text(dump_yaml(value))
self.assertIn("E_COLLECTION_REQUIRES", load_site(self.site).report.codes())
def test_document_choices_exclude_taxonomy_targets_without_public_pages(self):
write(
self.site,
"collections/tags.yaml",
dump_yaml({"id": "tags", "kind": "taxonomy", "fields": []}),
)
write(self.site, "content/tags/tag.md", frontmatter.dumps({"status": "published"}))
choices = DocumentService(self.site).get("index").schema["choices"]
self.assertEqual(choices["entries"]["tags"], ["tag"])
self.assertNotIn("tags", choices["published_entries"])
self.assertEqual(choices["published_entries"]["articles"], ["first"])
class SiteStudioExampleTest(unittest.TestCase):
def setUp(self):
self.tmp = tempfile.TemporaryDirectory()
self.addCleanup(self.tmp.cleanup)
self.root = Path(self.tmp.name)
self.site = self.root / "site"
self.out = self.root / "dist"
shutil.copytree(ROOT / "examples/site-studio", self.site)
def test_clean_example_has_13_published_pages_and_no_local_builtin_shadows(self):
reg = load_site(self.site)
self.assertFalse(reg.report.errors)
self.assertTrue(all(f.builtin for f in reg.fragments.values()))
self.assertEqual(len(reg.pages), 9)
self.assertEqual(sum(len(v) for v in reg.entries.values()), 8)
report = validate_workspace(reg)
self.assertFalse(report.errors, report.issues)
result = build_site(self.site, self.out)
self.assertEqual(result.pages, 13)
self.assertEqual(load_yaml((self.site / "site.yaml").read_text())["schema"], 1)
self.assertFalse((self.out / "current/cases/booking").exists())
self.assertNotIn("missing-cover", (self.out / "current/index.html").read_text())
def test_display_uses_real_bindings_assets_and_optional_entry_fields(self):
build_site(self.site, self.out)
html = (self.out / "current/services/bots/index.html").read_text()
self.assertIn('src="/assets/bots.webp"', html)
self.assertIn("Автоматизируем заявки", html)
self.assertIn("Умный бот для бизнеса", html)
self.assertNotIn("{{ entry.", html)
self.assertIn("STUDIO / SERVICES", html)
self.assertIn("<title>Telegram-боты —", html)
self.assertIn("content='Автоматизируем заявки", html)
def test_intentionally_incomplete_booking_is_previewable_with_visible_diagnostic(self):
html, report = preview_page(self.site, "cases/booking")
self.assertIn("Бот для онлайн-записи", html)
self.assertIn("E_ASSET_MISSING", report.codes())
def test_shared_lists_render_more_than_three_without_truncation(self):
p = self.site / "pages/index.md"
meta, body = frontmatter.parse(p.read_text())
for b in meta["regions"]["main"]:
if b["fragment"] in ("steps", "card_grid"):
b["props"]["items"] += [{"title": "Четвёртый"}, {"title": "Пятый"}]
p.write_text(frontmatter.dumps(meta, body))
build_site(self.site, self.out)
html = (self.out / "current/index.html").read_text()
self.assertEqual(html.count("Пятый"), 2)
self.assertIn("aria-hidden='true'>05</span>", html)
def test_collection_list_renders_more_than_three_entries(self):
meta, body = frontmatter.parse((self.site / "content/services/bots.md").read_text())
for i in range(4):
meta["slug"] = f"additional-{i}"
write(self.site, f"content/services/additional-{i}.md", frontmatter.dumps(meta, body))
path = self.site / "pages/index.md"
meta, body = frontmatter.parse(path.read_text())
meta["regions"]["main"][1]["props"]["source"]["query"]["limit"] = 10
path.write_text(frontmatter.dumps(meta, body))
build_site(self.site, self.out)
html = (self.out / "current/index.html").read_text()
self.assertEqual(html.count('class="f-collection_list__item"'), 6)
def test_form_schema_has_keys_enabled_fields_consent_and_page_ids(self):
reg = load_site(self.site)
f = reg.forms["form_contact"]
self.assertEqual(f.success["page"], "thank-you")
self.assertNotIn("telegram", [v["key"] for v in f.fields])
self.assertEqual(f.raw["status"], "active")
self.assertEqual(reg.forms["form_brief"].raw["status"], "draft")
self.assertTrue(any(v["key"] == "consent" and v["policy"] == "privacy" for v in f.fields))
build_site(self.site, self.out)
html = (self.out / "current/request/index.html").read_text()
self.assertIn('type="email"', html)
self.assertIn('type="tel"', html)
self.assertIn('action="/forms/form_contact"', html)
self.assertIn("name='form_version'", html)
self.assertIn("Приём заявок пока не подключён", html)
if __name__ == "__main__":
unittest.main()
+263
View File
@@ -0,0 +1,263 @@
"""File theme validation, shared CSS and immutable releases without editable examples."""
import datetime as dt
import json
import os
import tempfile
import unittest
from pathlib import Path
from unittest.mock import patch
from theme_fixture import document, seed, write
from site_engine.build.pipeline import build_site, preview_page
from site_engine.core.registry import load_site
from site_engine.core.theme import default_theme, preset_catalog, resolve_theme, theme_css
from site_engine.core.validate import validate_workspace
from site_engine.errors import EngineError, Report
from site_engine.parsing.yamlio import dump_yaml
from site_engine.services.publish import rollback
NOW = dt.datetime(2026, 11, 13, 12, tzinfo=dt.UTC)
class ThemeTest(unittest.TestCase):
def resolve(self, overrides=None, preset="minimal"):
report = Report()
result = resolve_theme(document(preset, overrides), report)
return result, report
def test_exact_design_presets_and_independent_catalog_copies(self):
expected = {"minimal": ("#4255b9", 1180), "dark": ("#a48bfa", 1240),
"editorial": ("#82563e", 1040), "bold": ("#df466f", 1280),
"natural": ("#49775c", 1140), "custom": ("#6554ce", 1180)}
for name, (color, width) in expected.items():
with self.subTest(name=name):
overrides = {k: v for k, v in preset_catalog()[name].items() if k in ("colors", "type", "ui")} if name == "custom" else {}
theme, report = self.resolve(overrides, name)
self.assertTrue(report.ok, report.issues)
self.assertEqual(theme.tokens["colors"]["primary"], color)
self.assertEqual(theme.container.max_width, width)
catalog = preset_catalog()
catalog["dark"]["colors"]["primary"] = "modified"
self.assertEqual(preset_catalog()["dark"]["colors"]["primary"], "#a48bfa")
def test_deep_overrides_preserve_other_tokens(self):
theme, report = self.resolve({"colors": {"primary": "#123456"}, "ui": {"container": {"mode": "fluid", "gutter": {"mobile": 0}}}})
self.assertTrue(report.ok, report.issues)
self.assertEqual(theme.container.gutter.desktop, 32)
self.assertEqual(theme.container.gutter.mobile, 0)
self.assertEqual(theme.container.mode, "fluid")
self.assertEqual(theme.tokens["colors"]["surface"], "#ffffff")
self.assertIn("--color-primary: #123456;", theme_css(theme))
def test_custom_requires_complete_groups(self):
theme, report = self.resolve({"colors": {"primary": "#123456"}}, "custom")
self.assertIsNone(theme)
self.assertIn("E_THEME_CUSTOM", report.codes())
values = {k: v for k, v in preset_catalog()["custom"].items() if k in ("colors", "type", "ui")}
del values["ui"]["container"]["gutter"]["mobile"]
self.assertIn("E_THEME_CUSTOM", self.resolve(values, "custom")[1].codes())
def test_invalid_document_versions_and_unknown_keys(self):
for values in ({"schema": True}, {"schema": 2}, {"preset": []}, {"preset": "missing"},
{"preset_version": True}, {"preset_version": 2}, {"inline": {}}, {"overrides": None}):
with self.subTest(values=values):
report = Report()
self.assertIsNone(resolve_theme({**document(), **values}, report))
self.assertFalse(report.ok)
def test_invalid_group_shapes_report_instead_of_crashing(self):
for group in ("colors", "type", "ui", "custom_colors", "gradients"):
for value in (None, False, 0, [], "url(https://invalid)"):
with self.subTest(group=group, value=value):
theme, report = self.resolve({group: value})
self.assertIsNone(theme)
self.assertTrue(any(i.path.startswith("theme.yaml.overrides." + group) for i in report.errors))
def test_numeric_boundaries_and_strict_types(self):
for group, key, valid, invalid in (
("type", "scale", [.85, 1.3], [.84, 1.31, True, "1", float("nan"), float("inf"), 10**1000]),
("type", "line", [1.3, 1.9], [1.29, 1.91, None]),
("type", "headingWeight", [100, 900], [99, 901, 700.0, True]),
("ui", "radius", [0, 24], [-1, 25, "8px"]),
("ui", "spacing", [.8, 1.4], [.79, 1.41, False]),
):
for value in valid + invalid:
with self.subTest(group=group, key=key, value=value):
theme, report = self.resolve({group: {key: value}})
self.assertEqual(theme is not None, value in valid and type(value) is not bool)
self.assertEqual(report.ok, theme is not None)
def test_container_types_ranges_keys_and_legacy_numeric(self):
invalid = [1080, None, [], {"mode": "wide"}, {"mode": []}, {"max_width": 719},
{"max_width": 1921}, {"max_width": 1080.0}, {"max_width": True},
{"gutter": []}, {"gutter": {"mobile": -1}}, {"gutter": {"desktop": 97}},
{"gutter": {"tablet": "24"}}, {"gutter": {"phone": 16}}, {"width": 1200}]
for cn in invalid:
with self.subTest(container=cn):
theme, report = self.resolve({"ui": {"container": cn}})
self.assertIsNone(theme)
self.assertFalse(report.ok)
for mode in ("boxed", "fluid", "full"):
for width in (720, 1920):
theme, report = self.resolve({"ui": {"container": {"mode": mode, "max_width": width, "gutter": {"mobile": 0, "desktop": 96}}}})
self.assertTrue(report.ok)
self.assertEqual(theme.container.max_width, width)
def test_css_url_script_jinja_and_unapproved_font_are_rejected(self):
for override in (
{"colors": {"primary": "red; }body{display:none}"}},
{"colors": {"surface": "#fff"}}, {"colors": {"accent": "{{ x }}"}},
{"type": {"body": "url(https://example.org/font)"}},
{"type": {"heading": "</style><script>1</script>"}},
{"type": {"pair": "unknown"}}, {"ui": {"shadow": "anything"}},
{"ui": {"button": "gradient"}}, {"ui": {"css": "color:red"}},
):
with self.subTest(override=override):
theme, report = self.resolve(override)
self.assertIsNone(theme)
self.assertFalse(report.ok)
def test_named_colors_limits_and_reserved_names(self):
valid = {f"brand_{i}": "#123456" for i in range(24)}
theme, report = self.resolve({"custom_colors": valid})
self.assertTrue(report.ok)
self.assertIn("--color-brand-0: #123456", theme_css(theme))
for extra in ({**valid, "another": "#123456"}, {"primary": "#123456"},
{"a": "#123456"}, {"Bad_Name": "#123456"}, {"font;body": "#123456"},
{"brand": "url(x)"}, {1: "#123456"}):
with self.subTest(extra=extra):
self.assertFalse(self.resolve({"custom_colors": extra})[1].ok)
def test_gradients_validate_all_stops_and_disable_with_solid_fallback(self):
definition = {"type": "linear", "angle": 145, "stops": [{"at": 0, "color": "#112233"}, {"at": 55, "color": "#445566"}, {"at": 100, "color": "#778899"}]}
theme, report = self.resolve({"gradients": {"enabled": True, "definitions": {"hero": definition}}})
self.assertTrue(report.ok)
self.assertIn("W_THEME_GRADIENT_CONTRAST", report.codes())
self.assertIn("--hero-gradient: linear-gradient(145deg, #112233 0%, #445566 55%, #778899 100%);", theme_css(theme))
theme, _ = self.resolve({"gradients": {"enabled": False, "definitions": {"hero": definition}}})
self.assertNotIn("linear-gradient", theme_css(theme))
self.assertIn("--hero-gradient: #4255b9", theme_css(theme))
for key, value in (("type", "radial"), ("angle", -1), ("angle", 361), ("angle", True),
("stops", []), ("stops", [{"at": 0, "color": "#fff"}] * 2),
("stops", [{"at": 20, "color": "#112233"}, {"at": 20, "color": "#445566"}]),
("stops", [{"at": "0", "color": "#112233"}, {"at": 100, "color": "#445566"}])):
with self.subTest(key=key, value=value):
self.assertFalse(self.resolve({"gradients": {"definitions": {"hero": {**definition, key: value}}}})[1].ok)
self.assertFalse(self.resolve({"gradients": {"enabled": "true"}})[1].ok)
self.assertFalse(self.resolve({"gradients": {"definitions": {f"gradient_{i}": definition for i in range(13)}}})[1].ok)
def test_contrast_is_warning_and_defaults_have_no_gradients(self):
theme, report = self.resolve({"colors": {"text": "#ffffff", "muted": "#ffffff", "surface": "#ffffff", "background": "#ffffff"}})
self.assertIsNotNone(theme)
self.assertTrue(report.ok)
self.assertEqual(len(report.warnings), 3)
self.assertFalse(default_theme().tokens["gradients"]["enabled"])
class ThemeReleaseTest(unittest.TestCase):
def setUp(self):
temp = tempfile.TemporaryDirectory()
self.addCleanup(temp.cleanup)
self.work = Path(temp.name)
self.site, self.out = self.work / "site", self.work / "dist"
seed(self.site)
def test_no_theme_uses_safe_default_without_creating_file(self):
write(self.site, "site.yaml", "name: New site\n")
(self.site / "theme.yaml").unlink()
reg = load_site(self.site)
self.assertTrue(reg.report.ok)
self.assertEqual(reg.theme.document.preset, "minimal")
self.assertFalse((self.site / "theme.yaml").exists())
def test_bad_explicit_file_inline_config_and_malformed_yaml(self):
configs = [{"file": "missing.yaml"}, {"file": "../secret.yaml"}, {"file": "/tmp/secret"},
{"file": None}, {"file": ""}, {"tokens": {"color.primary": "#123456"}}, [], False]
for config in configs:
with self.subTest(config=config):
write(self.site, "site.yaml", dump_yaml({"name": "Invalid theme", "theme": config}))
self.assertFalse(load_site(self.site).report.ok)
write(self.site, "site.yaml", dump_yaml({"name": "Invalid theme", "theme": {"file": "theme.yaml"}}))
for text in ("[", "", "schema: 1\nschema: 1", "schema: 1\npreset: &x minimal\npreset_version: *x", "- item"):
with self.subTest(text=text):
write(self.site, "theme.yaml", text)
self.assertFalse(load_site(self.site).report.ok)
def test_theme_symlink_cannot_escape_site_root(self):
write(self.work, "outside.yaml", dump_yaml(document()))
(self.site / "theme.yaml").unlink()
(self.site / "theme.yaml").symlink_to(self.work / "outside.yaml")
self.assertIn("E_THEME_FILE", load_site(self.site).report.codes())
def test_all_presets_build_and_manifest_pins_effective_tokens(self):
for preset in preset_catalog():
with self.subTest(preset=preset):
overrides = {k: v for k, v in preset_catalog()[preset].items() if k in ("colors", "type", "ui")} if preset == "custom" else {}
write(self.site, "theme.yaml", dump_yaml(document(preset, overrides)))
result = build_site(self.site, self.out, now=NOW, keep=10)
manifest = json.loads((result.output_dir / "manifest.json").read_text())
self.assertEqual(manifest["theme"]["document"]["preset"], preset)
self.assertEqual(manifest["theme"]["document"]["preset_version"], 1)
self.assertTrue(manifest["render_hash"])
css = next((result.output_dir / "assets").glob("site.*.css")).read_text()
expected = manifest["theme"]["effective_tokens"]["colors"]["primary"]
self.assertIn("--color-primary: " + expected, css)
self.assertNotIn("data-preview-", (result.output_dir / "index.html").read_text())
def test_public_and_passive_preview_share_css_and_override_defaults_last(self):
result = build_site(self.site, self.out, now=NOW)
css = next((result.output_dir / "assets").glob("site.*.css")).read_text()
html, report = preview_page(self.site, "index", now=NOW)
self.assertTrue(report.ok, report.issues)
self.assertIn(css, html)
self.assertGreater(css.index("--color-primary:"), css.index("/* fragment: hero */"))
def test_contrast_warning_does_not_block_release(self):
write(self.site, "theme.yaml", dump_yaml(document(overrides={"colors": {"text": "#ffffff"}})))
result = build_site(self.site, self.out, now=NOW)
self.assertIn("W_THEME_CONTRAST", result.report.codes())
self.assertTrue(result.report.ok)
def test_invalid_theme_preserves_live_and_is_visible_to_preview(self):
original = build_site(self.site, self.out, now=NOW)
write(self.site, "theme.yaml", dump_yaml(document(overrides={"ui": {"container": 1080}})))
self.assertIn("E_THEME_SHAPE", validate_workspace(load_site(self.site)).codes())
for action in (lambda: build_site(self.site, self.out, now=NOW), lambda: preview_page(self.site, "index")):
with self.assertRaises(EngineError) as caught:
action()
self.assertIn("E_THEME_SHAPE", caught.exception.report.codes())
self.assertEqual(os.readlink(self.out / "current"), original.build_id)
def test_reproducibility_and_rollback_do_not_change_workspace(self):
first = build_site(self.site, self.out, now=NOW)
original_bytes = (first.output_dir / "manifest.json").read_bytes()
again = build_site(self.site, self.out, now=NOW)
self.assertEqual(first.build_id, again.build_id)
write(self.site, "theme.yaml", dump_yaml(document("dark")))
workspace = (self.site / "theme.yaml").read_bytes()
second = build_site(self.site, self.out, now=NOW)
self.assertNotEqual(first.build_id, second.build_id)
rollback(self.out, first.build_id)
self.assertEqual((self.site / "theme.yaml").read_bytes(), workspace)
self.assertEqual((self.out / "current/manifest.json").read_bytes(), original_bytes)
def test_render_resource_change_changes_id_with_same_source(self):
first = build_site(self.site, self.out, now=NOW)
reg = load_site(self.site)
reg.fragments["hero"].style += "\n.f-hero { padding-top: 5rem; }"
with patch("site_engine.build.pipeline.load_site", return_value=reg):
second = build_site(self.site, self.out, now=NOW)
self.assertEqual(first.source_hash, second.source_hash)
self.assertNotEqual(first.build_id, second.build_id)
self.assertTrue(first.output_dir.exists())
def test_existing_release_is_never_overwritten_on_collision(self):
first = build_site(self.site, self.out, now=NOW)
(first.output_dir / "index.html").write_text("Historical content")
with self.assertRaises(EngineError) as caught:
build_site(self.site, self.out, now=NOW)
self.assertIn("E_RELEASE_COLLISION", caught.exception.report.codes())
self.assertEqual((first.output_dir / "index.html").read_text(), "Historical content")
self.assertFalse(list(self.out.glob(".staging*")))
+437
View File
@@ -0,0 +1,437 @@
"""Theme contract: real HTML/API boundary, CAS, workflow and isolated previews."""
import datetime as dt
import json
import os
import tempfile
import unittest
from pathlib import Path
from unittest.mock import patch
from urllib.parse import parse_qs, urlsplit
from fastapi.testclient import TestClient
from theme_fixture import document, seed, write
from site_engine.build.pipeline import build_site
from site_engine.errors import ConflictError, EngineError, UnsafePathError
from site_engine.parsing.yamlio import dump_yaml, load_yaml
from site_engine.services.auth import hash_password
from site_engine.services.content import ABSENT, ContentService
from site_engine.services.documents import EditorContext
from site_engine.services.publish import rollback
from site_engine.services.theme import OnboardingService, ThemeCommitError, ThemeService
from site_engine.web.app import create_app
class ThemeManagerTests(unittest.TestCase):
@classmethod
def setUpClass(cls):
cls.password = "theme test password"
cls.password_hash = hash_password(cls.password, n=2**10)
def setUp(self):
tmp = tempfile.TemporaryDirectory()
self.addCleanup(tmp.cleanup)
self.work = Path(tmp.name)
self.site, self.dist, self.state = (
self.work / "site",
self.work / "dist",
self.work / "state",
)
seed(self.site)
env = patch.dict(
os.environ,
{
"SITE_ROOT": str(self.site),
"SITE_DIST": str(self.dist),
"SITE_STATE_DIR": str(self.state),
"SITE_ADMIN_LOGIN": "admin",
"SITE_ADMIN_PASSWORD_HASH": self.password_hash,
"SITE_SECRET_KEY": "theme-integration-secret-" * 4,
"SITE_COOKIE_SECURE": "0",
"SITE_ADMIN_ORIGIN": "",
"SITE_PREVIEW_ORIGIN": "",
},
)
env.start()
self.addCleanup(env.stop)
self.app = create_app()
self.client = TestClient(self.app)
self.addCleanup(self.client.close)
self.cookie = self.app.state.auth.login("admin", self.password, "testclient")
self.client.cookies.set("se_session", self.cookie)
self.app.state.api_credentials["test"] = (self.cookie, "testclient")
self.principal = self.app.state.auth.authenticate(self.cookie)
self.csrf = self.app.state.auth.csrf_token(self.principal)
self.context = EditorContext(self.principal, "testclient")
self.svc = ThemeService(self.site, self.dist, self.state, self.app.state.auth.audit)
def api(self, method, path="/theme", data=None):
return self.client.request(
method, "/admin/api/v1" + path, json=data, headers={"Authorization": "Bearer test"}
)
def post(self, op, data=None, csrf=None, origin="http://testserver"):
return self.client.post(
"/admin/" + op,
data={"csrf": self.csrf if csrf is None else csrf, "payload": json.dumps(data or {})},
headers={"Origin": origin, "HX-Request": "true"},
)
def new_site(self):
raw = load_yaml((self.site / "site.yaml").read_text())
del raw["theme"]
write(self.site, "site.yaml", dump_yaml(raw))
(self.site / "theme.yaml").unlink()
def test_snapshot_and_catalog_share_core(self):
snap = self.api("GET").json()
self.assertEqual(
{
"document",
"etag",
"effective_tokens",
"diagnostics",
"workspace_revision",
"live_build_id",
}
- snap.keys(),
set(),
)
self.assertIsNone(snap["live_build_id"])
self.assertEqual(snap["effective_tokens"]["ui"]["container"]["max_width"], 1080)
presets = self.api("GET", "/theme/presets")
self.assertEqual(presets.status_code, 200)
self.assertEqual(len(presets.json()["presets"]), 6)
for preset in presets.json()["presets"].values():
result = self.api(
"POST", "/theme/validate", {"document": preset["document"], "revision": 9}
)
self.assertEqual(result.status_code, 200, result.text)
self.assertEqual(result.json()["effective_tokens"], preset["effective_tokens"])
def test_validate_and_preview_never_save(self):
before = (self.site / "theme.yaml").read_bytes()
new = document("dark")
validated = self.post("theme/validate", {"document": new, "revision": 42})
self.assertEqual(validated.status_code, 200, validated.text)
self.assertIn("preset: dark", validated.json()["yaml"])
for target in ("sample", "page"):
result = self.post("theme/preview", {"document": new, "revision": 42, "target": target})
self.assertEqual(result.status_code, 200, result.text)
self.assertEqual(result.json()["revision"], 42)
preview = self.client.get(result.json()["url"])
self.assertEqual(preview.status_code, 200, preview.text)
self.assertIn("--color-primary: #a48bfa", preview.text)
self.assertIn("script-src 'none'", preview.headers["content-security-policy"])
self.assertNotIn("<script", preview.text)
self.assertEqual(before, (self.site / "theme.yaml").read_bytes())
self.assertFalse((self.state / "theme-onboarding.json").exists())
def test_demo_keeps_source_viewport_breakpoints_inside_isolated_frame(self):
for width in (390, 1440):
response = self.api(
"POST",
"/theme/preview",
{
"document": document(),
"revision": 2,
"viewport_width": width,
},
)
self.assertEqual(response.status_code, 200, response.text)
html = self.client.get(response.json()["url"]).text
self.assertEqual('<div class="sample-site compact ' in html, width <= 770)
self.assertIn(f"padding-top:clamp(25px,{width * 0.06}px,53px)", html)
for width in (True, 0, 4000):
response = self.api(
"POST",
"/theme/preview",
{
"document": document(),
"viewport_width": width,
},
)
self.assertEqual(response.status_code, 422, response.text)
def test_two_editors_conflict_returns_current_and_preserves_file(self):
etag = self.svc.get()["etag"]
first = self.api(
"PATCH", data={"document": document("dark"), "if_match": etag, "revision": 2}
)
self.assertEqual(first.status_code, 200, first.text)
second = self.api(
"PATCH", data={"document": document("natural"), "if_match": etag, "revision": 3}
)
self.assertEqual(second.status_code, 409, second.text)
error = second.json()["error"]
self.assertEqual(error["current"]["document"]["preset"], "dark")
self.assertEqual(error["current"]["etag"], first.json()["etag"])
self.assertTrue(error["request_id"])
self.assertEqual(self.svc.get()["document"]["preset"], "dark")
self.assertTrue(list((self.site / ".engine/history").rglob("*")))
self.assertIn("theme_save", (self.state / "audit.jsonl").read_text())
def test_first_save_absent_creates_link_and_completed_workflow(self):
self.new_site()
state = self.api("GET", "/theme/onboarding").json()
self.assertTrue(state["needs_setup"])
initial = self.svc.get()
self.assertEqual(initial["etag"], ABSENT)
wrong = self.api(
"PATCH", data={"document": document("dark"), "if_match": "bad", "revision": 1}
)
self.assertEqual(wrong.status_code, 409)
self.assertFalse((self.site / "theme.yaml").exists())
response = self.post(
"theme/save", {"document": document("dark"), "if_match": ABSENT, "revision": 2}
)
self.assertEqual(response.status_code, 200, response.text)
self.assertEqual(
load_yaml((self.site / "site.yaml").read_text())["theme"], {"file": "theme.yaml"}
)
self.assertEqual(OnboardingService(self.svc).status()["status"], "completed")
self.assertFalse((self.dist / "current").exists())
def test_onboarding_skip_restart_existing_and_restart_persistence(self):
self.assertEqual(OnboardingService(self.svc).status()["status"], "existing")
self.assertEqual(self.client.get("/admin/", follow_redirects=False).status_code, 200)
self.new_site()
self.assertEqual(
self.client.get("/admin/", follow_redirects=False).headers["location"],
"/admin/setup/theme",
)
for op, status in [("skip", "skipped"), ("restart", "in_progress")]:
response = self.post("setup/theme/" + op)
self.assertEqual(response.status_code, 200, response.text)
self.assertEqual(response.json()["status"], status)
restarted = ThemeService(self.site, self.dist, self.state)
self.assertEqual(OnboardingService(restarted).status()["status"], status)
self.assertEqual(create_app().state.auth.state_dir, self.state)
self.assertFalse((self.site / "theme.yaml").exists())
self.assertEqual(self.client.get("/admin/", follow_redirects=False).status_code, 200)
def test_release_marks_unconfigured_site_existing(self):
self.new_site()
build_site(self.site, self.dist)
self.assertEqual(OnboardingService(self.svc).status()["status"], "existing")
def test_auth_csrf_and_origin(self):
self.assertEqual(self.client.get("/admin/api/v1/theme").status_code, 401)
for op in (
"theme/save",
"theme/validate",
"theme/preview",
"setup/theme/skip",
"setup/theme/restart",
):
for kwargs in ({"csrf": "bad"}, {"origin": "https://evil.example"}):
self.assertEqual(self.post(op, **kwargs).status_code, 403)
self.app.state.auth.logout(self.principal, "testclient")
self.assertEqual(self.api("GET").status_code, 401)
def test_invalid_tokens_give_paths_and_no_write(self):
before = self.svc.get()
for overrides in (
{"colors": {"primary": "url(javascript:evil)"}},
{"ui": {"container": 3}},
{"type": {"scale": float("nan")}},
):
if "type" in overrides:
# JSON itself rejects NaN; exercise the service boundary separately.
with self.assertRaises(EngineError):
self.svc.save(document(overrides=overrides), before["etag"], self.context)
continue
for op in ("validate", "preview", "save"):
body = {"document": document(overrides=overrides), "revision": 4}
if op == "save":
body["if_match"] = before["etag"]
response = self.post("theme/" + op, body)
self.assertEqual(response.status_code, 422, response.text)
self.assertTrue(
any(
i["path"].startswith("theme.yaml.overrides")
for i in response.json()["error"]["issues"]
)
)
self.assertEqual(before["etag"], self.svc.get()["etag"])
def test_contrast_is_warning_and_save_allowed(self):
result = self.api(
"PATCH",
data={
"document": document(overrides={"colors": {"text": "#ffffff"}}),
"if_match": self.svc.get()["etag"],
"revision": 3,
},
)
self.assertEqual(result.status_code, 200, result.text)
self.assertTrue(any(i["code"] == "W_THEME_CONTRAST" for i in result.json()["diagnostics"]))
def test_path_is_exact_and_reconfiguration_is_rechecked_under_lock(self):
raw = load_yaml((self.site / "site.yaml").read_text())
for path in ("../outside.yaml", "site.yaml", "assets/palette.css"):
raw["theme"] = {"file": path}
write(self.site, "site.yaml", dump_yaml(raw))
with self.assertRaises(UnsafePathError):
self.svc.get()
raw["theme"] = {"file": "config/brand.yaml"}
write(self.site, "site.yaml", dump_yaml(raw))
write(self.site, "config/brand.yaml", dump_yaml(document()))
snapshot = self.svc.get()
self.svc.save(document("bold"), snapshot["etag"], self.context)
self.assertEqual(self.svc.get()["path"], "config/brand.yaml")
content = ContentService(self.site, allowed_paths=("config/brand.yaml",))
with self.assertRaises(UnsafePathError):
content.write("config/another.yaml", "{}", ABSENT)
original = ContentService.update_files
def reconfigure(content, versions, prepare):
raw["theme"] = {"file": "theme.yaml"}
write(self.site, "site.yaml", dump_yaml(raw))
return original(content, versions, prepare)
with (
patch.object(ContentService, "update_files", reconfigure),
self.assertRaises(ConflictError),
):
self.svc.save(document("dark"), self.svc.get()["etag"], self.context)
def test_symlink_escape_is_rejected(self):
raw = load_yaml((self.site / "site.yaml").read_text())
raw["theme"] = {"file": "escape/brand.yaml"}
write(self.site, "site.yaml", dump_yaml(raw))
(self.site / "escape").symlink_to(self.work, target_is_directory=True)
self.assertEqual(self.api("GET").status_code, 403)
def test_disk_failure_does_not_change_theme_and_is_logged(self):
initial = self.svc.get()
with (
patch("site_engine.services.content.atomic_write", side_effect=OSError("disk probe")),
self.assertLogs("uvicorn.error", level="ERROR") as logs,
):
result = self.post(
"theme/save",
{"document": document("bold"), "if_match": initial["etag"], "revision": 6},
)
self.assertEqual(result.status_code, 500, result.text)
self.assertEqual(result.json()["error"]["code"], "storage_error")
self.assertEqual(initial["etag"], self.svc.get()["etag"])
self.assertIn("disk probe", "\n".join(logs.output))
def test_first_save_second_write_failure_restores_both_files(self):
from site_engine.storage.fs import atomic_write
self.new_site()
before = (self.site / "site.yaml").read_bytes()
def fail(path, text):
if path.name == "site.yaml":
raise OSError("config write")
return atomic_write(path, text)
with patch("site_engine.services.content.atomic_write", fail), self.assertRaises(OSError):
self.svc.save(document("dark"), ABSENT, self.context)
self.assertFalse((self.site / "theme.yaml").exists())
self.assertEqual((self.site / "site.yaml").read_bytes(), before)
def test_audit_failure_reports_committed_snapshot_not_a_silent_failure(self):
initial = self.svc.get()
with (
patch.object(self.app.state.auth.audit, "write", side_effect=OSError("audit probe")),
self.assertLogs("uvicorn.error", level="ERROR"),
):
result = self.post(
"theme/save",
{"document": document("dark"), "if_match": initial["etag"], "revision": 11},
)
self.assertEqual(result.status_code, 500, result.text)
err = result.json()["error"]
self.assertEqual(err["code"], "theme_after_commit")
self.assertEqual(err["committed"]["revision"], 11)
self.assertEqual(err["committed"]["etag"], self.svc.get()["etag"])
self.assertEqual(self.svc.get()["document"]["preset"], "dark")
def test_onboarding_write_failure_also_reports_committed(self):
with (
patch("site_engine.services.theme.atomic_write", side_effect=OSError("state probe")),
self.assertRaises(ThemeCommitError) as raised,
):
self.svc.save(document("dark"), self.svc.get()["etag"], self.context, 8)
self.assertEqual(raised.exception.snapshot["revision"], 8)
self.assertEqual(self.svc.get()["document"]["preset"], "dark")
def test_preview_snapshots_are_immutable_and_signed(self):
response = self.api(
"POST", "/theme/preview", {"document": document("dark"), "revision": 10}
).json()
before = self.client.get(response["url"]).text
self.svc.save(document("natural"), self.svc.get()["etag"], self.context)
self.assertEqual(before, self.client.get(response["url"]).text)
self.assertEqual(self.client.get(response["url"] + "bad").status_code, 403)
parts = urlsplit(response["url"])
token = parse_qs(parts.query)["token"][0]
_, data = self.app.state.previews.authorize(response["snapshot"], token)
self.assertEqual(data["revision"], 10)
self.app.state.auth.logout(self.principal, "testclient")
with self.assertRaises(PermissionError):
self.app.state.previews.authorize(response["snapshot"], token)
def test_save_publish_rollback_keep_workspace_and_live_independent(self):
now = dt.datetime(2026, 11, 13, 16, tzinfo=dt.UTC)
first = build_site(self.site, self.dist, now=now)
self.svc.save(document("dark"), self.svc.get()["etag"], self.context)
self.assertEqual(self.svc.get()["live_build_id"], first.build_id)
second = build_site(self.site, self.dist, now=now + dt.timedelta(seconds=1))
self.assertNotEqual(first.build_id, second.build_id)
before = (self.site / "theme.yaml").read_bytes()
rollback(self.dist, first.build_id)
self.assertEqual(before, (self.site / "theme.yaml").read_bytes())
self.assertEqual(self.svc.get()["document"]["preset"], "dark")
self.assertEqual(self.svc.get()["live_build_id"], first.build_id)
def test_html_uses_api_and_never_exposes_internal_credentials(self):
calls = self.app.state.api_calls
result = self.client.get("/admin/theme")
self.assertEqual(result.status_code, 200, result.text)
self.assertGreater(self.app.state.api_calls, calls + 3)
self.assertIn("theme-bootstrap", result.text)
self.assertIn("theme-studio.css", result.text)
self.assertNotIn("Bearer ", result.text)
self.assertNotIn(self.cookie, result.text)
schema = self.app.openapi()["paths"]
self.assertIn("/admin/api/v1/theme", schema)
self.assertIn("patch", schema["/admin/api/v1/theme"])
def test_network_error_keeps_contract_and_does_not_call_services_directly(self):
from site_engine.web.admin.api_client import AdminApi, ApiError
original = AdminApi.call
async def fail(api, method, path, data=None):
if path == "/theme":
raise ApiError(503, {"error": {"code": "api_unavailable", "message": "Нет API"}})
return await original(api, method, path, data)
before = (self.site / "theme.yaml").read_bytes()
with patch.object(AdminApi, "call", fail):
result = self.post(
"theme/save",
{"document": document("dark"), "if_match": self.svc.get()["etag"], "revision": 12},
)
self.assertEqual(result.status_code, 503)
self.assertEqual(result.json()["error"]["code"], "api_unavailable")
self.assertEqual(before, (self.site / "theme.yaml").read_bytes())
def test_explicit_missing_or_bad_theme_is_diagnostic_and_repairable(self):
for text in ("not: [valid", "preset: unknown", "null"):
write(self.site, "theme.yaml", text)
snap = self.svc.get()
self.assertTrue(any(i["severity"] == "error" for i in snap["diagnostics"]))
repaired = self.svc.save(document("dark"), snap["etag"], self.context)
self.assertEqual(repaired["document"]["preset"], "dark")
(self.site / "theme.yaml").unlink()
snap = self.svc.get()
self.assertEqual(snap["etag"], ABSENT)
self.assertTrue(snap["diagnostics"])
self.svc.save(document(), ABSENT, self.context)
+65
View File
@@ -0,0 +1,65 @@
"""Small independent site shared by theme/layout integration and browser acceptance."""
from pathlib import Path
from site_engine.parsing import frontmatter
from site_engine.parsing.yamlio import dump_yaml
def write(root: Path, rel: str, text: str):
path = root / rel
path.parent.mkdir(parents=True, exist_ok=True)
path.write_text(text, encoding="utf-8")
def document(preset="minimal", overrides=None):
return {"schema": 1, "preset": preset, "preset_version": 1, "overrides": overrides or {}}
def seed(root: Path):
write(root, "site.yaml", dump_yaml({
"schema": 1, "name": "Width and theme checks", "theme": {"file": "theme.yaml"},
"base_url": "https://theme.example", "defaults": {"layout": "default"},
}))
write(root, "theme.yaml", dump_yaml(document(overrides={"ui": {"container": {
"mode": "boxed", "max_width": 1080, "gutter": {"desktop": 36, "tablet": 24, "mobile": 16},
}}})))
write(root, "layouts/default/layout.yaml", dump_yaml({
"id": "default", "regions": [
{"id": "header", "fixed": [{"id": "header_fixed", "fragment": "site_header"}]},
{"id": "main", "allow": ["*"]},
{"id": "footer", "fixed": [{"id": "footer_fixed", "fragment": "site_footer"}]},
],
}))
write(root, "layouts/default/layout.html.j2", """<!doctype html><html lang="ru"><head>{{ seo_head() }}{{ assets_head() }}<link rel="stylesheet" href="/assets/check.css"></head><body>{{ region('header') }}<main>{{ region('main') }}</main>{{ region('footer') }}{{ assets_body() }}</body></html>""")
write(root, "assets/check.css", ".f-site_header{position:sticky;top:0;z-index:10;background:var(--color-surface)} .f-richtext p{overflow-wrap:anywhere}")
write(root, "pages/index.md", frontmatter.dumps({
"schema": 1, "title": "Проверка ширины секций", "status": "published",
"regions": {"main": [
{"id": "hero_home", "fragment": "hero", "props": {"title": "Файловая тема и ширина секций", "subtitle": "Общий контракт сборки и preview", "actions": [{"url": "https://example.org", "label": "Основная кнопка"}]},
"layout": {"section_width": "full", "content_width": "boxed"}},
{"id": "section_outer", "fragment": "section", "props": {"title": "Родительская секция", "text": "Ширина фона и содержимого настраиваются отдельно."},
"layout": {"section_width": "fluid", "content_width": "full"}, "slots": {"content": [
{"id": "richtext_child", "fragment": "richtext", "props": {"content": "## Вложенный блок\n\nСобственная ширина вложенного блока."},
"layout": {"section_width": "boxed", "content_width": "fluid"}},
]}},
{"id": "columns_grid", "fragment": "columns", "props": {"count": "2"}, "slots": {"col_1": [
{"id": "richtext_column", "fragment": "richtext", "props": {"content": "Содержимое первой колонки"}},
]}},
*[{"id": f"richtext_long_{i}", "fragment": "richtext", "props": {"content": "## Текстовая секция\n\n" + ("Проверка прокрутки. " * 60)}} for i in range(8)],
]},
}))
write(root, "collections/articles.yaml", dump_yaml({
"id": "articles", "name": "Статьи", "route": "/articles/{slug}/", "body": "markdown",
"fields": [{"key": "title", "type": "text", "required": True}],
}))
write(root, "display/articles.yaml", dump_yaml({
"layout": "default", "regions": {"main": [
{"id": "display_text", "fragment": "richtext", "layout": {"section_width": "full", "content_width": "boxed"}, "props": {"content": {"bind": "entry.body"}}},
]},
}))
write(root, "content/articles/first.md", frontmatter.dumps({
"title": "Первая статья", "status": "published", "regions": {"main": [
{"id": "entry_text", "fragment": "richtext", "layout": {"section_width": "fluid", "content_width": "full"}, "props": {"content": "Текст записи"}},
]},
}, "Текст из Display."))