Add Site Studio themes and Theme Manager

Support categorized fragments, theme presets, block widths, and server-backed theme editing with onboarding and preview.

Include Site Studio, design sources, specification and verification reports; remove the legacy studio-site example.
This commit is contained in:
2026-11-13 14:04:49 +03:00
parent 231490bb7c
commit 0d171915d7
408 changed files with 11812 additions and 550 deletions
+355
View File
@@ -0,0 +1,355 @@
"""Stage 1 catalog acceptance on real FastAPI/preview origins and a git baseline.
PYTHONPATH=src python scripts/qa_fragments_002.py
Artifacts: /tmp/site-engine-fragments-002/{catalog-desktop.png,mobile.png,report.json}
Never reads or modifies the working examples/studio-site/pages/index.md.
"""
from __future__ import annotations
import argparse
import hashlib
import io
import json
import os
import re
import shutil
import subprocess
import sys
import tarfile
import tempfile
import traceback
from pathlib import Path
from unittest.mock import patch
from playwright.sync_api import expect, sync_playwright
from qa_001 import PASSWORD, ROOT, serve
from qa_editor_001 import reserve
sys.path.insert(0, str(ROOT / "tests"))
from test_fragment_catalog_ui import (
LABELS,
PAGE_ID,
PREVIEW,
environment,
seed_catalog,
)
from site_engine.build.pipeline import build_site
from site_engine.parsing import frontmatter
from site_engine.services.auth import hash_password
from site_engine.web.app import create_app
from site_engine.web.preview_app import create_preview_app
def baseline(work: Path) -> Path:
"""Extract committed example only; tar filter rejects traversal and unsafe links."""
archive = subprocess.run(
["git", "archive", "--format=tar", "HEAD", "examples/studio-site"],
cwd=ROOT, check=True, capture_output=True,
)
with tarfile.open(fileobj=io.BytesIO(archive.stdout)) as tar:
tar.extractall(work / "baseline", filter="data")
site = work / "baseline/examples/studio-site"
# Only configuration follows the new runtime contract; content stays at the git baseline.
for name in ("site.yaml", "theme.yaml"):
shutil.copyfile(ROOT / "examples/studio-site" / name, site / name)
return site
def idle(page):
page.wait_for_function("() => window.siteDocument && !window.siteDocument.state.busy")
def source_blocks(page):
source = page.locator("#document-source").input_value()
meta, _ = frontmatter.parse(source)
return source, meta["regions"]["main"]
def select_target(dialog, *, region="", parent="", slot=""):
option = dialog.locator(
f'[data-catalog-target] option[data-region="{region}"][data-parent="{parent}"][data-slot="{slot}"]'
)
expect(option).to_have_count(1)
dialog.locator("[data-catalog-target]").select_option(option.get_attribute("value"))
def visible_ids(dialog):
return set(dialog.locator(".catalog-item[data-fragment]:visible").evaluate_all(
"items => items.map(item => item.dataset.fragment)"
))
def check_geometry(page, dialog, width, report):
geometry = dialog.evaluate("""dialog => {
const r=dialog.getBoundingClientRect();
const body=dialog.querySelector('.modal-body');
return {x:r.x,right:r.right,width:r.width,scroll:body.scrollWidth,client:body.clientWidth,
page:document.documentElement.scrollWidth,viewport:innerWidth};
}""")
assert geometry["x"] >= -1 and geometry["right"] <= width + 1, geometry
assert geometry["scroll"] <= geometry["client"] + 1, geometry
assert geometry["page"] <= width + 1, geometry
report["widths"].append({"width": width, "geometry": geometry})
def catalog_checks(page, expected, width, out, report):
page.set_viewport_size({"width": width, "height": 960 if width == 1440 else 844})
opener = page.locator('[data-catalog-open][data-region="main"]').first
opener.click()
dialog = page.locator("#builder-catalog-dialog")
expect(dialog).to_be_visible()
select_target(dialog, region="main")
search = dialog.locator("[data-catalog-search]")
search.fill("")
dialog.locator('[data-catalog-category=""]').click()
check_geometry(page, dialog, width, report)
for group, label in LABELS.items():
button = dialog.locator(f'[data-catalog-category="{group}"]')
expect(button).to_have_text(label)
expect(button).to_have_count(1)
for fid, (raw, group) in expected.items():
item = dialog.locator(f'[data-fragment="{fid}"]')
expect(item).to_have_attribute("data-category", group)
expect(item).to_have_attribute("data-category-source", raw)
expect(item).to_have_attribute("title", fid)
badge = item.locator("[data-fragment-category]")
expect(badge).to_be_visible()
expect(badge).to_have_text(LABELS[group])
expect(badge).to_have_attribute("title", raw)
expect(dialog.locator('[data-fragment="qa_nested"] b')).to_have_text("Nested catalog card")
expect(dialog.locator('[data-fragment="qa_nested"] [data-fragment-description]')).to_have_text("Sidecar defaults probe")
# Filter expectations come from every rendered item's declared group, including builtins.
all_groups = dialog.locator("[data-fragment]").evaluate_all(
"items => Object.fromEntries(items.map(item => [item.dataset.fragment,item.dataset.category]))"
)
for group in LABELS:
dialog.locator(f'[data-catalog-category="{group}"]').click()
assert visible_ids(dialog) == {fid for fid, value in all_groups.items() if value == group}, (width, group)
expect(dialog.locator("[data-catalog-empty]")).to_be_hidden()
dialog.locator('[data-catalog-category=""]').click()
for group, label in LABELS.items():
for query in (group, label):
search.fill(query)
want = {fid for fid, (_, value) in expected.items() if value == group}
assert want <= visible_ids(dialog), (width, query, want, visible_ids(dialog))
# Raw legacy labels, names, descriptions and IDs remain searchable.
for query, fid in [
("Компоновка", "qa_category_8"), ("Nested catalog card", "qa_nested"),
("Sidecar defaults probe", "qa_nested"), ("qa_nested", "qa_nested"),
]:
search.fill(query)
assert fid in visible_ids(dialog), (width, query)
dialog.locator('[data-catalog-category="content"]').click()
search.fill("qa_nested")
assert not visible_ids(dialog)
expect(dialog.locator("[data-catalog-empty]")).to_be_visible()
dialog.locator('[data-catalog-category=""]').click()
search.fill("no-such-fragment-002")
expect(dialog.locator("[data-catalog-empty]")).to_be_visible()
assert not visible_ids(dialog)
search.fill("")
expect(dialog.locator("[data-catalog-empty]")).to_be_hidden()
select_target(dialog, region="restricted")
assert visible_ids(dialog) == {"qa_legacy"}
search.fill("marketing")
expect(dialog.locator("[data-catalog-empty]")).to_be_visible()
search.fill("")
select_target(dialog, parent="qa_container_block", slot="body")
assert visible_ids(dialog) == {"qa_nested"}
dialog.locator('[data-catalog-category="content"]').click()
expect(dialog.locator("[data-catalog-empty]")).to_be_visible()
dialog.locator('[data-catalog-category=""]').click()
assert visible_ids(dialog) == {"qa_nested"}
select_target(dialog, region="main")
# Include the local card and its localized badge in both requested screenshots.
search.fill("qa_")
dialog.locator('[data-fragment="qa_nested"]').scroll_into_view_if_needed()
page.screenshot(path=str(out / ("catalog-desktop.png" if width == 1440 else "mobile.png")))
for _ in range(5):
page.keyboard.press("Tab")
assert dialog.evaluate("dialog => dialog.contains(document.activeElement)")
page.keyboard.press("Escape")
expect(dialog).to_be_hidden()
expect(opener).to_be_focused()
report["checks"].append(f"catalog_categories_search_empty_targets_keyboard_{width}")
def add_save_reopen(page, site, origin, work, report):
path = site / f"pages/{PAGE_ID}.md"
original = path.read_bytes()
page.set_viewport_size({"width": 1440, "height": 960})
page.locator('[data-catalog-open][data-region="main"]').first.click()
dialog = page.locator("#builder-catalog-dialog")
select_target(dialog, parent="qa_container_block", slot="body")
dialog.locator('[data-catalog-category="marketing"]').click()
dialog.locator("[data-catalog-search]").fill("qa_nested")
form = dialog.locator('[data-catalog-form="qa_nested"]')
for key, value in {**PREVIEW, "fallback": "Schema fallback"}.items():
rendered = "false" if value is False else str(value)
expect(form.locator(f'[name="p.{key}"]')).to_have_value(rendered)
# The real catalog click submits the existing add flow, using its populated hidden form.
with page.expect_response(lambda response: response.url.endswith(f"/pages/{PAGE_ID}/transform")) as response:
dialog.locator('[data-fragment="qa_nested"]').click()
assert response.value.status == 200, response.value.text()
idle(page)
source, blocks = source_blocks(page)
added = blocks[0]["slots"]["body"][-1]
assert added["fragment"] == "qa_nested", added
assert re.fullmatch(r"qa_nested_[a-z0-9]{5}", added["id"]), added
assert {key: added["props"][key] for key in PREVIEW} == PREVIEW, added
assert blocks[1]["fragment"] == "qa_legacy", blocks
assert path.read_bytes() == original, "Add must not write the document"
assert not (site / ".engine/history").exists(), "Add must not create content history"
frame = page.frame_locator("#preview-result iframe")
expect(frame.locator(".qa-nested h2")).to_have_text(PREVIEW["title"])
expect(frame.locator(".qa-legacy")).to_have_text("Legacy flat content")
expect(frame.locator(".qa-nested")).to_have_css("border-top-width", "7px")
assert path.read_bytes() == original, "Preview must not write the document"
report["checks"].extend(["sidecar_defaults_override_per_key_false_zero", "add_preview_does_not_write"])
# A successful transform replaces the catalog HTML, while the chosen group persists.
page.locator('[data-catalog-open][data-region="main"]').first.click()
expect(dialog).to_be_visible()
expect(dialog.locator('[data-catalog-category].active')).to_have_count(1)
expect(dialog.locator('[data-catalog-category].active')).to_have_attribute(
"data-catalog-category", "marketing"
)
dialog.locator("[data-catalog-search]").fill("")
groups = dialog.locator("[data-fragment]").evaluate_all(
"items => Object.fromEntries(items.map(item => [item.dataset.fragment,item.dataset.category]))"
)
assert visible_ids(dialog) == {fid for fid, group in groups.items() if group == "marketing"}
expect(dialog.locator('[data-fragment="qa_nested"]')).to_be_visible()
expect(dialog.locator('[data-fragment="qa_legacy"]')).to_be_hidden()
expect(dialog.locator("[data-catalog-empty]")).to_be_hidden()
page.keyboard.press("Escape")
expect(dialog).to_be_hidden()
assert source_blocks(page)[0] == source
assert path.read_bytes() == original
report["checks"].append("active_category_and_results_preserved_after_add_swap")
with page.expect_response(lambda response: response.url.endswith(f"/pages/{PAGE_ID}/save")) as response:
page.get_by_role("button", name="Сохранить документ", exact=True).click()
assert response.value.status == 200, response.value.text()
idle(page)
expect(page.locator("#editor-result")).to_have_attribute("data-saved", "1")
assert path.read_text() == source
page.reload()
idle(page)
reopened, reopened_blocks = source_blocks(page)
assert reopened == source and reopened_blocks == blocks
expect(page.locator(f'[data-tree-id="{added["id"]}"]')).to_be_visible()
expect(page.frame_locator("#preview-result iframe").locator(".qa-nested h2")).to_have_text(PREVIEW["title"])
report["checks"].append("save_reopen_nested_local_and_legacy_flat")
build_site(site, work / "dist")
public = (work / f"dist/current/{PAGE_ID}/index.html").read_text()
css_paths = list((work / "dist/current/assets").glob("site.*.css"))
assert len(css_paths) == 1, css_paths
css = css_paths[0].read_text()
for fid, selector in [("qa_nested", ".qa-nested"), ("qa_legacy", ".qa-legacy")]:
assert f"/* fragment: {fid} */" in css and selector in css
assert "/assets/" + css_paths[0].name in public
assert "data-preview-" not in public and "data-fragment-category" not in public
assert PREVIEW["title"] in public and "Legacy flat content" in public
public_page = page.context.new_page()
response = public_page.goto(origin + f"/{PAGE_ID}/")
assert response.status == 200, response.status
expect(public_page.locator(".qa-nested")).to_have_css("border-top-width", "7px")
expect(public_page.locator(".qa-legacy")).to_have_css("padding-top", "11px")
public_page.close()
report["checks"].append("static_nested_flat_hashed_css_bundle_served")
def run(out: Path, report):
with tempfile.TemporaryDirectory(prefix="fragments-002-browser-") as tmp:
work = Path(tmp)
site = baseline(work)
expected = seed_catalog(site)
admin_socket, preview_socket = reserve(), reserve()
origin = f"http://127.0.0.1:{admin_socket.getsockname()[1]}"
preview_origin = f"http://127.0.0.1:{preview_socket.getsockname()[1]}"
env = environment(site, work, hash_password(PASSWORD, n=2**10))
env.update(SITE_ADMIN_ORIGIN=origin, SITE_PREVIEW_ORIGIN=preview_origin)
report["fixture"] = "git archive HEAD examples/studio-site + disposable catalog probes"
with (patch.dict(os.environ, env), serve(create_app(), admin_socket),
serve(create_preview_app(), preview_socket), sync_playwright() as pw):
browser_type = getattr(pw, os.environ.get("QA_BROWSER", "chromium"))
options = {"headless": True}
if browser_type.name == "chromium":
options["args"] = ["--no-sandbox", "--no-proxy-server"]
elif browser_type.name == "firefox":
options["firefox_user_prefs"] = {"network.proxy.type": 0}
if os.environ.get("QA_BROWSER_EXECUTABLE"):
options["executable_path"] = os.environ["QA_BROWSER_EXECUTABLE"]
browser = browser_type.launch(**options)
report["browser"] = {"name": browser_type.name, "version": browser.version}
context = browser.new_context(viewport={"width": 1440, "height": 960}, reduced_motion="reduce")
def monitor(page):
page.set_default_timeout(12000)
page.on("pageerror", lambda error: report["errors"].append(str(error)))
page.on("console", lambda message: report["errors"].append(message.text) if message.type == "error" else None)
def native_dialog(dialog):
report["errors"].append(f"Forbidden native dialog: {dialog.type}: {dialog.message}")
dialog.dismiss()
page.on("dialog", native_dialog)
page.on("request", lambda request: report["browser_api_requests"].append(request.url)
if "/admin/api/v1/" in request.url or "authorization" in request.headers else None)
context.on("page", monitor)
page = context.new_page()
try:
page.goto(origin + "/admin/login")
page.locator("[name=login]").fill("admin")
page.locator("[name=password]").fill(PASSWORD)
page.get_by_role("button", name="Войти", exact=True).click()
page.wait_for_url(origin + "/admin/")
response = page.goto(origin + f"/admin/pages/{PAGE_ID}")
assert response.status == 200, response.status
idle(page)
# Compare served assets with exact current sources, including category CSS.
report["runtime_assets"] = {}
for name in ("builder-adapter.css", "builder.js"):
response = page.request.get(origin + "/admin/static/" + name)
assert response.status == 200, (name, response.status)
current = (ROOT / "src/site_engine/web/admin/static" / name).read_bytes()
assert response.body() == current, name
report["runtime_assets"][name] = hashlib.sha256(current).hexdigest()
expect(page.locator("#preview-result iframe")).to_have_attribute("src", re.compile(re.escape(preview_origin)))
for width in (1440, 390):
catalog_checks(page, expected, width, out, report)
add_save_reopen(page, site, origin, work, report)
assert not report["errors"], report["errors"]
assert not report["browser_api_requests"], report["browser_api_requests"]
report["checks"].append("no_native_dialogs_js_errors_or_browser_credentials")
except Exception:
page.screenshot(path=str(out / "failure.png"), full_page=True)
raise
finally:
browser.close()
def main():
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument("--out", type=Path, default=Path("/tmp/site-engine-fragments-002"))
args = parser.parse_args()
args.out.mkdir(parents=True, exist_ok=True)
report = {"status": "running", "checks": [], "widths": [], "errors": [], "browser_api_requests": []}
try:
run(args.out, report)
report["status"] = "passed"
except Exception:
report["status"] = "failed"
report["failure"] = traceback.format_exc()
raise
finally:
(args.out / "report.json").write_text(json.dumps(report, ensure_ascii=False, indent=2), encoding="utf-8")
print(json.dumps({"status": report["status"], "checks": len(report["checks"]), "artifacts": str(args.out)}))
if __name__ == "__main__":
main()