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.
320 lines
14 KiB
Python
320 lines
14 KiB
Python
"""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()
|