"""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("