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:
@@ -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"])
|
||||
@@ -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()
|
||||
@@ -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("<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()
|
||||
@@ -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
@@ -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__":
|
||||
|
||||
@@ -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")
|
||||
|
||||
@@ -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()
|
||||
@@ -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*")))
|
||||
@@ -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)
|
||||
@@ -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."))
|
||||
Reference in New Issue
Block a user