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
+3 -3
View File
@@ -83,12 +83,12 @@ def main():
"entry_cover",
"benefits",
"related",
"steps",
}
assert not any(fid.startswith("ai_") for fid in reg.fragments)
assert all(
reg.fragments[fid].builtin
for fid in (
"steps",
"hero",
"page_header",
"richtext",
@@ -321,11 +321,11 @@ def main():
expect(page.locator("#inspectpane")).to_contain_text("Название этапа")
expect(page.locator('[data-inspector] [name="p.variant"]')).to_have_count(0)
page.locator('[data-inspector] [name="p.items.0.title"]').fill("QA первый этап")
expect(frame.locator("[data-preview-id=process_steps] h3").first).to_have_text(
expect(frame.locator("[data-preview-id=process_steps] b").first).to_have_text(
"QA первый этап"
)
page.locator('[data-inspector] [name="p.items.0.title"]').fill("Разбираемся в задаче")
expect(frame.locator("[data-preview-id=process_steps] h3").first).to_have_text(
expect(frame.locator("[data-preview-id=process_steps] b").first).to_have_text(
"Разбираемся в задаче"
)
checks.append("dedicated_steps_inspector_and_list_edit_reach_preview")
+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()
+247
View File
@@ -0,0 +1,247 @@
"""Compare production Site Studio with the seed in Chromium, using isolated FastAPI servers."""
from __future__ import annotations
import argparse
import json
import os
import re
import shutil
import tempfile
from pathlib import Path
from unittest.mock import patch
from fastapi import FastAPI
from fastapi.staticfiles import StaticFiles
from playwright.sync_api import expect, sync_playwright
from qa_001 import PASSWORD, ROOT, serve
from qa_ai_studio import LocalURLs
from site_engine.build.pipeline import build_site
from site_engine.core.registry import load_site
from site_engine.services.auth import hash_password
from site_engine.web.app import create_app
def geometry(page, selector):
return page.locator(selector).evaluate_all("""nodes => nodes.map(n => {
const r=n.getBoundingClientRect(), s=getComputedStyle(n);
return {x:r.x,y:r.y,width:r.width,height:r.height,paddingTop:s.paddingTop,
paddingBottom:s.paddingBottom,font:s.font,background:s.backgroundImage,backgroundColor:s.backgroundColor};
})""")
def main():
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument("--out", type=Path, default=Path("/tmp/site-engine-studio-002"))
args = parser.parse_args()
args.out.mkdir(parents=True, exist_ok=True)
report = {"checks": [], "geometry": [], "page_errors": [], "dialogs": [], "http_errors": []}
with tempfile.TemporaryDirectory(prefix="site-studio-002-") as tmp:
work = Path(tmp)
site, dist = work / "site", work / "dist"
shutil.copytree(ROOT / "examples/site-studio", site)
result = build_site(site, dist)
assert result.pages == 13, result.pages
current = dist / "current"
# Every generated local link and asset must resolve. Redirect HTML is included.
for html in current.rglob("*.html"):
parsed = LocalURLs()
parsed.feed(html.read_text())
for url in parsed.urls:
local = url.split("#", 1)[0].split("?", 1)[0]
if not local:
continue
target = (
current / local.lstrip("/") if local.startswith("/") else html.parent / local
)
assert target.is_file() or (target / "index.html").is_file(), (html, url)
assert not (current / "cases/booking").exists()
assert not (current / "services/automation").exists()
assert not (current / "scenarios/real-estate").exists()
assert not (current / "blog").exists() and not (current / "courses").exists()
report["checks"].append(
"13 pages, all local links/assets/redirects, draft and feature exclusion"
)
reference = FastAPI()
reference.mount(
"/", StaticFiles(directory=ROOT / "design/examples/site-studio/preview-dist", html=True)
)
env = {
"SITE_ROOT": str(site),
"SITE_DIST": str(dist),
"SITE_STATE_DIR": str(work / "state"),
"SITE_ADMIN_LOGIN": "admin",
"SITE_ADMIN_PASSWORD_HASH": hash_password(PASSWORD, n=2**10),
"SITE_SECRET_KEY": "site-studio-browser-secret-" * 3,
"SITE_COOKIE_SECURE": "0",
"SITE_ADMIN_ORIGIN": "",
"SITE_PREVIEW_ORIGIN": "",
}
with (
patch.dict(os.environ, env),
serve(create_app()) as origin,
serve(reference) as ref_origin,
sync_playwright() as pw,
):
browser = pw.chromium.launch(channel="chromium", headless=True, args=["--no-sandbox"])
page = browser.new_page(viewport={"width": 1440, "height": 1000})
source = browser.new_page(viewport={"width": 1440, "height": 1000})
page.on("pageerror", lambda e: report["page_errors"].append(str(e)))
page.on("dialog", lambda d: (report["dialogs"].append(d.message), d.dismiss()))
page.on(
"response",
lambda r: (
report["http_errors"].append([r.status, r.url])
if r.status >= 400 and "/forms/" not in r.url
else None
),
)
for width in (1440, 1280, 1024, 768, 390, 360):
for p in (page, source):
p.set_viewport_size({"width": width, "height": 1000})
for route in (
"/",
"/about/",
"/services/",
"/services/bots/",
"/request/",
"/privacy/",
):
page.goto(origin + route)
source.goto(ref_origin + route)
page.locator("img").evaluate_all(
"(nodes)=>Promise.all(nodes.map(n=>n.decode().catch(()=>{})))"
)
source.locator("img").evaluate_all(
"(nodes)=>Promise.all(nodes.map(n=>n.decode().catch(()=>{})))"
)
page.evaluate("window.scrollTo(0,0)")
source.evaluate("window.scrollTo(0,0)")
assert page.evaluate("document.documentElement.scrollWidth <= innerWidth"), (
width,
route,
)
actual = geometry(page, "[data-engine-block]")
expected = geometry(source, "[data-block] > :first-child")
report["geometry"].append(
{"width": width, "route": route, "actual": actual, "source": expected}
)
assert len(actual) == len(expected), (width, route, len(actual), len(expected))
for a, b in zip(actual, expected):
assert abs(a["x"] - b["x"]) < 1 and abs(a["width"] - b["width"]) < 1, (
width,
route,
a,
b,
)
if route != "/request/":
assert (
abs(a["y"] - b["y"]) < 1 and abs(a["height"] - b["height"]) < 1
), (width, route, a, b)
assert a["background"] == b["background"], (width, route, a, b)
# Header alpha uses the theme color and may serialize as color(srgb …).
if a != actual[0]:
assert a["backgroundColor"] == b["backgroundColor"], (
width,
route,
a,
b,
)
if width in (1440, 390):
name = route.strip("/").replace("/", "-") or "home"
page.screenshot(
path=str(args.out / f"public-{name}-{width}.png"), full_page=True
)
source.screenshot(
path=str(args.out / f"source-{name}-{width}.png"), full_page=True
)
report["checks"].append(
f"{width}px: six source/public pages, width geometry and no overflow"
)
page.set_viewport_size({"width": 1440, "height": 1000})
page.goto(origin + "/services/")
page.locator("details summary").focus()
page.keyboard.press("Enter")
assert page.locator("details").evaluate("(n)=>n.open")
page.goto(origin + "/request/")
page.locator('[name="name"]').fill("Демонстрация")
page.locator('[name="email"]').fill("test@example.org")
page.locator('[name="consent"]').check()
with page.expect_response(lambda r: "/forms/form_contact" in r.url) as sent:
page.locator(".demo-form button").click()
assert sent.value.status == 501
page.get_by_role("status").filter(has_text="HTTP 501").wait_for()
assert page.locator('[name="email"]').input_value() == "test@example.org"
assert page.url == origin + "/request/"
report["checks"].append(
"FAQ keyboard/native details; actual form POST=501 with visible feedback and preserved input"
)
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/")
page.goto(origin + "/admin/pages/index")
page.bring_to_front()
assert page.locator("#document-editor").count() or "document-editor" in page.content()
frame = page.frame_locator("#preview-result iframe")
expect(frame.locator(".f-hero h1")).to_have_text("Автоматизируем бизнес с помощью AI")
expect(frame.locator(".f-hero")).to_have_attribute("data-preview-selected", "true")
expect(frame.locator(".f-hero")).to_have_css(
"background-image", re.compile("linear-gradient")
)
expect(frame.locator(".f-hero h1")).to_be_visible()
page.wait_for_load_state("networkidle")
page.screenshot(path=str(args.out / "constructor-1440.png"), full_page=True)
reg = load_site(site)
assert reg.fragments["steps"].builtin and reg.fragments["entry_card"].builtin
report["checks"].append(
"Real admin opens the independent example with shared steps/entry_card"
)
original = (site / "pages/index.md").read_bytes()
page.locator("[data-catalog-open]").first.click()
dialog = page.locator("#builder-catalog-dialog")
dialog.locator("[data-catalog-search]").fill("entry_card")
dialog.locator('[data-fragment="entry_card"]').click()
field = page.locator('[data-inspector] [name="p.entry"]')
expect(field).to_be_visible()
options = page.locator(
'[data-inspector] datalist[id="dl-p.entry"] option'
).evaluate_all("(nodes)=>nodes.map(n=>n.value)")
assert set(options) == {
"services/bots",
"services/ai",
"scenarios/legal",
"cases/ai-reception",
}, options
field.fill("services/bots")
expect(page.locator("#document-source")).to_have_value(
re.compile("entry: services/bots")
)
assert (site / "pages/index.md").read_bytes() == original
expect(frame.locator('.f-entry_card a[href="/services/bots/"]')).to_contain_text(
"Telegram-боты"
)
page.locator("[data-save-document]").click()
expect(page.locator("#editor-result")).to_have_attribute("data-saved", "1")
assert "entry: services/bots" in (site / "pages/index.md").read_text()
page.reload()
assert "entry: services/bots" in page.locator("#document-source").input_value()
report["checks"].append(
"entry_card: only published collection/slug choices, unsaved buffer, explicit Save and reopen"
)
browser.close()
assert not report["page_errors"] and not report["dialogs"] and not report["http_errors"], report
(args.out / "browser.json").write_text(json.dumps(report, ensure_ascii=False, indent=2))
print(
json.dumps(
{"checks": report["checks"], "comparisons": len(report["geometry"])},
ensure_ascii=False,
indent=2,
)
)
if __name__ == "__main__":
main()
+280
View File
@@ -0,0 +1,280 @@
"""Stages 2/3: real public/admin/preview browser checks on a disposable independent site."""
from __future__ import annotations
import argparse
import json
import os
import re
import sys
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 environment
from theme_fixture import document, seed, write
from site_engine.build.pipeline import build_site
from site_engine.core.theme import preset_catalog
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
from site_engine.web.preview_app import create_preview_app
WIDTHS = (1440, 1280, 1024, 1023, 768, 700, 699, 390, 360)
def palette_checks(page, origin, site, work, report):
def rgb(color):
return "rgb(" + ", ".join(str(int(color[i:i + 2], 16)) for i in (1, 3, 5)) + ")"
for name, preset in preset_catalog().items():
overrides = {k: preset[k] for k in ("colors", "type", "ui")} if name == "custom" else {}
write(site, "theme.yaml", dump_yaml(document(name, overrides)))
build_site(site, work / "dist")
page.goto(origin + "/")
expect(page.locator("body")).to_have_css("background-color", rgb(preset["colors"]["background"]))
expect(page.locator("body")).to_have_css("color", rgb(preset["colors"]["text"]))
expect(page.locator(".f-hero h1")).to_have_css("font-weight", str(preset["type"]["headingWeight"]))
expect(page.locator(".f-hero .f-btn")).to_have_css("border-radius", str(preset["ui"]["radius"]) + "px")
write(site, "theme.yaml", dump_yaml(document(overrides={"gradients": {"enabled": True}})))
build_site(site, work / "dist")
page.goto(origin + "/")
assert page.locator(".f-hero .f-btn").evaluate("e=>getComputedStyle(e).backgroundImage").startswith("linear-gradient"), "button gradient not consumed"
write(site, "theme.yaml", dump_yaml(document(overrides={"gradients": {"enabled": False}})))
build_site(site, work / "dist")
page.goto(origin + "/")
expect(page.locator(".f-hero .f-btn")).to_have_css("background-image", "none")
report["checks"].append("6_presets_typography_button_tokens_and_gradient_toggle_rendered")
def public_checks(page, origin, site, work, out, report):
meta, body = frontmatter.parse((site / "pages/index.md").read_text())
meta["regions"]["main"] += [
{"id": f"pair_{outer}_{inner}", "fragment": "hero", "anchor": f"pair_{outer}_{inner}",
"props": {"title": f"{outer} / {inner}"},
"layout": {"section_width": outer, "content_width": inner}}
for outer in ("boxed", "fluid", "full") for inner in ("boxed", "fluid", "full")
]
write(site, "pages/index.md", frontmatter.dumps(meta, body))
for mode in ("boxed", "fluid", "full"):
write(site, "theme.yaml", dump_yaml(document(overrides={"ui": {"container": {
"mode": mode, "max_width": 1080, "gutter": {"desktop": 36, "tablet": 24, "mobile": 16},
}}})))
build_site(site, work / "dist")
for width in WIDTHS:
page.set_viewport_size({"width": width, "height": 960})
response = page.goto(origin + "/")
assert response.status == 200, response.status
gutter = 36 if width >= 1024 else 24 if width >= 700 else 16
assert page.evaluate("document.documentElement.scrollWidth <= innerWidth + 1"), (mode, width, "overflow")
for outer in ("boxed", "fluid", "full"):
expected = min(width - 2 * gutter, 1080) if outer == "boxed" else width - 2 * gutter if outer == "fluid" else width
for inner in ("boxed", "fluid", "full"):
locator = page.locator(f"#pair_{outer}_{inner} + section")
actual = locator.evaluate("e=>({width:e.getBoundingClientRect().width,inner:e.firstElementChild.getBoundingClientRect().width,padding:parseFloat(getComputedStyle(e.firstElementChild).paddingLeft)})")
assert abs(actual["width"] - expected) < 1, (mode, width, outer, inner, actual, expected)
expected_content = min(expected, 1080) if inner == "boxed" else expected
assert abs(actual["inner"] - expected_content) < 1, (width, outer, inner, actual)
assert actual["padding"] == (0 if inner == "full" else gutter), (width, outer, inner, actual)
# Parent full content must not rewrite the nested block's fluid container.
child = page.locator('.f-section .f-richtext [data-engine-container]')
expect(child).to_have_attribute("data-engine-container", "fluid")
expect(child).to_have_css("padding-left", f"{gutter}px")
expect(page.locator('body > .f-site_header [data-engine-container]')).to_have_attribute("data-engine-container", mode)
page.evaluate("scrollTo(0, 550)")
assert abs(page.locator("body > .f-site_header").bounding_box()["y"]) < 1, "sticky header"
if mode == "boxed" and width in (1440, 390, 360):
page.evaluate("scrollTo(0,0)")
page.screenshot(path=str(out / f"public-{width}.png"))
report["geometry"].append({"mode": mode, "width": width, "gutter": gutter, "pairs": 9})
for gutter in (0, 96):
write(site, "theme.yaml", dump_yaml(document(overrides={"ui": {"container": {"gutter": {"desktop": gutter, "tablet": gutter, "mobile": gutter}}}})))
build_site(site, work / "dist")
page.set_viewport_size({"width": 360, "height": 960})
page.goto(origin + "/")
assert page.evaluate("document.documentElement.scrollWidth <= innerWidth + 1"), ("gutter", gutter)
# Return to boxed before the constructor scenario.
write(site, "theme.yaml", dump_yaml(document(overrides={"ui": {"container": {
"mode": "boxed", "max_width": 1080, "gutter": {"desktop": 36, "tablet": 24, "mobile": 16},
}}})))
report["checks"].append("3_global_modes_9_width_pairs_9_breakpoints_nested_and_sticky")
def active_frame(page, identity="hero_home"):
frame = page.frame_locator("#preview-result iframe")
expect(frame.locator(f'[data-preview-id="{identity}"]')).to_have_count(1)
return frame
def source(page):
return page.locator("#document-source").input_value()
def idle(page):
page.wait_for_function("() => window.siteDocument && !window.siteDocument.state.busy")
def constructor_checks(page, origin, preview_origin, site, out, report):
page.set_viewport_size({"width": 1440, "height": 960})
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/")
page.goto(origin + "/admin/pages/index")
idle(page)
expect(page.locator("#preview-result iframe")).to_have_attribute("src", re.compile(re.escape(preview_origin)))
active_frame(page)
reference = page.context.browser.new_page(viewport={"width": 1440, "height": 960})
try:
reference.goto((ROOT / "design/builder-antirion.html").as_uri())
reference.locator('[data-block-width="section_width"]').wait_for()
properties = ["fontFamily", "fontSize", "backgroundColor", "color", "borderRadius", "borderTopWidth", "height", "paddingTop", "paddingLeft"]
for key in ("section_width", "content_width"):
selector = f'[data-block-width="{key}"]'
actual = page.locator("#inspectpane " + selector)
expected = reference.locator(selector)
self_options = actual.locator("option").evaluate_all("items=>items.map(i=>[i.value,i.textContent])")
reference_options = expected.locator("option").evaluate_all("items=>items.map(i=>[i.value,i.textContent])")
assert self_options == reference_options, (key, self_options, reference_options)
metrics = "(el,props)=>Object.fromEntries(props.map(p=>[p,getComputedStyle(el)[p]]))"
a, b = actual.evaluate(metrics, properties), expected.evaluate(metrics, properties)
assert a == b, (key, a, b)
reference.screenshot(path=str(out / "reference-controls-1440.png"))
report["checks"].append("width_controls_options_and_computed_styles_match_original_design")
finally:
reference.close()
requests = []
page.on("request", lambda r: requests.append(r.url) if "/admin/editor/pages/index/" in r.url else None)
count = len(requests)
page.locator('[data-tree-id="section_outer"]').click()
expect(page.locator('#inspectpane [data-block-width="section_width"]')).to_have_value("fluid")
page.locator('[data-tree-id="hero_home"]').click()
expect(active_frame(page).locator('[data-preview-id="hero_home"]')).to_have_attribute("data-preview-selected", "true")
assert len(requests) == count, requests
report["checks"].append("section_selection_local_and_preview_highlights")
before = (site / "pages/index.md").read_bytes()
# Change the long last section while retaining its selected preview and viewport position.
page.locator('[data-tree-id="richtext_long_7"]').click()
frame = active_frame(page, "richtext_long_7")
expect(frame.locator('[data-preview-id="richtext_long_7"]')).to_have_attribute("data-preview-selected", "true")
position = frame.locator("body").evaluate("()=>scrollY")
assert position > 100, position
preview_before = page.locator("#preview-result").get_attribute("data-snapshot")
page.locator('#inspectpane [data-block-width="content_width"]').select_option("full")
expect(page.locator("#document-source")).to_have_value(re.compile("content_width: full"))
page.wait_for_function("old => document.querySelector('#preview-result').dataset.snapshot !== old", arg=preview_before)
frame = active_frame(page, "richtext_long_7")
expect(frame.locator('[data-preview-id="richtext_long_7"]')).to_have_attribute("data-content-width", "full")
expect(frame.locator('[data-preview-id="richtext_long_7"]')).to_have_attribute("data-preview-selected", "true")
page.wait_for_function("() => !window.siteDocument.state.busy")
actual = frame.locator("body").evaluate("()=>scrollY")
assert abs(actual - position) < 3, (position, actual)
assert (site / "pages/index.md").read_bytes() == before
report["checks"].append("width_change_refreshes_preview_preserves_scroll_selection_without_save")
# Constructor/expert share the same YAML; changing props retains explicit layout.
canonical = source(page)
page.locator('[data-editor-mode="expert"]').click()
expect(page.locator("#document-editor")).to_have_attribute("data-mode", "expert")
assert source(page) == canonical
page.locator('[data-editor-mode="constructor"]').click()
expect(page.locator("#document-editor")).to_have_attribute("data-mode", "constructor")
assert source(page) == canonical
page.locator('[data-tree-id="hero_home"]').click()
page.locator('#inspectpane [data-block-width="section_width"]').select_option("fluid")
expect(page.locator("#document-source")).to_have_value(re.compile("section_width: fluid"))
idle(page)
page.locator('#inspectpane [name="p.title"]').fill("Ширина после изменения текста")
expect(page.locator("#document-source")).to_have_value(re.compile("Ширина после изменения текста"))
expect(page.locator('#inspectpane [data-block-width="section_width"]')).to_have_value("fluid")
idle(page)
page.locator('[data-save-document]').click()
expect(page.locator("#buffer-status")).to_have_text("Нет несохранённых изменений")
page.reload()
idle(page)
frame = active_frame(page)
expect(frame.locator('[data-preview-id="hero_home"]')).to_have_attribute("data-preview-selected", "true")
expect(page.locator('#inspectpane [data-block-width="section_width"]')).to_have_value("fluid")
meta, _ = frontmatter.parse((site / "pages/index.md").read_text())
assert meta["regions"]["main"][0]["layout"]["section_width"] == "fluid"
report["checks"].append("constructor_expert_props_save_reopen_keep_layout")
for width in (1440, 1280, 1024, 768, 390, 360):
page.set_viewport_size({"width": width, "height": 960})
assert page.evaluate("document.documentElement.scrollWidth <= innerWidth + 1"), ("admin", width)
if width in (1440, 390):
page.locator('#inspectpane [data-block-width="section_width"]').scroll_into_view_if_needed()
page.screenshot(path=str(out / f"constructor-{width}.png"))
report["checks"].append("admin_6_widths_no_overflow")
def run(out, report):
with tempfile.TemporaryDirectory(prefix="theme-002-browser-") as temp:
work = Path(temp)
site = work / "site"
seed(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)
with (patch.dict(os.environ, env), serve(create_app(), admin_socket),
serve(create_preview_app(), preview_socket), sync_playwright() as pw):
options = {"headless": True, "args": ["--no-sandbox", "--no-proxy-server"]}
if os.environ.get("QA_BROWSER_EXECUTABLE"):
options["executable_path"] = os.environ["QA_BROWSER_EXECUTABLE"]
browser = pw.chromium.launch(**options)
report["browser"] = browser.version
context = browser.new_context(viewport={"width": 1440, "height": 960}, reduced_motion="reduce")
def monitor(page):
page.set_default_timeout(15000)
page.on("pageerror", lambda error: report["errors"].append(str(error)))
page.on("console", lambda m: report["errors"].append(m.text) if m.type == "error" else None)
def dialog(d):
report["errors"].append(f"native dialog: {d.type}")
d.dismiss()
page.on("dialog", dialog)
page.on("request", lambda r: report["browser_api_requests"].append(r.url)
if "/admin/api/v1/" in r.url or "authorization" in r.headers else None)
context.on("page", monitor)
page = context.new_page()
try:
palette_checks(page, origin, site, work, report)
public_checks(page, origin, site, work, out, report)
constructor_checks(page, origin, preview_origin, site, out, report)
assert not report["errors"], report["errors"]
assert not report["browser_api_requests"], report["browser_api_requests"]
report["checks"].append("no_js_errors_native_dialogs_browser_api_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-theme-002"))
args = parser.parse_args()
args.out.mkdir(parents=True, exist_ok=True)
report = {"status": "running", "checks": [], "geometry": [], "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 / "browser.json").write_text(json.dumps(report, ensure_ascii=False, indent=2))
print(json.dumps({"status": report["status"], "checks": len(report["checks"]), "artifacts": str(args.out)}))
if __name__ == "__main__":
main()
+506
View File
@@ -0,0 +1,506 @@
"""Theme Manager: source comparison and real browser/API acceptance on an isolated site."""
from __future__ import annotations
import argparse
import json
import os
import shutil
import socket
import tempfile
from pathlib import Path
from unittest.mock import patch
from fastapi import FastAPI
from fastapi.staticfiles import StaticFiles
from playwright.sync_api import expect, sync_playwright
from qa_001 import PASSWORD, ROOT, serve
from site_engine.parsing.yamlio import dump_yaml, load_yaml
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 click(page, action, identity=None):
selector = f'button[data-action="{action}"]'
if identity is not None:
selector += f'[data-id="{identity}"]'
page.locator(selector).click()
def frame_ready(page):
page.wait_for_function(
"""()=>{const f=document.getElementById('theme-preview'),app=document.getElementById('theme-app'),device=document.querySelector('[data-action=device][aria-pressed=true]')?.dataset.id,target=document.getElementById('theme-preview-target')?.value==='sample'?'sample':'page';return f&&f.dataset.revision===app.dataset.revision&&f.dataset.device===device&&f.dataset.target===target&&+f.dataset.viewportWidth===innerWidth}""",
timeout=20000,
)
page.frame_locator("#theme-preview").locator(
".sample-site, [data-engine-block]"
).first.wait_for(timeout=20000)
# Wait for a resolved resource, not an animation frame inside a passive sandbox.
expect(page.locator("#source-preview")).not_to_have_text(
"Проверяем текущие изменения…", timeout=20000
)
def styles(page, selector):
return page.locator(selector).first.evaluate("""e=>{const s=getComputedStyle(e),r=e.getBoundingClientRect();return {
fontSize:s.fontSize,fontWeight:s.fontWeight,borderRadius:s.borderRadius,
padding:s.padding,background:s.backgroundColor,width:r.width,height:r.height
}}""")
def main():
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument("--out", type=Path, default=Path("/tmp/site-engine-manager-002"))
args = parser.parse_args()
args.out.mkdir(parents=True, exist_ok=True)
report = {
"checks": [],
"comparisons": [],
"page_errors": [],
"csp_errors": [],
"native_dialogs": [],
"unexpected_http": [],
"expected_http": [],
}
with tempfile.TemporaryDirectory(prefix="theme-manager-002-") as tmp:
work = Path(tmp)
site, state = work / "site", work / "state"
shutil.copytree(ROOT / "examples/site-studio", site)
# Use the exact source default for component comparison, with no live publication.
(site / "theme.yaml").write_text(
dump_yaml({"schema": 1, "preset": "minimal", "preset_version": 1, "overrides": {}})
)
env = {
"SITE_ROOT": str(site),
"SITE_DIST": str(work / "dist"),
"SITE_STATE_DIR": str(state),
"SITE_ADMIN_LOGIN": "admin",
"SITE_ADMIN_PASSWORD_HASH": hash_password(PASSWORD, n=2**10),
"SITE_SECRET_KEY": "theme-manager-browser-secret-" * 3,
"SITE_COOKIE_SECURE": "0",
"SITE_ADMIN_ORIGIN": "",
"SITE_PREVIEW_ORIGIN": "",
}
reference = FastAPI()
reference.mount("/", StaticFiles(directory=ROOT / "design", html=True))
with (
patch.dict(os.environ, env),
serve(create_app()) as origin,
serve(reference) as source_origin,
sync_playwright() as pw,
):
browser = pw.chromium.launch(
channel="chromium", headless=True, args=["--no-sandbox", "--no-proxy-server"]
)
context = browser.new_context(viewport={"width": 1440, "height": 1050})
page = context.new_page()
source = context.new_page()
expected_errors = set()
def watch(p):
p.on("pageerror", lambda e: report["page_errors"].append(str(e)))
p.on(
"console",
lambda m: (
report["csp_errors"].append(m.text)
if "Content Security Policy" in m.text or "violates" in m.text
else None
),
)
p.on("dialog", lambda d: (report["native_dialogs"].append(d.message), d.dismiss()))
p.on(
"response",
lambda r: (
(
report["expected_http"]
if any(x in r.url for x in expected_errors)
else report["unexpected_http"]
).append([r.status, r.url.split("?")[0]])
if r.status >= 400 and not r.url.endswith("/favicon.ico")
else None
),
)
watch(page)
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/")
page.goto(origin + "/admin/theme")
source.goto(source_origin + "/theme-studio-antirion.html")
frame_ready(page)
initial = (site / "theme.yaml").read_bytes()
expect(page.locator("[data-action=preset]")).to_have_count(6)
assert page.locator("[data-action=preset]").evaluate_all(
"(ns)=>ns.map(n=>n.dataset.id)"
) == ["minimal", "dark", "editorial", "bold", "natural", "custom"]
# The source shell is deliberately not transplanted: existing admin skin is retained.
original_shell = styles(page, ".sidebar")
for width in (1440, 1280, 1024, 768, 390, 360):
for p in (page, source):
p.set_viewport_size({"width": width, "height": 1050})
for step in range(4):
print(f"source comparison {width}px step {step + 1}", flush=True)
click(page, "step", str(step))
click(source, "step", str(step))
assert page.evaluate("document.documentElement.scrollWidth<=innerWidth+1"), (
width,
step,
)
# Exact designer component metrics, excluding textual changes and the persistent shell.
for selector in (
".theme-heading h1",
".theme-section-head h2",
".step-button",
".preset-option" if step == 0 else ".wz-subtitle",
):
actual, ref = styles(page, selector), styles(source, selector)
for key in ("fontSize", "borderRadius", "padding"):
assert actual[key] == ref[key], (
width,
step,
selector,
key,
actual,
ref,
)
report["comparisons"].append(
{
"width": width,
"step": step,
"selector": selector,
"actual": actual,
"source": ref,
}
)
frame_ready(page)
if step == 0:
actual_hero = (
page.frame_locator("#theme-preview")
.locator(".sample-hero")
.evaluate("e=>getComputedStyle(e).paddingTop")
)
source_hero = source.locator(".sample-hero").evaluate(
"e=>getComputedStyle(e).paddingTop"
)
assert actual_hero == source_hero, (width, actual_hero, source_hero)
actual_nav = (
page.frame_locator("#theme-preview")
.locator(".sample-nav-links")
.evaluate("e=>getComputedStyle(e).display")
)
source_nav = source.locator(".sample-nav-links").evaluate(
"e=>getComputedStyle(e).display"
)
assert actual_nav == source_nav, (width, actual_nav, source_nav)
page.evaluate(
"document.getElementById('theme-preview')?.scrollIntoView({block:'center'})"
)
page.wait_for_timeout(120)
if step == 3:
page.screenshot(path=str(args.out / f"manager-{width}-preview.png"))
page.evaluate("window.scrollTo(0,0)")
page.wait_for_timeout(60)
page.screenshot(
path=str(args.out / f"manager-{width}-step{step + 1}.png"), full_page=True
)
source.screenshot(
path=str(args.out / f"source-{width}-step{step + 1}.png"), full_page=True
)
click(page, "device", "phone")
frame_ready(page)
assert page.locator("#theme-preview").bounding_box()["width"] <= 315
click(page, "device", "desktop")
frame_ready(page)
report["checks"].append(
"24 source UI comparisons × 4 components, six widths, all steps and devices, no overflow"
)
page.set_viewport_size({"width": 1440, "height": 1050})
click(page, "step", "0")
# Every server preset renders through the same stand, with no file writes.
for preset in ("minimal", "dark", "editorial", "bold", "natural", "custom"):
click(page, "preset", preset)
if page.locator("#theme-confirm.open").count():
click(page, "confirm-yes")
frame_ready(page)
expect(page.locator(f"[data-action=preset][data-id={preset}]")).to_have_attribute(
"aria-pressed", "true"
)
page.screenshot(path=str(args.out / f"preset-{preset}.png"))
assert (site / "theme.yaml").read_bytes() == initial
report["checks"].append("Six presets, source confirmation, zero auto-save")
click(page, "step", "1")
field = page.locator('[data-field="color:primary"]')
field.fill("#123456")
frame_ready(page)
expect(page.locator("#source-preview")).to_contain_text("#123456")
# A late response for older input cannot replace the newer snapshot.
held = []
def hold_first(route):
part = route.request.post_data.split('name="payload"', 1)[1].split("\r\n\r\n", 1)[1]
payload = json.loads(part.rsplit("\r\n--", 1)[0])
if not held:
held.append((route, payload["revision"]))
else:
route.continue_()
page.route("**/admin/theme/preview", hold_first)
with page.expect_request("**/admin/theme/preview"):
field.fill("#112233")
page.wait_for_timeout(50)
assert held
field.fill("#334455")
frame_ready(page)
newest = page.locator("#theme-preview").get_attribute("src")
held[0][0].fulfill(
status=200,
content_type="application/json",
body=json.dumps(
{
"url": "about:blank",
"revision": held[0][1],
"interactive": False,
"snapshot": "obsolete",
"expires_at": 0,
}
),
)
page.wait_for_timeout(100)
assert page.locator("#theme-preview").get_attribute("src") == newest
page.unroute("**/admin/theme/preview")
field.fill("#123456")
frame_ready(page)
before_step = page.locator("#theme-preview").element_handle()
click(page, "step", "2")
assert before_step.evaluate("e=>e===document.getElementById('theme-preview')")
click(page, "step", "1")
report["checks"].append(
"Delayed old preview ignored; step selection retains the same iframe"
)
page.locator("#new-color-name").fill("promo_highlight")
click(page, "add-color")
expect(page.locator("[data-extra-color=promo_highlight]")).to_be_visible()
page.locator("[data-gradient-toggle]").check()
click(page, "add-stop")
frame_ready(page)
assert page.locator("[data-gradient-stop]").count() == 3
page.locator("#new-gradient-name").fill("promo_bg")
click(page, "add-gradient")
frame_ready(page)
expect(page.locator("[data-action=gradient-role][data-id=promo_bg]")).to_be_visible()
click(page, "remove-gradient", "promo_bg")
expect(page.locator("button[data-action=confirm-no]")).to_be_focused()
page.keyboard.press("Shift+Tab")
expect(page.locator("[data-action=confirm-yes]")).to_be_focused()
page.keyboard.press("Tab")
expect(page.locator("button[data-action=confirm-no]")).to_be_focused()
page.keyboard.press("Escape")
expect(page.locator("#theme-confirm")).not_to_have_class("open")
click(page, "step", "2")
click(page, "font-pair", "classic")
page.locator('[data-field="type:heading"]').select_option("Arial, sans-serif")
frame_ready(page)
click(page, "step", "3")
click(page, "container-mode", "fluid")
page.locator("[data-container-gutter=mobile]").fill("0")
click(page, "choice", "button:outline")
frame_ready(page)
assert (site / "theme.yaml").read_bytes() == initial
# Real page and component stand are both immutable snapshots of unsaved input.
page.locator("#theme-preview-target").select_option("index")
frame_ready(page)
expect(
page.frame_locator("#theme-preview").locator("[data-engine-block]").first
).to_be_visible()
page.screenshot(path=str(args.out / "real-page-overlay.png"), full_page=True)
page.locator("#theme-preview-target").select_option("sample")
frame_ready(page)
report["checks"].append(
"Colors, custom tokens, gradients/stops, fonts, widths and real-page overlay; keyboard modal containment"
)
with page.expect_download() as dl:
click(page, "yaml-download")
download = dl.value
export = load_yaml(Path(download.path()).read_text())
assert export["schema"] == 1 and export["overrides"]["colors"]["primary"] == "#123456"
assert export["overrides"]["ui"]["container"]["gutter"]["mobile"] == 0
report["checks"].append("Server-validated YAML/export, including zero gutters")
# Deliberately invalid values: visible error and untouched file, then recovery.
click(page, "step", "1")
expected_errors.add("/admin/theme/validate")
page.locator('[data-field="color:primary"]').fill("bad")
expect(page.locator("#theme-diagnostics")).to_contain_text("HEX", timeout=10000)
expect(page.locator("[data-action=save]")).to_be_disabled()
assert (site / "theme.yaml").read_bytes() == initial
page.locator('[data-field="color:primary"]').fill("#123456")
frame_ready(page)
expect(page.locator("[data-action=save]")).to_be_enabled()
# Two real tabs: second commit wins; first receives current snapshot and keeps its edits.
second = context.new_page()
watch(second)
second.goto(origin + "/admin/theme")
frame_ready(second)
click(second, "preset", "dark")
frame_ready(second)
click(second, "save")
expect(second.locator(".save-note")).to_contain_text(
"Сохранено в workspace", timeout=10000
)
expected_errors.add("/admin/theme/save")
click(page, "save")
expect(page.locator("#theme-request-error")).to_contain_text("conflict", timeout=10000)
expect(page.locator('[data-field="color:primary"]')).to_have_value("#123456")
assert load_yaml((site / "theme.yaml").read_text())["preset"] == "dark"
page.screenshot(path=str(args.out / "conflict-keeps-input.png"), full_page=True)
click(page, "conflict-rebase")
click(page, "confirm-yes")
click(page, "save")
expect(page.locator(".save-note")).to_contain_text(
"Сохранено в workspace", timeout=10000
)
assert (
load_yaml((site / "theme.yaml").read_text())["overrides"]["colors"]["primary"]
== "#123456"
)
assert (
json.loads((state / "theme-onboarding.json").read_text())["status"] == "completed"
)
assert not (work / "dist/current").exists()
report["checks"].append(
"Invalid input blocked; two editors 409/current + explicit rebase; Save completes workflow without publishing"
)
# A real HTTP 500, then failed transport: edits and focus survive both.
page.locator('[data-field="color:primary"]').fill("#654321")
frame_ready(page)
page.route(
"**/admin/theme/save",
lambda route: route.fulfill(
status=500,
content_type="application/json",
body=json.dumps(
{
"error": {
"code": "qa_failure",
"message": "Ошибка сохранения · QA",
"request_id": "test-request-id",
}
}
),
),
)
click(page, "save")
expect(page.locator("#theme-request-error")).to_contain_text("test-request-id")
expect(page.locator('[data-field="color:primary"]')).to_have_value("#654321")
page.unroute("**/admin/theme/save")
page.route("**/admin/theme/save", lambda route: route.abort("failed"))
click(page, "save")
expect(page.locator("#theme-request-error")).to_contain_text("network_error")
expect(page.locator('[data-field="color:primary"]')).to_have_value("#654321")
page.unroute("**/admin/theme/save")
assert (
load_yaml((site / "theme.yaml").read_text())["overrides"]["colors"]["primary"]
== "#123456"
)
report["checks"].append(
"HTTP 500/request_id and transport failure visible; unsaved input and saved file preserved"
)
# Leaving asks through source modal; cancellation keeps form.
page.locator('a[href="/admin/pages"]').first.click()
expect(page.locator("#theme-confirm")).to_have_class("open")
click(page, "confirm-no")
expect(page.locator('[data-field="color:primary"]')).to_have_value("#654321")
click(page, "reset-onboarding")
click(page, "confirm-yes")
expect(page.locator('[data-action=step][data-id="0"]')).to_have_attribute(
"aria-current", "step"
)
assert (
json.loads((state / "theme-onboarding.json").read_text())["status"] == "in_progress"
)
assert (
load_yaml((site / "theme.yaml").read_text())["overrides"]["colors"]["primary"]
== "#123456"
)
click(page, "skip")
click(page, "confirm-yes")
page.wait_for_url(origin + "/admin/")
assert json.loads((state / "theme-onboarding.json").read_text())["status"] == "skipped"
report["checks"].append(
"Navigation cancel, repeat and skip persist independently of theme/live"
)
page.goto(origin + "/admin/theme")
frame_ready(page)
assert styles(page, ".sidebar")["background"] == original_shell["background"]
assert not page.evaluate(
"Object.keys(localStorage).some(x=>x.includes('theme-manager'))"
)
assert not report["page_errors"], report["page_errors"]
assert not report["csp_errors"], report["csp_errors"]
assert not report["native_dialogs"], report["native_dialogs"]
assert not report["unexpected_http"], report["unexpected_http"]
second.close()
# Separate-origin immutable preview uses the existing nonce bridge/CSP.
a = socket.socket()
a.bind(("127.0.0.1", 0))
p = socket.socket()
p.bind(("127.0.0.1", 0))
with (
patch.dict(
os.environ,
{
"SITE_ADMIN_ORIGIN": f"http://127.0.0.1:{a.getsockname()[1]}",
"SITE_PREVIEW_ORIGIN": f"http://127.0.0.1:{p.getsockname()[1]}",
},
),
serve(create_app(), a) as admin2,
serve(create_preview_app(), p) as preview2,
):
interactive_context = browser.new_context(viewport={"width": 1440, "height": 1050})
interactive = interactive_context.new_page()
watch(interactive)
interactive.goto(admin2 + "/admin/login")
interactive.locator("[name=login]").fill("admin")
interactive.locator("[name=password]").fill(PASSWORD)
interactive.get_by_role("button", name="Войти", exact=True).click()
interactive.goto(admin2 + "/admin/theme")
frame_ready(interactive)
expect(interactive.locator("#theme-preview")).to_have_attribute(
"sandbox", "allow-scripts allow-same-origin"
)
assert (
interactive.locator("#theme-preview")
.get_attribute("src")
.startswith(preview2 + "/s/")
)
expect(
interactive.frame_locator("#theme-preview").locator(".sample-card")
).to_have_count(3)
interactive.screenshot(path=str(args.out / "separate-origin.png"), full_page=True)
interactive_context.close()
report["checks"].append(
"Passive and separate-origin nonce preview, unchanged admin skin, no storage/native dialogs/CSP/JS/unexpected HTTP errors"
)
assert not report["page_errors"], report["page_errors"]
assert not report["csp_errors"], report["csp_errors"]
assert not report["native_dialogs"], report["native_dialogs"]
assert not report["unexpected_http"], report["unexpected_http"]
browser.close()
(args.out / "browser.json").write_text(json.dumps(report, ensure_ascii=False, indent=2))
print(
json.dumps(
{
"checks": len(report["checks"]),
"comparisons": len(report["comparisons"]),
"out": str(args.out),
},
ensure_ascii=False,
)
)
if __name__ == "__main__":
main()
+28 -3
View File
@@ -1,5 +1,6 @@
"""Install a wheel and smoke real FastAPI outside the checkout, without design/."""
import argparse
import os
import shutil
import subprocess
@@ -11,6 +12,9 @@ ROOT = Path(__file__).resolve().parents[1]
def main():
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument("--site", type=Path, default=ROOT / "examples/studio-site")
args = parser.parse_args()
with tempfile.TemporaryDirectory(prefix="cms-installed-001-") as tmp:
work = Path(tmp)
project = work / "project"
@@ -54,7 +58,7 @@ def main():
check=True,
)
shutil.copytree(
ROOT / "examples/studio-site", work / "site", ignore=shutil.ignore_patterns(".engine")
args.site, work / "site", ignore=shutil.ignore_patterns(".engine")
)
env = dict(
os.environ,
@@ -76,6 +80,15 @@ from site_engine.web.app import create_app
from site_engine.web.preview_app import create_preview_app
import site_engine
assert str(Path(site_engine.__file__).resolve()).startswith(os.environ['PYTHONPATH'])
from site_engine.core.theme import preset_catalog, resolve_theme
from site_engine.errors import Report
for name, preset in preset_catalog().items():
overrides={k:preset[k] for k in ('colors','type','ui')} if name=='custom' else {}
report=Report()
theme=resolve_theme(dict(schema=1,preset=name,preset_version=1,overrides=overrides), report)
assert theme and report.ok,(name,report)
from site_engine.build.pipeline import build_site
build_site(Path(os.environ['SITE_ROOT']),Path(os.environ['SITE_DIST']))
os.environ['SITE_ADMIN_PASSWORD_HASH']=hash_password('installed wheel password',n=2**10)
os.environ['SITE_ADMIN_LOGIN']='admin'
app=create_app()
@@ -84,7 +97,7 @@ with TestClient(app) as client:
assert response.status_code==200
response=client.get('/admin/pages/index')
assert response.status_code==200 and 'document-editor' in response.text
for name in ('antirion-rework.css','shell.css','pages.css','pages.js','admin.css','admin.js','editor.js','builder.css','builder-adapter.css','builder.js','htmx.min.js'):
for name in ('antirion-rework.css','shell.css','pages.css','pages.js','admin.css','admin.js','editor.js','builder.css','builder-adapter.css','builder.js','htmx.min.js','theme-studio.css','theme-studio.js'):
assert client.get('/admin/static/'+name).status_code==200,name
assert 'pages-screen' in client.get('/admin/pages').text
cookie=client.cookies.get('se_session')
@@ -99,8 +112,20 @@ with TestClient(app) as client:
result=preview.get(url)
assert result.status_code==200,result.text
assert 'preview:ready' in result.text and 'data-preview-id' in result.text
assert 'data-section-width' in result.text and '--container-max:' in result.text
assert 'theme-bootstrap' in client.get('/admin/theme').text
import json
document={'schema':1,'preset':'dark','preset_version':1,'overrides':{}}
result=client.post('/admin/theme/validate',data={'csrf':csrf,'payload':json.dumps({'document':document,'revision':17})},headers={'Origin':'http://testserver','HX-Request':'true'})
assert result.status_code==200 and result.json()['revision']==17,result.text
result=client.post('/admin/theme/preview',data={'csrf':csrf,'payload':json.dumps({'document':document,'revision':17})},headers={'Origin':'http://testserver','HX-Request':'true'})
assert result.status_code==200,result.text
with TestClient(create_preview_app()) as preview:
result=preview.get(result.json()['url'])
assert result.status_code==200 and 'sample-site' in result.text,result.text
assert '--color-primary: #a48bfa' in result.text
assert app.state.api_calls>0
print('installed wheel: static, templates, API, bridge, separate preview OK; design/ absent')
print('installed wheel: all theme presets, build, widths, static, templates, Theme Manager, API, bridge, separate preview OK; design/ absent')
"""
subprocess.run([sys.executable, "-c", program], cwd=work, env=env, check=True)