Init Project Flexly CMS

This commit is contained in:
Alexey Dudin
2026-11-09 15:32:41 +03:00
commit c778db6208
115 changed files with 5098 additions and 0 deletions
+32
View File
@@ -0,0 +1,32 @@
import datetime as dt
import shutil
import tempfile
import unittest
from pathlib import Path
ROOT = Path(__file__).resolve().parent.parent
EXAMPLE = ROOT / "examples" / "studio-site"
NOW = dt.datetime(2026, 11, 7, 12, 0, 0, tzinfo=dt.timezone.utc)
class SiteTestCase(unittest.TestCase):
"""Каждый тест получает свежую копию примера во временном каталоге."""
def setUp(self):
self._tmp = tempfile.TemporaryDirectory()
self.addCleanup(self._tmp.cleanup)
self.tmp = Path(self._tmp.name)
self.site = self.tmp / "site"
shutil.copytree(EXAMPLE, self.site)
self.out = self.tmp / "dist"
def edit(self, rel: str, old: str, new: str) -> None:
path = self.site / rel
text = path.read_text(encoding="utf-8")
assert old in text, f"{old!r} не найден в {rel}"
path.write_text(text.replace(old, new), encoding="utf-8")
def write(self, rel: str, text: str) -> None:
path = self.site / rel
path.parent.mkdir(parents=True, exist_ok=True)
path.write_text(text, encoding="utf-8")
+174
View File
@@ -0,0 +1,174 @@
import json
import os
import unittest
from helpers import NOW, SiteTestCase
from site_engine.build.pipeline import build_site, preview_page
from site_engine.core.registry import load_site
from site_engine.core.routes import build_route_table
from site_engine.core.validate import validate_workspace
from site_engine.errors import EngineError, Report
class BuildTest(SiteTestCase):
def build(self, out=None):
return build_site(self.site, out or self.out, now=NOW)
def codes_of_failed_build(self):
with self.assertRaises(EngineError) as ctx:
self.build()
return ctx.exception.report.codes()
def test_example_builds_published_pages_only(self):
result = self.build()
cur = self.out / "current"
self.assertTrue(cur.is_symlink())
self.assertEqual(os.readlink(cur), result.build_id)
for rel in ("index.html", "services/index.html", "services/bots/index.html",
"contacts/index.html", "privacy/index.html", "sitemap.xml", "robots.txt"):
self.assertTrue((cur / rel).is_file(), rel)
self.assertFalse((cur / "drafts").exists(), "черновик не должен попадать в релиз")
self.assertEqual(result.pages, 7)
def test_hidden_features_and_disabled_menu_items_are_absent(self):
self.build()
html = (self.out / "current" / "index.html").read_text(encoding="utf-8")
self.assertNotIn("Заглушка", html) # блок с requires: feature.demo
self.assertNotIn("Проекты", html) # пункт меню enabled: false
self.assertIn("Telegram-боты", html) # данные из коллекции без дублей
def test_feature_flag_returns_block(self):
self.edit("site.yaml", "demo: false", "demo: true")
self.build()
html = (self.out / "current" / "index.html").read_text(encoding="utf-8")
self.assertIn("Заглушка", html)
def test_redirect_forms_snapshot_and_sitemap(self):
self.build()
cur = self.out / "current"
self.assertIn("/services/", (cur / "uslugi" / "index.html").read_text(encoding="utf-8"))
forms = list((cur / "_forms").glob("consultation@*.json"))
self.assertEqual(len(forms), 1)
self.assertEqual(json.loads(forms[0].read_text(encoding="utf-8"))["id"], "consultation")
sitemap = (cur / "sitemap.xml").read_text(encoding="utf-8")
self.assertIn("/services/bots/", sitemap)
self.assertNotIn("drafts", sitemap)
self.assertNotIn("uslugi", sitemap)
def test_form_html_carries_version_and_consent(self):
self.build()
html = (self.out / "current" / "contacts" / "index.html").read_text(encoding="utf-8")
self.assertIn("name='form_version'", html)
self.assertIn("href='/privacy/'", html)
self.assertIn("type='checkbox' name='consent' required", html)
def test_build_is_deterministic_without_database(self):
a = self.build(self.tmp / "a")
b = self.build(self.tmp / "b")
self.assertEqual(a.build_id, b.build_id)
self.assertEqual(a.source_hash, b.source_hash)
for rel in ("index.html", "services/ai/index.html", "sitemap.xml"):
self.assertEqual((a.output_dir / rel).read_bytes(), (b.output_dir / rel).read_bytes())
def test_failed_build_does_not_touch_live(self):
first = self.build()
self.edit("display/services.yaml", "{bind: entry.summary}", "{bind: entry.no_such_field}")
with self.assertRaises(EngineError) as ctx:
build_site(self.site, self.out, now=NOW.replace(minute=30))
self.assertIn("E_BIND_MISSING", ctx.exception.report.codes())
self.assertEqual(os.readlink(self.out / "current"), first.build_id)
leftovers = [p.name for p in self.out.iterdir() if p.name.startswith(".staging")]
self.assertEqual(leftovers, [])
def test_unknown_fragment_is_reported(self):
self.edit("pages/contacts.md", "fragment: form", "fragment: no_such_fragment")
self.assertIn("E_FRAGMENT_UNKNOWN", self.codes_of_failed_build())
def test_unknown_prop_and_wrong_type(self):
self.edit("pages/contacts.md", "props: {title: Контакты, lead: Свяжитесь удобным способом.}",
"props: {title: 5, bogus: 1}")
codes = self.codes_of_failed_build()
self.assertIn("E_PROP_UNKNOWN", codes)
self.assertIn("E_TYPE", codes)
def test_template_syntax_in_data_is_rejected(self):
self.edit("display/services.yaml", "title: {bind: entry.title}", "title: '{{ entry.title }}'")
self.assertIn("E_TEMPLATE_IN_DATA", self.codes_of_failed_build())
def test_unknown_requires_feature(self):
self.edit("pages/index.md", "requires: [feature.demo]", "requires: [feature.nope]")
self.assertIn("E_REQUIRES_UNKNOWN", self.codes_of_failed_build())
def test_site_rule_requires_consent_field(self):
self.edit("forms/consultation.yaml", " - {key: consent, type: consent, policy: privacy}\n", "")
self.assertIn("R_form-consent", self.codes_of_failed_build())
def test_draft_may_be_incomplete_but_publishing_it_fails(self):
# ADR-003: у черновика обязательные поля не требуются; в релиз он не попадает
self.write("pages/wip.md", "---\ntitle: WIP\nstatus: draft\nregions:\n main:\n - {id: b_h, fragment: hero}\n---\n")
report = validate_workspace(load_site(self.site))
self.assertEqual(report.errors, [])
self.build() # черновик не рендерится
self.edit("pages/wip.md", "status: draft", "status: published")
self.assertIn("E_REQUIRED", self.codes_of_failed_build())
def test_duplicate_block_ids(self):
self.edit("pages/contacts.md", "id: b_form", "id: b_text")
self.assertIn("E_BLOCK_DUP", self.codes_of_failed_build())
def test_block_without_explicit_id_is_rejected(self):
self.write("pages/noid.md", "---\ntitle: X\nstatus: published\nregions:\n main:\n - {fragment: hero, props: {title: A}}\n---\n")
self.assertIn("E_BLOCK_ID", self.codes_of_failed_build())
def test_link_to_unpublished_page_fails_release(self):
self.edit("pages/index.md", "{page: contacts, label: Обсудить задачу}", "{page: drafts/next, label: Черновик}")
self.assertIn("E_LINK_UNPUBLISHED", self.codes_of_failed_build())
def test_asset_must_exist(self):
self.edit("pages/index.md", "variant: dark\n", "variant: dark\n image: assets/missing.png\n")
self.assertIn("E_ASSET_MISSING", self.codes_of_failed_build())
def test_asset_ok_and_copied(self):
self.edit("pages/index.md", "variant: dark\n", "variant: dark\n image: assets/hero.svg\n image_alt: Баннер\n")
self.build()
self.assertTrue((self.out / "current" / "assets" / "hero.svg").is_file())
def test_empty_collection_hides_list(self):
for f in (self.site / "content" / "services").glob("*.md"):
f.unlink()
self.edit("pages/index.md", "card: direction", "card: direction\n empty: hide")
self.edit("pages/services/index.md", "layout: list", "layout: list\n empty: message\n empty_message: Скоро")
self.build()
self.assertNotIn("Направления", (self.out / "current" / "index.html").read_text(encoding="utf-8"))
self.assertIn("Скоро", (self.out / "current" / "services" / "index.html").read_text(encoding="utf-8"))
def test_entry_regions_override_appends_blocks(self):
self.edit("content/services/bots.md", "order: 1\n",
"order: 1\nregions:\n main:\n - {id: e_note, fragment: disclaimer, props: {text: Только для этой услуги}}\n")
self.build()
self.assertIn("Только для этой услуги", (self.out / "current" / "services" / "bots" / "index.html").read_text(encoding="utf-8"))
self.assertNotIn("Только для этой услуги", (self.out / "current" / "services" / "ai" / "index.html").read_text(encoding="utf-8"))
def test_old_releases_are_pruned_but_current_kept(self):
for minute in range(4):
self.edit("pages/privacy.md", "Текст политики", f"Текст политики v{minute}")
build_site(self.site, self.out, keep=2, now=NOW.replace(minute=minute))
self.edit("pages/privacy.md", f"Текст политики v{minute}", "Текст политики")
builds = [p for p in self.out.iterdir() if p.is_dir() and p.name[0].isdigit()]
self.assertEqual(len(builds), 2)
def test_preview_renders_draft_leniently(self):
html, report = preview_page(self.site, "drafts/next")
self.assertIn("Черновик", html)
self.assertIn("<style>", html)
def test_breadcrumbs_and_active_menu(self):
self.build()
html = (self.out / "current" / "services" / "index.html").read_text(encoding="utf-8")
self.assertIn("aria-label='Хлебные крошки'", html)
self.assertIn("aria-current='page'", html)
if __name__ == "__main__":
unittest.main()
+76
View File
@@ -0,0 +1,76 @@
import threading
import unittest
from helpers import SiteTestCase
from site_engine.errors import ConflictError, EngineError, UnsafePathError
from site_engine.services.content import ABSENT, CONTENT_PREFIXES, ContentService
from site_engine.storage.history import list_versions
from site_engine.storage.locks import SiteLock
class ContentServiceTest(SiteTestCase):
def setUp(self):
super().setUp()
self.svc = ContentService(self.site)
def test_create_requires_absent_marker(self):
with self.assertRaises(ConflictError):
self.svc.write("pages/new.md", "---\ntitle: N\n---\n", if_match="sha256:deadbeef")
etag = self.svc.write("pages/new.md", "---\ntitle: N\n---\n", if_match=ABSENT)
self.assertEqual(self.svc.read("pages/new.md")[1], etag)
def test_if_match_conflict_returns_current_etag(self):
text, etag = self.svc.read("pages/privacy.md")
self.svc.write("pages/privacy.md", text + "\nправка 1\n", if_match=etag)
with self.assertRaises(ConflictError) as ctx:
self.svc.write("pages/privacy.md", text + "\nправка 2\n", if_match=etag) # устаревший etag
self.assertEqual(ctx.exception.current_etag, self.svc.read("pages/privacy.md")[1])
self.assertIn("правка 1", self.svc.read("pages/privacy.md")[0]) # потерянного обновления нет
def test_previous_versions_go_to_history(self):
text, etag = self.svc.read("pages/privacy.md")
self.svc.write("pages/privacy.md", text + "\nv2\n", if_match=etag)
versions = list_versions(self.site, "pages/privacy.md")
self.assertEqual(len(versions), 1)
self.assertEqual(versions[0].read_text(encoding="utf-8"), text)
def test_syntax_error_is_rejected_before_writing(self):
text, etag = self.svc.read("pages/privacy.md")
with self.assertRaises(EngineError) as ctx:
self.svc.write("pages/privacy.md", "---\ntitle: [битый\n---\n", if_match=etag)
self.assertIn("E_YAML", ctx.exception.report.codes())
self.assertEqual(self.svc.read("pages/privacy.md")[0], text)
def test_editor_cannot_write_code_or_escape(self):
editor = ContentService(self.site, allowed_prefixes=CONTENT_PREFIXES)
for rel in ("fragments/hero/template.html.j2", "layouts/default/layout.html.j2", "site.yaml", "../x.md"):
with self.assertRaises(UnsafePathError, msg=rel):
editor.write(rel, "x", if_match=ABSENT)
def test_site_lock_is_exclusive(self):
with SiteLock(self.site):
result = []
def other():
try:
with SiteLock(self.site, timeout=0.2):
result.append("got")
except EngineError:
result.append("timeout")
t = threading.Thread(target=other)
t.start()
t.join()
self.assertEqual(result, ["timeout"])
def test_ten_sequential_writers_lose_no_update(self):
text, etag = self.svc.read("pages/privacy.md")
for i in range(10):
etag = self.svc.write("pages/privacy.md", text + f"\nстрока {i}\n", if_match=etag)
self.assertIn("строка 9", self.svc.read("pages/privacy.md")[0])
self.assertEqual(len(list_versions(self.site, "pages/privacy.md")), 10)
if __name__ == "__main__":
unittest.main()
+77
View File
@@ -0,0 +1,77 @@
import unittest
from helpers import NOW, SiteTestCase
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.errors import Report
CORE_15 = {
"site_header", "site_footer", "hero", "page_header", "section", "columns", "richtext",
"image", "card_grid", "collection_list", "entry_header", "cta_banner", "form", "faq", "disclaimer",
}
class BuiltinFragmentsTest(SiteTestCase):
def test_builtin_set_is_exactly_the_15_from_adr_006(self):
reg = load_site(self.site)
builtin = {f.id for f in reg.fragments.values() if f.builtin}
self.assertEqual(builtin, CORE_15)
def test_all_templates_compile_in_sandbox(self):
reg = load_site(self.site)
renderer = Renderer(reg, build_route_table(reg, Report()), Report(), now=NOW)
for fid in CORE_15:
renderer.env.get_template(f"fragment/{fid}")
def test_every_builtin_has_style_and_flat_unique_id(self):
reg = load_site(self.site)
self.assertEqual(reg.report.errors, [])
for fid in CORE_15:
self.assertTrue(reg.fragments[fid].style, fid)
def test_nested_slots_render(self):
self.write("pages/layout-test.md", """---
title: Колонки
status: published
regions:
main:
- id: s1
fragment: section
props: {title: Секция}
slots:
content:
- id: c1
fragment: columns
props: {count: 2}
slots:
col_1:
- {id: t1, fragment: richtext, props: {content: Левая колонка}}
col_2:
- {id: t2, fragment: richtext, props: {content: Правая колонка}}
---
""")
from site_engine.build.pipeline import build_site
build_site(self.site, self.out, now=NOW)
html = (self.out / "current" / "layout-test" / "index.html").read_text(encoding="utf-8")
self.assertIn("Левая колонка", html)
self.assertIn("f-columns--2", html)
def test_slot_depth_limit(self):
from site_engine.core.models import parse_block
raw = {"id": "a1", "fragment": "section"}
node = raw
for i in range(2, 7):
child = {"id": f"a{i}", "fragment": "section"}
node["slots"] = {"content": [child]}
node = child
report = Report()
parse_block(raw, "t", report)
self.assertIn("E_BLOCK_DEPTH", report.codes())
if __name__ == "__main__":
unittest.main()
+37
View File
@@ -0,0 +1,37 @@
import unittest
from site_engine.parsing import frontmatter
from site_engine.parsing.markdown import render_markdown
from site_engine.parsing.yamlio import YamlError, load_yaml
class ParsingTest(unittest.TestCase):
def test_front_matter_roundtrip_keeps_tree_and_ids(self):
src = "---\ntitle: Тест\nregions:\n main:\n - id: b_1\n fragment: hero\n props: {title: Привет}\n---\nТекст\n"
meta, body = frontmatter.parse(src)
again = frontmatter.parse(frontmatter.dumps(meta, body))
self.assertEqual((meta, body), again)
self.assertEqual(meta["regions"]["main"][0]["id"], "b_1")
def test_no_front_matter_means_body_only(self):
self.assertEqual(frontmatter.parse("просто текст"), ({}, "просто текст"))
def test_yaml_aliases_forbidden(self):
with self.assertRaises(YamlError):
load_yaml("a: &x [1, 2]\nb: *x\n")
def test_yaml_size_limit(self):
with self.assertRaises(YamlError):
load_yaml("a: " + "x" * 1_100_000)
def test_markdown_raw_html_is_escaped(self):
html = render_markdown("<script>alert(1)</script> **ok**")
self.assertNotIn("<script>", html)
self.assertIn("<strong>ok</strong>", html)
def test_markdown_javascript_links_not_linked(self):
self.assertNotIn("<a ", render_markdown("[x](javascript:alert(1))"))
if __name__ == "__main__":
unittest.main()
+50
View File
@@ -0,0 +1,50 @@
import unittest
from helpers import SiteTestCase
from site_engine.core.registry import load_site
from site_engine.core.routes import build_route_table, normalize_route, route_to_output
from site_engine.errors import Report
class RoutesTest(SiteTestCase):
def test_normalize(self):
self.assertEqual(normalize_route("/about"), "/about/")
self.assertEqual(normalize_route("/404.html"), "/404.html")
for bad in ("about/", "/About/", "/a//b/", "/ключ/", "/assets/x/", "/forms/consultation/"):
with self.assertRaises(ValueError, msg=bad):
normalize_route(bad)
def test_output_paths(self):
self.assertEqual(route_to_output("/"), "index.html")
self.assertEqual(route_to_output("/a/b/"), "a/b/index.html")
self.assertEqual(route_to_output("/404.html"), "404.html")
def test_example_routes(self):
report = Report()
table = build_route_table(load_site(self.site), report)
self.assertEqual(report.errors, [])
for route in ("/", "/services/", "/services/bots/", "/contacts/", "/uslugi/"):
self.assertIn(route, table)
self.assertFalse(table["/drafts/next/"].published)
def test_collision_between_page_and_entry(self):
self.write("pages/dup.md", "---\ntitle: Дубль\nroute: /services/bots/\nstatus: published\n---\n")
report = Report()
build_route_table(load_site(self.site), report)
self.assertIn("E_ROUTE_COLLISION", report.codes())
def test_collision_with_redirect(self):
self.write("redirects.yaml", "- {from: /contacts/, to: /services/}\n")
report = Report()
build_route_table(load_site(self.site), report)
self.assertIn("E_ROUTE_COLLISION", report.codes())
def test_page_route_override_for_filename_mismatch(self):
self.write("pages/scenario-legal.md", "---\ntitle: Сценарий\nroute: /scenarios/legal/\nstatus: published\n---\n")
table = build_route_table(load_site(self.site), Report())
self.assertEqual(table["/scenarios/legal/"].page.id, "scenario-legal")
if __name__ == "__main__":
unittest.main()
+75
View File
@@ -0,0 +1,75 @@
import os
import unittest
from helpers import NOW, SiteTestCase
from jinja2.exceptions import SecurityError
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.errors import Report, UnsafePathError
from site_engine.storage.fs import safe_join
class SecurityTest(SiteTestCase):
def test_safe_join_blocks_traversal_and_absolute(self):
self.assertEqual(safe_join(self.site, "pages/index.md"), (self.site / "pages/index.md").resolve())
for bad in ("../x", "pages/../../x", "/etc/passwd", "", "pages/\x00x"):
with self.assertRaises(UnsafePathError, msg=repr(bad)):
safe_join(self.site, bad)
def test_safe_join_blocks_symlink_escape(self):
os.symlink(self.tmp, self.site / "pages" / "escape")
with self.assertRaises(UnsafePathError):
safe_join(self.site, "pages/escape/secret.txt")
def test_jinja_sandbox_blocks_object_introspection(self):
reg = load_site(self.site)
renderer = Renderer(reg, build_route_table(reg, Report()), Report(), now=NOW)
with self.assertRaises(SecurityError):
renderer.env.from_string("{{ ''.__class__.__mro__[1].__subclasses__() }}").render()
def test_templates_have_no_access_to_environment_or_filesystem(self):
reg = load_site(self.site)
renderer = Renderer(reg, build_route_table(reg, Report()), Report(), now=NOW)
with self.assertRaises(Exception):
renderer.env.from_string("{{ os.environ }}").render()
with self.assertRaises(Exception):
renderer.env.from_string("{{ open('/etc/passwd').read() }}").render()
def test_markdown_in_props_cannot_inject_html(self):
self.edit("pages/privacy.md", "Текст политики добавляет", "<script>alert(1)</script> Текст политики добавляет")
from site_engine.build.pipeline import build_site
build_site(self.site, self.out, now=NOW)
html = (self.out / "current" / "privacy" / "index.html").read_text(encoding="utf-8")
self.assertNotIn("<script>alert", html)
def test_url_scheme_javascript_rejected_in_links(self):
from site_engine.build.pipeline import build_site
from site_engine.errors import EngineError
self.edit("pages/index.md", "{page: contacts, label: Обсудить задачу}", "{url: 'javascript:alert(1)', label: X}")
with self.assertRaises(EngineError) as ctx:
build_site(self.site, self.out, now=NOW)
self.assertIn("E_URL_SCHEME", ctx.exception.report.codes())
def test_theme_token_injection_rejected(self):
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'")
with self.assertRaises(EngineError) as ctx:
build_site(self.site, self.out, now=NOW)
self.assertIn("E_THEME_TOKEN", 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")
self.write("fragments/mine/hero/template.html.j2", "<b>x</b>\n")
reg = load_site(self.site)
self.assertIn("E_FRAGMENT_DUP", reg.report.codes())
self.assertTrue(reg.fragments["hero"].builtin)
if __name__ == "__main__":
unittest.main()
+40
View File
@@ -0,0 +1,40 @@
import unittest
from site_engine.core.values import Binding, LinkRef, Query, ValueShapeError, classify
class ValuesTest(unittest.TestCase):
def test_binding_everywhere(self):
self.assertEqual(classify({"bind": "entry.title"}), Binding("entry.title"))
self.assertEqual(classify({"bind": "page.body"}, "markdown"), Binding("page.body"))
def test_binding_root_must_be_known(self):
with self.assertRaises(ValueShapeError):
classify({"bind": "os.environ"})
def test_link_only_for_link_fields(self):
raw = {"page": "contacts", "label": "Связаться"}
self.assertEqual(classify(raw, "link"), LinkRef("page", "contacts", "Связаться", False))
self.assertEqual(classify(raw, None), raw) # для group это просто объект
def test_link_needs_exactly_one_target(self):
with self.assertRaises(ValueShapeError):
classify({"page": "a", "url": "/b"}, "link")
def test_query_mvp_subset(self):
q = classify({"query": {"collection": "services", "where": {"tech": {"in": ["python"]}}, "limit": 3}}, "query")
self.assertEqual(q, Query("services", None, {"tech": {"in": ["python"]}}, None, 3))
def test_query_rejects_deferred_features(self):
for bad in ({"collection": "s", "offset": 1}, {"collection": "s", "paginate": 10},
{"collection": "s", "where": {"x": {"contains": "a"}}}):
with self.assertRaises(ValueShapeError):
classify({"query": bad}, "query")
def test_query_field_rejects_plain_dict(self):
with self.assertRaises(ValueShapeError):
classify({"collection": "s"}, "query")
if __name__ == "__main__":
unittest.main()