Files
phelex 0d171915d7 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.
2026-11-13 14:04:49 +03:00

281 lines
16 KiB
Python

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