Integrate Antirion admin with FastAPI and htmx

Add the shared document API, constructor and expert editors, isolated preview, and fragment catalog metadata with typed block IDs.

Include design references, specification 001, QA scripts, project guidance, and cached Docker dependency installation. Leave example sites for a separate commit.
This commit is contained in:
2026-11-12 21:55:36 +03:00
parent 58cc8090a9
commit 88ac95dd19
260 changed files with 20395 additions and 320 deletions
+62
View File
@@ -0,0 +1,62 @@
"""Prefix the designer's flat CSS rules without requiring browser @scope support."""
import re
TOKENS = re.compile(r'''/\*[\s\S]*?\*/|"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|[{}]''')
def selectors(value):
"""Split a selector list while preserving commas inside :is(), :has(), etc."""
start = depth = 0
for i, char in enumerate(value):
if char in "([":
depth += 1
elif char in ")]":
depth -= 1
elif char == "," and depth == 0:
yield value[start:i]
start = i + 1
yield value[start:]
def scope_css(source, scope, root=None):
"""Keep declarations/media queries; isolate selectors with zero-weight :where.
The source contains ordinary style rules and @media only. Fail on other
at-rules so a designer addition cannot silently produce invalid CSS.
`root` replaces :scope with the same specificity as that pseudo-class.
"""
result, start, opening, depth = [], 0, None, 0
for token in TOKENS.finditer(source):
if token[0] == "{":
if depth == 0:
opening = token.start()
depth += 1
elif token[0] == "}":
depth -= 1
if depth < 0:
raise ValueError("Unbalanced CSS braces")
if depth:
continue
header = source[start:opening]
# Comments/whitespace remain verbatim outside the selector.
prefix = re.match(r"(?:\s|/\*[\s\S]*?\*/)*", header)[0]
header = header[len(prefix):]
body = source[opening + 1:token.start()]
if header.startswith("@media"):
body = scope_css(body, scope, root)
elif header.startswith("@"):
raise ValueError(f"Unsupported CSS rule: {header}")
else:
header = ",".join(
selector.replace(":scope", root or scope)
if ":scope" in selector
else f":where({scope}) {selector.strip()}"
for selector in selectors(header)
)
result.append(prefix + header + "{" + body + "}")
start = token.end()
if depth:
raise ValueError("Unbalanced CSS braces")
result.append(source[start:])
return "".join(result)
+180
View File
@@ -0,0 +1,180 @@
"""Real browser QA on an isolated example; writes screenshots and a JSON report to /tmp."""
from __future__ import annotations
import argparse
import contextlib
import json
import os
import shutil
import socket
import tempfile
import threading
import time
from pathlib import Path
from unittest.mock import patch
import uvicorn
from playwright.sync_api import sync_playwright
from site_engine.services.auth import hash_password
from site_engine.web.app import create_app
ROOT = Path(__file__).resolve().parents[1]
PASSWORD = "temporary browser password"
@contextlib.contextmanager
def serve(app, sock=None):
if sock is None:
sock = socket.socket()
sock.bind(("127.0.0.1", 0))
port = sock.getsockname()[1]
server = uvicorn.Server(uvicorn.Config(app, log_level="error", access_log=False))
thread = threading.Thread(target=server.run, kwargs={"sockets": [sock]}, daemon=True)
thread.start()
for _ in range(1000):
if server.started:
break
if not thread.is_alive():
raise RuntimeError("QA server did not start")
time.sleep(0.01)
try:
yield f"http://127.0.0.1:{port}"
finally:
server.should_exit = True
thread.join(timeout=10)
sock.close()
def main():
parser = argparse.ArgumentParser()
parser.add_argument("--out", type=Path, default=Path("/tmp/site-engine-001-qa"))
args = parser.parse_args()
args.out.mkdir(parents=True, exist_ok=True)
results = {"widths": [], "screens": [], "console_errors": []}
with tempfile.TemporaryDirectory(prefix="cms-browser-") as temp:
work = Path(temp)
site = work / "site"
shutil.copytree(
ROOT / "examples/studio-site", site, ignore=shutil.ignore_patterns(".engine")
)
env = {
"SITE_ROOT": str(site),
"SITE_DIST": str(work / "dist"),
"SITE_STATE_DIR": str(work / "state"),
"SITE_ADMIN_LOGIN": "admin",
"SITE_ADMIN_PASSWORD_HASH": hash_password(PASSWORD, n=2**10),
"SITE_SECRET_KEY": "temporary-browser-qa-secret-" * 2,
"SITE_COOKIE_SECURE": "0",
}
with patch.dict(os.environ, env), serve(create_app()) as origin, sync_playwright() as pw:
browser = pw.chromium.launch(headless=True, args=["--no-sandbox"])
page = browser.new_page(viewport={"width": 1440, "height": 960})
page.on("pageerror", lambda exc: results["console_errors"].append(str(exc)))
page.goto(origin + "/admin/login")
page.screenshot(path=str(args.out / "login.png"))
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/")
for path, name in [
("/admin/", "overview"),
("/admin/pages", "pages"),
("/admin/pages/index", "page"),
("/admin/pages/index/blocks/b_hero", "block"),
("/admin/content", "collections"),
("/admin/content/services", "entries"),
("/admin/content/services/bots", "entry"),
("/admin/publish", "publish"),
]:
response = page.goto(origin + path)
assert response.status == 200, path
page.screenshot(path=str(args.out / (name + ".png")), full_page=True)
results["screens"].append(name)
for width in [1440, 1280, 1024, 768, 390, 360]:
page.set_viewport_size({"width": width, "height": 960})
overflow = page.evaluate(
"document.documentElement.scrollWidth > innerWidth + 1"
)
assert not overflow, (name, width, "horizontal overflow")
results["widths"].append([name, width])
page.set_viewport_size({"width": 1440, "height": 960})
page.goto(origin + "/admin/pages?q=no-such-page")
assert page.get_by_text("Страниц по этим фильтрам нет").is_visible()
page.set_viewport_size({"width": 390, "height": 844})
page.get_by_role("button", name="Открыть меню").click()
assert page.locator(".sidebar.open").count() == 1
page.keyboard.press("Shift+Tab")
assert page.locator(".sidebar").evaluate("(e)=>e.contains(document.activeElement)")
page.keyboard.press("Tab")
expect_focus = page.locator(".sidebar a").first
assert expect_focus.evaluate("(e)=>e===document.activeElement")
page.keyboard.press("Escape")
assert page.locator(".sidebar.open").count() == 0
assert page.get_by_role("button", name="Открыть меню").evaluate(
"(e)=>e===document.activeElement"
)
page.screenshot(path=str(args.out / "mobile.png"))
page.goto(origin + "/admin/pages/index")
page.locator("#preview-result iframe").wait_for()
page.frame_locator("#preview-result iframe").get_by_role("heading").first.wait_for()
assert (
page.frame_locator("#preview-result iframe")
.locator(".f-hero")
.evaluate("(e)=>getComputedStyle(e).backgroundColor")
!= "rgba(0, 0, 0, 0)"
)
page.locator(".topbar [data-action=theme]").click()
assert page.locator("body").get_attribute("data-skin") == "dark"
for mode in ["constructor", "expert"]:
page.get_by_role(
"button", name="Эксперт" if mode == "expert" else "Конструктор", exact=True
).click()
for width in [1440, 1280, 1024, 768, 390, 360]:
page.set_viewport_size({"width": width, "height": 960})
assert not page.evaluate("document.documentElement.scrollWidth>innerWidth+1"), (
mode,
width,
)
results["widths"].append([mode + "-dark", width])
page.screenshot(path=str(args.out / "expert-dark-mobile.png"))
page.goto(origin + "/admin/publish")
invoker = page.get_by_role(
"button", name="Опубликовать текущий черновик сайта", exact=True
)
invoker.click()
page.locator("#confirm-dialog").wait_for(state="visible")
for _ in range(4):
page.keyboard.press("Tab")
assert page.locator("#confirm-dialog").evaluate(
"(e)=>e.contains(document.activeElement)"
)
page.keyboard.press("Escape")
assert not page.locator("#confirm-dialog").is_visible()
assert invoker.evaluate("(e)=>e===document.activeElement")
assert not results["console_errors"], results["console_errors"]
browser.close()
# Reference is rendered from its own assets, independent of the runtime package.
with sync_playwright() as pw:
browser = pw.chromium.launch(headless=True, args=["--no-sandbox"])
page = browser.new_page(viewport={"width": 1440, "height": 960})
page.goto((ROOT / "design/antirion-rework.html").as_uri())
page.screenshot(path=str(args.out / "reference-antirion.png"), full_page=True)
page.set_viewport_size({"width": 390, "height": 844})
page.screenshot(path=str(args.out / "reference-mobile.png"), full_page=True)
browser.close()
(args.out / "report.json").write_text(json.dumps(results, ensure_ascii=False, indent=2))
print(
json.dumps(
{
"screens": len(results["screens"]),
"width_checks": len(results["widths"]),
"artifacts": str(args.out),
}
)
)
if __name__ == "__main__":
main()
+409
View File
@@ -0,0 +1,409 @@
"""Exercise the schema-1 example, public build and real admin on an isolated copy."""
from __future__ import annotations
import argparse
import datetime as dt
import hashlib
import json
import os
import re
import shutil
import tempfile
from html.parser import HTMLParser
from pathlib import Path
from unittest.mock import patch
from urllib.parse import urljoin, urlsplit
from playwright.sync_api import expect, sync_playwright
from qa_001 import PASSWORD, ROOT, serve
from site_engine.build.pipeline import build_site
from site_engine.core.registry import load_site
from site_engine.core.routes import build_route_table
from site_engine.core.validate import validate_release, validate_workspace
from site_engine.errors import EngineError, Report
from site_engine.parsing.frontmatter import parse
from site_engine.parsing.yamlio import load_yaml
from site_engine.services.auth import hash_password
from site_engine.web.app import create_app
EXAMPLE = ROOT / "examples/ai-studio"
NOW = dt.datetime(2026, 11, 12, 12, tzinfo=dt.UTC)
class LocalURLs(HTMLParser):
def __init__(self):
super().__init__()
self.urls = set()
def handle_starttag(self, tag, attrs):
values = dict(attrs)
if tag == "link" and values.get("rel") not in ("stylesheet", "icon"):
return
if tag not in ("a", "img", "link", "script"):
return
value = values.get("href") or values.get("src") or ""
if value and not value.startswith("#") and not urlsplit(value).scheme:
self.urls.add(value)
def files(root):
return {
p.relative_to(root).as_posix(): hashlib.sha256(p.read_bytes()).hexdigest()
for p in root.rglob("*")
if p.is_file() and ".engine" not in p.relative_to(root).parts
}
def main():
parser = argparse.ArgumentParser()
parser.add_argument("--out", type=Path, default=Path("/tmp/ai-studio-qa"))
args = parser.parse_args()
args.out.mkdir(parents=True, exist_ok=True)
baseline = files(EXAMPLE)
report = {"schema": 1, "checks": [], "browser_errors": [], "native_dialogs": []}
checks = report["checks"]
with tempfile.TemporaryDirectory(prefix="ai-studio-qa-") as tmp:
work = Path(tmp)
site, dist = work / "site", work / "dist"
shutil.copytree(EXAMPLE, site, ignore=shutil.ignore_patterns(".engine"))
reg = load_site(site)
issues = Report()
table = build_route_table(reg, issues)
issues.extend(validate_workspace(reg, table))
issues.extend(validate_release(reg, table))
assert not issues.issues, [str(i) for i in issues.issues]
assert load_yaml((site / "site.yaml").read_text())["schema"] == 1
for page_file in (site / "pages").rglob("*.md"):
assert parse(page_file.read_text())[0]["schema"] == 1
local_fragments = [f for f in reg.fragments.values() if not f.builtin]
assert all(f.version == 1 for f in local_fragments)
assert {f.id for f in local_fragments} == {
"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 (
"hero",
"page_header",
"richtext",
"card_grid",
"faq",
"cta_banner",
"section",
"columns",
"collection_list",
)
)
assert set(reg.collections) == {"services", "scenarios", "cases"}
home_blocks = {b.id: b for b in reg.pages["index"].regions["main"]}
assert home_blocks["hero_home"].fragment == "hero"
assert home_blocks["services_list"].fragment == "collection_list"
assert home_blocks["benefits_grid"].fragment == "card_grid"
assert home_blocks["benefits_grid"].props["variant"] == "features"
assert home_blocks["process_steps"].fragment == "steps"
assert "variant" not in home_blocks["process_steps"].props
assert home_blocks["cta_home"].fragment == "cta_banner"
checks.append("schema_1_and_clean_workspace_release_validation")
checks.append("universal_fragment_ids_and_shared_builtins_without_duplicates")
checks.append("design_block_ids_and_fragment_types_kept_separate")
build = build_site(site, dist, now=NOW)
assert not build.report.issues, [str(i) for i in build.report.issues]
assert build.pages == 14, build.pages
repeated = build_site(site, work / "second-dist", now=NOW)
assert repeated.build_id == build.build_id
assert files(repeated.output_dir) == files(build.output_dir)
checks.append("14_pages_and_deterministic_build_without_database")
public = dist / "current"
home = (public / "index.html").read_text()
assert "Telegram-боты" in home and "AI-ассистенты" in home
assert "Почему нам доверяют" in home and "Под задачу, а не по шаблону" in home
for hidden in ("Исследовательские прототипы", "Академия", "Автоматизация процессов"):
assert hidden not in home, hidden
assert not (public / "services/research").exists()
assert not (public / "drafts").exists()
sitemap = (public / "sitemap.xml").read_text()
assert "research" not in sitemap and "academy" not in sitemap
assert "Автоматизация процессов" in (public / "services/index.html").read_text()
checks.append("featured_queries_and_draft_exclusion")
service_html = (public / "services/bots/index.html").read_text()
for text in (
"/assets/bot.svg",
"Интеграция с CRM и расписанием",
"/scenarios/support/",
"/cases/support-assistant/",
"/contacts/",
"Обсудим похожую задачу?",
):
assert text in service_html, text
assert "Поддержка клиентов" in (public / "scenarios/support/index.html").read_text()
case_html = (public / "cases/support-assistant/index.html").read_text()
assert "Демонстрационный кейс" in case_html and "Учебная служба поддержки" in case_html
assert "Корректность источников" in case_html
assert "data-preview-id" not in service_html
assert "<form" not in (public / "contacts/index.html").read_text()
checks.append("covers_benefits_metadata_refs_cta_and_demo_cases_rendered")
about_html = (public / "about/index.html").read_text()
assert "f-columns--2" in about_html
assert "Принципы" in about_html and "/assets/automation.svg" in about_html
assert "f-steps__items" in about_html and "f-card_grid--steps" not in about_html
checks.append("columns_composition_and_dedicated_steps_coexist")
# Failed publication must retain the working release.
broken_file = site / "content/services/bots.md"
saved_source = broken_file.read_bytes()
broken_file.write_text(saved_source.decode().replace("- support\n", "- missing_scenario\n"))
assert broken_file.read_bytes() != saved_source
try:
build_site(site, dist, now=NOW + dt.timedelta(minutes=1))
except EngineError as exc:
assert "E_REF_MISSING" in exc.report.codes(), exc.report.codes()
else:
raise AssertionError("Broken reference accepted")
assert public.resolve() == build.output_dir.resolve()
broken_file.write_bytes(saved_source)
checks.append("broken_reference_rejected_current_preserved")
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": "isolated-ai-studio-browser-" * 3,
"SITE_COOKIE_SECURE": "0",
"SITE_ADMIN_ORIGIN": "",
"SITE_PREVIEW_ORIGIN": "",
}
with patch.dict(os.environ, env), serve(create_app()) as origin, sync_playwright() as pw:
kind = getattr(pw, os.environ.get("QA_BROWSER", "chromium"))
options = {"headless": True}
if kind.name == "chromium":
options["args"] = ["--no-sandbox", "--no-proxy-server"]
if kind.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 = kind.launch(**options)
report["browser"] = {"name": kind.name, "version": browser.version}
context = browser.new_context(viewport={"width": 1440, "height": 960})
page = context.new_page()
page.on(
"pageerror",
lambda e: report["browser_errors"].append(
{"message": str(e), "stack": e.stack, "url": page.url}
),
)
def native(dialog):
report["native_dialogs"].append(dialog.message)
dialog.dismiss()
page.on("dialog", native)
routes = sorted(r.route for r in table.values() if r.published and r.kind != "redirect")
responsive = []
linked_urls = set()
for route in routes:
page.set_viewport_size({"width": 1440, "height": 960})
response = page.goto(origin + route)
assert response.status == 200, route
expect(page.locator("main h1")).to_have_count(1)
for img in page.locator("img").all():
img.scroll_into_view_if_needed()
expect(img).to_have_js_property("complete", True)
assert img.evaluate("e=>e.naturalWidth>0"), route
page.evaluate("window.scrollTo(0,0)")
links = LocalURLs()
links.feed(page.content())
linked_urls.update(urljoin(origin + route, url) for url in links.urls)
for width in (1440, 1024, 768, 390, 360):
page.set_viewport_size({"width": width, "height": 960})
assert page.evaluate("document.documentElement.scrollWidth<=innerWidth+1"), (
route,
width,
)
responsive.append([route, width])
if route in (
"/",
"/about/",
"/services/bots/",
"/cases/support-assistant/",
) and width in (
1440,
390,
):
name = route.strip("/").replace("/", "-") or "home"
page.screenshot(path=str(args.out / f"{name}-{width}.png"), full_page=True)
for url in sorted(linked_urls):
if urlsplit(url).netloc == urlsplit(origin).netloc:
assert context.request.get(url).status == 200, url
report["responsive"] = responsive
report["local_urls_checked"] = len(linked_urls)
checks.append("public_pages_images_links_and_70_responsive_checks")
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/")
for collection in ("services", "scenarios", "cases"):
assert page.goto(origin + "/admin/content/" + collection).status == 200
page.goto(origin + "/admin/pages/about")
about_source = page.locator("#document-source").input_value()
frame = page.frame_locator("#preview-result iframe")
page.locator("[data-tree-id=about_columns]").click()
expect(page.locator("#inspectpane")).to_contain_text("Количество колонок")
expect(frame.locator("[data-preview-id=about_columns]")).to_have_attribute(
"data-preview-selected", "true"
)
page.locator("[data-tree-id=body_about]").click()
expect(frame.locator("[data-preview-id=body_about]")).to_have_attribute(
"data-preview-selected", "true"
)
frame.locator("[data-preview-id=about_image] img").click()
expect(page.locator("[data-tree-id=about_image]")).to_have_class(re.compile("selected"))
expect(frame.locator("[data-preview-id=about_image]")).to_have_attribute(
"data-preview-selected", "true"
)
expect(page.locator("#inspectpane")).to_contain_text("Описание изображения")
page.locator("[data-editor-mode=expert]").click()
page.locator("[data-editor-mode=constructor]").click()
assert page.locator("#document-source").input_value() == about_source
checks.append("nested_columns_bidirectional_selection_and_mode_roundtrip")
page.goto(origin + "/admin/pages/index")
page.locator("[data-catalog-open]").first.click()
dialog = page.locator("#builder-catalog-dialog")
for fid, name, description in (
("collection_list", "Список коллекций", "Карточки, получаемые из collection"),
("section", "Текстовая секция", "Заголовок и содержимое секции"),
("richtext", "Markdown body", "Выводит Markdown из файла страницы"),
("card_grid", "Карточки", "Сетка преимуществ"),
("steps", "Этапы", "Три этапа реализации"),
):
item = dialog.locator(f"[data-fragment='{fid}']")
expect(item).to_be_visible()
expect(item.locator("b")).to_have_text(name)
expect(item.locator("small")).to_have_text(description)
expect(dialog.locator("[data-fragment=catalog]")).to_have_count(0)
page.screenshot(path=str(args.out / "fragment-catalog.png"))
dialog.locator("[data-catalog-search]").fill("получаемые")
expect(dialog.locator("[data-fragment=collection_list]")).to_be_visible()
expect(dialog.locator("[data-fragment=section]")).to_be_hidden()
dialog.locator("[data-catalog-search]").fill("card_grid")
expect(dialog.locator("[data-fragment=card_grid]")).to_be_visible()
expect(dialog.locator("[data-fragment=collection_list]")).to_be_hidden()
dialog.locator("[data-catalog-search]").fill("")
dialog.get_by_role("button", name="Данные", exact=True).click()
expect(dialog.locator("[data-fragment=collection_list]")).to_be_visible()
expect(dialog.locator("[data-fragment=card_grid]")).to_be_hidden()
dialog.get_by_role("button", name="Все", exact=True).click()
dialog.get_by_role("button", name="Отмена", exact=True).click()
checks.append("design_catalog_names_descriptions_search_and_categories")
frame = page.frame_locator("#preview-result iframe")
expect(frame.locator("[data-preview-id=hero_home]")).to_have_attribute(
"data-preview-selected", "true"
)
page.locator("[data-tree-id=services_list]").click()
expect(frame.locator("[data-preview-id=services_list]")).to_have_attribute(
"data-preview-selected", "true"
)
expect(page.locator("#inspectpane")).to_contain_text("Какие записи показать")
page.locator("[data-tree-id=benefits_grid]").click()
expect(frame.locator("[data-preview-id=benefits_grid]")).to_have_attribute(
"data-preview-selected", "true"
)
expect(page.locator("#inspectpane")).to_contain_text("Вариант оформления")
page.locator("[data-tree-id=process_steps]").click()
expect(frame.locator("[data-preview-id=process_steps] .f-steps__item")).to_have_count(3)
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(
"QA первый этап"
)
page.locator('[data-inspector] [name="p.items.0.title"]').fill("Разбираемся в задаче")
expect(frame.locator("[data-preview-id=process_steps] h3").first).to_have_text(
"Разбираемся в задаче"
)
checks.append("dedicated_steps_inspector_and_list_edit_reach_preview")
page.locator("[data-tree-id=hero_home]").click()
source = page.locator("#document-source").input_value()
page.locator("[data-editor-mode=expert]").click()
page.locator("[data-editor-mode=constructor]").click()
assert page.locator("#document-source").input_value() == source
page.screenshot(path=str(args.out / "admin-constructor.png"))
checks.append("three_collections_and_localized_constructor_preview_mode_roundtrip")
page_source = (site / "pages/index.md").read_bytes()
page.locator('[data-inspector] [name="p.image_alt"]').fill("QA описание обложки")
expect(page.locator("#document-source")).to_have_value(
re.compile("QA описание обложки")
)
assert (site / "pages/index.md").read_bytes() == page_source
page.locator("[data-save-document]").click()
expect(page.locator("#editor-result")).to_have_attribute("data-saved", "1")
page_meta, _ = parse((site / "pages/index.md").read_text())
assert page_meta["schema"] == 1
assert page_meta["regions"]["main"][0]["props"]["title"] == {"bind": "page.title"}
assert (public / "index.html").read_text() == home
checks.append("page_edit_explicit_save_schema_bindings_preserved_no_publish")
page.wait_for_load_state("networkidle")
page.goto(origin + "/admin/content/services/bots")
entry_original = (site / "content/services/bots.md").read_bytes()
expect(page.locator("[data-inspector]")).to_contain_text("Краткое описание")
expect(page.locator("[data-inspector]")).to_contain_text("Призыв к действию")
page.locator('[data-inspector] [name="p.summary"]').fill("QA новое описание услуги")
page.locator('[data-inspector] [name="p.cta.title"]').fill("QA новый CTA")
page.locator('[data-inspector] [name="p.cta.actions.0.label"]').fill("QA связаться")
page.locator("[data-inspector]").get_by_role(
"button", name="Применить к буферу", exact=True
).click()
expect(page.locator("#document-source")).to_have_value(re.compile("QA новый CTA"))
assert (site / "content/services/bots.md").read_bytes() == entry_original
page.get_by_role("button", name="Сохранить документ", exact=True).click()
expect(page.locator("#editor-result")).to_have_attribute("data-saved", "1")
meta, _ = parse((site / "content/services/bots.md").read_text())
assert meta["summary"] == "QA новое описание услуги"
assert meta["cta"]["title"] == "QA новый CTA"
assert meta["cta"]["actions"][0] == {"page": "contacts", "label": "QA связаться"}
assert meta["related_scenarios"] == ["support"]
assert (public / "services/bots/index.html").read_text() == service_html
page.wait_for_load_state("networkidle")
checks.append("entry_group_list_link_refs_edit_explicit_save_no_publish")
updated = build_site(site, dist, now=NOW + dt.timedelta(minutes=2))
assert not updated.report.issues
updated_html = (public / "services/bots/index.html").read_text()
assert "QA новое описание услуги" in updated_html and "QA новый CTA" in updated_html
assert "QA связаться" in updated_html
checks.append("saved_content_reaches_public_site_after_build")
csrf = page.locator('form[action="/admin/logout"] [name=csrf]').first.input_value()
response = context.request.post(
origin + "/admin/logout", form={"csrf": csrf}, headers={"Origin": origin}
)
assert response.status == 200 and response.url.endswith("/admin/login")
page.goto(origin + "/admin/pages/index")
page.wait_for_url(origin + "/admin/login")
checks.append("login_preview_and_logout_complete_without_http_500")
assert not report["browser_errors"], report["browser_errors"]
assert not report["native_dialogs"], report["native_dialogs"]
browser.close()
assert files(EXAMPLE) == baseline, "QA modified the example"
checks.append("source_example_unchanged")
(args.out / "report.json").write_text(json.dumps(report, ensure_ascii=False, indent=2) + "\n")
print(
json.dumps(
{
"checks": len(checks),
"pages": 14,
"responsive": len(report["responsive"]),
"out": str(args.out),
},
ensure_ascii=False,
)
)
if __name__ == "__main__":
main()
+379
View File
@@ -0,0 +1,379 @@
"""Chromium against designer original + real FastAPI on disposable content."""
import json
import os
import shutil
import tempfile
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
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
OUT = Path(os.environ.get("QA_BUILDER_OUT", "/tmp/site-engine-builder-001"))
def idle(page):
page.wait_for_function("() => !window.siteDocument.state.busy")
page.wait_for_timeout(60)
def metrics(page, selectors):
return page.evaluate(
"""selectors=>Object.fromEntries(selectors.map(s=>{
const e=document.querySelector(s),c=getComputedStyle(e),r=e.getBoundingClientRect();
return [s,{x:r.x,y:r.y,width:r.width,height:r.height,font:c.fontSize,padding:c.padding,color:c.color,background:c.backgroundColor}];
}))""",
selectors,
)
def main():
OUT.mkdir(exist_ok=True)
report = {"comparisons": [], "flows": [], "errors": []}
with tempfile.TemporaryDirectory(prefix="cms-builder-") as tmp:
work = Path(tmp)
site = work / "site"
shutil.copytree(
ROOT / "examples/studio-site", site, ignore=shutil.ignore_patterns(".engine")
)
a, p = reserve(), reserve()
admin = f"http://127.0.0.1:{a.getsockname()[1]}"
preview = f"http://127.0.0.1:{p.getsockname()[1]}"
env = {
"SITE_ROOT": str(site),
"SITE_DIST": str(work / "dist"),
"SITE_STATE_DIR": str(work / "state"),
"SITE_ADMIN_LOGIN": "admin",
"SITE_ADMIN_PASSWORD_HASH": hash_password(PASSWORD, n=2**10),
"SITE_SECRET_KEY": "builder-browser-qa-secret-" * 3,
"SITE_COOKIE_SECURE": "0",
"SITE_ADMIN_ORIGIN": admin,
"SITE_PREVIEW_ORIGIN": preview,
}
with (
patch.dict(os.environ, env),
serve(create_app(), a),
serve(create_preview_app(), p),
sync_playwright() as pw,
):
browser_type = getattr(pw, os.environ.get("QA_BROWSER", "chromium"))
launch_options = {"headless": True}
if browser_type.name == "chromium":
launch_options["args"] = ["--no-sandbox", "--no-proxy-server"]
elif browser_type.name == "firefox":
launch_options["firefox_user_prefs"] = {"network.proxy.type": 0}
if os.environ.get("QA_BROWSER_EXECUTABLE"):
launch_options["executable_path"] = os.environ["QA_BROWSER_EXECUTABLE"]
browser = browser_type.launch(**launch_options)
report["browser"] = {"name": browser_type.name, "version": browser.version}
context = browser.new_context(
viewport={"width": 1440, "height": 960}, reduced_motion="reduce"
)
page = context.new_page()
page.set_default_timeout(10000)
page.on("pageerror", lambda e: report["errors"].append(str(e)))
page.on(
"console",
lambda m: (
report["errors"].append(m.text)
if m.type == "error" and "422" not in m.text
else None
),
)
page.on("dialog", lambda d: d.accept())
page.goto(admin + "/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(admin + "/admin/")
page.goto(admin + "/admin/pages/index")
page.locator("#preview-result iframe").wait_for()
page.wait_for_load_state("networkidle")
# Switch before any server transform can incidentally repair layout.
for _ in range(2):
page.locator("[data-editor-mode=expert]").click()
expect(page.locator(".builder")).to_have_class("builder expert-layout")
expect(page.locator("#inspectpane #preview-result iframe")).to_be_visible()
page.locator("[data-editor-mode=constructor]").click()
expect(page.locator("#builder > #stagepane")).to_be_visible()
expect(page.locator("#stagepane > .stage-toolbar").first).to_be_visible()
expect(page.locator("#stagepane .pane-foot button")).to_be_visible()
report["flows"].append("pristine_mode_roundtrip_restores_preview_and_toolbar")
reference = browser.new_page(
viewport={"width": 1440, "height": 960}, reduced_motion="reduce"
)
reference.goto((ROOT / "design/builder-antirion.html").as_uri())
reference.locator(".tree-item").first.wait_for()
selectors = [
".treepane",
".inspectpane",
".pane-head",
".tree-layout",
".tree-item",
".stage-toolbar",
".panel-tabs",
".inspect-title h3",
".field input",
".head .button",
]
for theme in ["light", "dark"]:
if theme == "dark":
page.locator(".topbar [data-action=theme]").click()
for width in [1440, 1280, 1024, 768, 390, 360]:
page.set_viewport_size({"width": width, "height": 960})
reference.set_viewport_size({"width": width, "height": 960})
page.wait_for_timeout(80)
live = metrics(page, selectors)
original = metrics(reference, selectors)
if width > 960:
assert page.evaluate(
"Math.abs(document.querySelector('.builder').getBoundingClientRect().bottom-innerHeight)<1"
)
assert page.evaluate("document.documentElement.scrollHeight<=innerHeight+1")
for selector in [
".pane-head",
".tree-layout",
".stage-toolbar",
".panel-tabs",
".inspect-title h3",
".field input",
".head .button",
]:
assert live[selector]["font"] == original[selector]["font"], (
width,
selector,
live[selector],
original[selector],
)
if selector not in [".field input", ".head .button"]:
assert live[selector]["padding"] == original[selector]["padding"], (
width,
selector,
live[selector],
original[selector],
)
# Shared shell is already approved separately; constructor columns retain designer widths.
if width > 960:
for selector in [".treepane", ".inspectpane"]:
assert abs(live[selector]["width"] - original[selector]["width"]) < 1, (
width,
selector,
live[selector],
original[selector],
)
assert not page.evaluate("document.documentElement.scrollWidth>innerWidth+1"), (
width
)
if theme == "light":
for selector in [
".treepane",
".inspectpane",
".tree-layout",
".stage-toolbar",
".field input",
]:
assert (
live[selector]["background"] == original[selector]["background"]
), (width, selector, live[selector], original[selector])
page.screenshot(path=str(OUT / f"constructor-{theme}-{width}.png"))
reference.screenshot(path=str(OUT / f"reference-{width}.png"))
report["comparisons"].append(
{"theme": theme, "width": width, "runtime": live, "reference": original}
)
page.set_viewport_size({"width": 1440, "height": 960})
original = (site / "pages/index.md").read_text()
# Field edits apply automatically. Save and tree selection flush immediately pending changes.
title = page.locator('[data-inspector] [name="p.title"]').first
title.fill("Auto applied builder")
expect(page.locator("#document-source")).to_have_value(
__import__("re").compile("Auto applied builder")
)
expect(
page.frame_locator("#preview-result iframe").get_by_role(
"heading", name="Auto applied builder", exact=True
)
).to_be_visible()
assert (site / "pages/index.md").read_text() == original
expect(title).to_be_focused()
assert title.evaluate("(e)=>e.selectionStart") == len("Auto applied builder")
title.fill("{{ invalid }}")
expect(page.locator(".issues")).to_be_visible()
expect(title).to_have_value("{{ invalid }}")
page.get_by_role("button", name="Сохранить документ", exact=True).click()
expect(page.locator("#editor-notice")).to_contain_text("Изменения не применены")
assert (site / "pages/index.md").read_text() == original
idle(page)
title.fill("Corrected builder")
expect(page.locator("#document-source")).to_have_value(
__import__("re").compile("Corrected builder")
)
expect(page.locator(".issues")).to_have_count(0)
page.locator('[data-inspector] [data-value-picker="p.image"]').click()
page.locator("[data-value-search]").fill("hero")
page.locator('[data-value-choice="assets/hero.svg"]').click()
expect(page.locator("#document-source")).to_have_value(
__import__("re").compile("image: assets/hero.svg")
)
expect(
page.frame_locator("#preview-result iframe").locator('img[src*="hero.svg"]')
).to_be_visible()
report["flows"].append(
"invalid_fields_retained_save_stopped_correction_and_real_asset_picker"
)
title.fill("Flush on selection")
page.locator("button[data-tree-id=b_cta]").click()
expect(page.locator(".tree-node.selected")).to_have_attribute("data-tree-id", "b_cta")
expect(page.locator("#document-source")).to_have_value(
__import__("re").compile("Flush on selection")
)
report["flows"].append("auto_apply_focus_caret_preview_and_selection_flush")
idle(page)
page.locator("[data-viewport=mobile]").click()
page.get_by_role("button", name="Обновить превью", exact=True).click()
expect(page.locator("#preview-result iframe")).to_have_class(
__import__("re").compile("mobile-viewport")
)
page.locator("[data-viewport=desktop]").click()
report["flows"].append("device_retained_after_preview_refresh")
# Real source picker -> API bind object, not flattened resolved text.
page.locator('[data-source-picker="p.title"]').first.click()
page.locator("[data-binding-kind]").select_option("bind")
page.locator("[data-binding-path]").fill("page.title")
page.locator("[data-apply-binding]").click()
expect(page.locator("#document-source")).to_have_value(
__import__("re").compile("bind: page.title")
)
report["flows"].append("binding_picker_preserves_typed_source")
idle(page)
page.get_by_role("button", name="Дублировать", exact=True).click()
expect(page.locator(".tree-node")).to_have_count(6)
duplicate = page.locator(".tree-node.selected").get_attribute("data-tree-id")
assert duplicate != "b_cta"
page.get_by_role("button", name="Удалить", exact=True).click()
page.keyboard.press("Escape")
expect(page.locator(".tree-node")).to_have_count(6)
page.get_by_role("button", name="Удалить", exact=True).click()
page.locator("[data-builder-confirm]").click()
expect(page.locator(".tree-node")).to_have_count(5)
expect(page.locator(".tree-node.selected")).to_have_attribute("data-tree-id", "b_cta")
report["flows"].append("duplicate_selects_new_id_delete_is_memory_only")
idle(page)
# Original catalog: search/category/allowed target; a click inserts with actual manifest preview/defaults.
page.locator(".pane-head [data-catalog-open]").click()
expect(page.locator("#builder-catalog-dialog")).to_be_visible()
page.locator("[data-catalog-search]").fill("no-such-fragment")
expect(page.locator("[data-catalog-empty]")).to_be_visible()
page.locator("[data-catalog-search]").fill("hero")
page.locator('[data-catalog-form=hero] [name="p.title"]').evaluate(
"e=>e.value='{{ invalid }}'"
)
page.locator("[data-fragment=hero]").click()
expect(page.locator("#builder-catalog-dialog .catalog-errors")).to_be_visible()
expect(page.locator('[data-catalog-form=hero] [name="p.title"]')).to_have_value(
"{{ invalid }}"
)
page.locator('[data-catalog-form=hero] [name="p.title"]').fill("Заголовок страницы")
page.locator("[data-catalog-form=hero]").get_by_role(
"button", name="Добавить блок", exact=True
).click()
expect(page.locator(".tree-node")).to_have_count(6)
expect(page.locator('[data-inspector] [name="p.title"]').first).to_have_value(
"Заголовок страницы"
)
assert (site / "pages/index.md").read_text() == original
report["flows"].append("catalog_filters_click_inserts_schema_defaults_no_file_write")
idle(page)
# Actual drag event sequence exercises the same HTML transform as keyboard movement.
last = page.locator(".tree-node.selected").get_attribute("data-tree-id")
page.locator(f"button[data-tree-id={last}]").drag_to(
page.locator("button[data-tree-id=b_hero]")
)
expect(page.locator(".tree-node").first).to_have_attribute("data-tree-id", last)
report["flows"].append("drag_drop_real_reordering")
idle(page)
page.locator('[data-inspector] [name="p.title"]').first.fill("Saved pending edit")
page.get_by_role("button", name="Сохранить документ", exact=True).click()
expect(page.locator("#editor-result .success")).to_be_visible()
assert "Saved pending edit" in (site / "pages/index.md").read_text()
assert not (work / "dist/current").exists()
report["flows"].append("save_flushes_pending_fields_without_publish")
# Source mode preserves bytes; live source validation, diff and reset are real.
idle(page)
page.get_by_role("button", name="Эксперт", exact=True).click()
expect(page.locator("#document-source")).to_be_visible()
before = page.locator("#document-source").input_value()
page.locator("#document-source").fill(
before.replace("title:", "# formatter-check\ntitle:", 1)
)
page.locator("[data-format-source]").click()
expect(page.locator("#document-source")).not_to_have_value(
__import__("re").compile("formatter-check")
)
assert (site / "pages/index.md").read_text() == before
report["flows"].append("explicit_server_format_does_not_save_file")
page.locator("#document-source").fill(before + "\nExpert text")
expect(page.locator("#buffer-status")).to_contain_text("Есть несохранённые")
page.locator("[data-builder-diff]").click()
expect(page.locator(".diff-line.add")).to_contain_text("Expert text")
page.keyboard.press("Escape")
expect(page.locator("[data-builder-diff]")).to_be_focused()
page.locator("[data-builder-reset]").click()
page.locator("[data-builder-confirm]").click()
expect(page.locator("#document-source")).to_have_value(before)
report["flows"].append("expert_source_diff_reset_dialog_focus")
idle(page)
reference.get_by_role("button", name="Эксперт", exact=True).click()
report["expert_comparisons"] = []
for width in [1440, 1280, 1024, 768, 390, 360]:
page.set_viewport_size({"width": width, "height": 960})
reference.set_viewport_size({"width": width, "height": 960})
live = metrics(page, [".treepane", ".inspectpane", ".expert-textarea"])
source = metrics(reference, [".treepane", ".inspectpane", ".expert-textarea"])
expect(page.locator("#inspectpane #preview-result iframe")).to_be_visible()
assert live[".expert-textarea"]["font"] == source[".expert-textarea"]["font"]
assert live[".expert-textarea"]["padding"] == source[".expert-textarea"]["padding"]
if width > 1050:
for selector in [".treepane", ".inspectpane"]:
assert abs(live[selector]["width"] - source[selector]["width"]) < 1
elif width > 700:
assert (
page.locator(".inspectpane").bounding_box()["width"]
== page.locator("#builder").bounding_box()["width"]
)
assert not page.evaluate("document.documentElement.scrollWidth>innerWidth+1")
page.evaluate("scrollTo(0,0)")
page.screenshot(path=str(OUT / f"expert-dark-{width}.png"))
reference.screenshot(path=str(OUT / f"reference-expert-{width}.png"))
report["expert_comparisons"].append(
{"width": width, "runtime": live, "reference": source}
)
page.set_viewport_size({"width": 1440, "height": 960})
page.get_by_role("button", name="Конструктор", exact=True).click()
page.locator("[data-tree-tab=mapping]").click()
expect(page.locator(".mapping-card").first).to_be_visible()
page.locator("[data-focus-bind]").first.click()
expect(page.locator("[data-inspector-panel=bindings]")).to_be_visible()
report["flows"].append("data_map_and_binding_inspector")
assert not report["errors"], report["errors"]
reference.close()
browser.close()
(OUT / "report.json").write_text(json.dumps(report, ensure_ascii=False, indent=2))
print(
json.dumps(
{
"comparisons": len(report["comparisons"]),
"flows": len(report["flows"]),
"artifacts": str(OUT),
}
)
)
if __name__ == "__main__":
main()
+341
View File
@@ -0,0 +1,341 @@
"""Two real HTTP origins and Chromium: buffers, CAS, preview bridge, assets, auth, release."""
from __future__ import annotations
import json
import os
import shutil
import socket
import tempfile
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 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 reserve():
sock = socket.socket()
sock.bind(("127.0.0.1", 0))
return sock
def main():
artifacts = Path("/tmp/site-engine-001-editor-qa")
artifacts.mkdir(exist_ok=True)
checks = []
with tempfile.TemporaryDirectory(prefix="cms-editor-qa-") as tmp:
work = Path(tmp)
site = work / "site"
shutil.copytree(
ROOT / "examples/studio-site", site, ignore=shutil.ignore_patterns(".engine")
)
probe = site / "fragments/qa_probe"
probe.mkdir(parents=True)
(probe / "fragment.yaml").write_text(
"id: qa_probe\nname: Probe\ncategory: test\nfields: []\nslots: {}\n"
)
(probe / "template.html.j2").write_text(
"<section><h2>Script probe</h2><script>window.__site_script_ran=1</script></section>"
)
(probe / "script.js").write_text("window.__site_bundle_ran=1;")
meta, body = frontmatter.parse((site / "pages/index.md").read_text())
meta["regions"]["main"].append({"id": "b_probe", "fragment": "qa_probe"})
(site / "pages/index.md").write_text(frontmatter.dumps(meta, body))
(site / "pages/crlf.md").write_bytes(
b"---\r\ntitle: Exact\r\nstatus: draft\r\n---\r\nBody\r\n"
)
(site / "assets/new.svg").parent.mkdir(exist_ok=True)
(site / "assets/new.svg").write_text(
'<svg xmlns="http://www.w3.org/2000/svg" width="30" height="30"><rect width="30" height="30" fill="red"/></svg>'
)
a, p = reserve(), reserve()
admin = f"http://127.0.0.1:{a.getsockname()[1]}"
preview = f"http://127.0.0.1:{p.getsockname()[1]}"
env = {
"SITE_ROOT": str(site),
"SITE_DIST": str(work / "dist"),
"SITE_STATE_DIR": str(work / "state"),
"SITE_ADMIN_LOGIN": "admin",
"SITE_ADMIN_PASSWORD_HASH": hash_password(PASSWORD, n=2**10),
"SITE_SECRET_KEY": "temporary-editor-browser-secret-" * 2,
"SITE_COOKIE_SECURE": "0",
"SITE_ADMIN_ORIGIN": admin,
"SITE_PREVIEW_ORIGIN": preview,
}
with (
patch.dict(os.environ, env),
serve(create_app(), a),
serve(create_preview_app(), p),
sync_playwright() as pw,
):
browser = pw.chromium.launch(headless=True, args=["--no-sandbox"])
context = browser.new_context(
viewport={"width": 1440, "height": 1000}, reduced_motion="reduce"
)
page = context.new_page()
errors = []
browser_api_requests = []
page.on("pageerror", lambda e: errors.append(str(e)))
page.on(
"request",
lambda r: (
browser_api_requests.append(r.url)
if "/admin/api/v1/" in r.url or "authorization" in r.headers
else None
),
)
page.on("dialog", lambda d: d.accept())
page.goto(admin + "/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(admin + "/admin/")
page.goto(admin + "/admin/pages/index")
source = page.locator("#document-source")
original = (site / "pages/index.md").read_text()
page.locator("#preview-result iframe").wait_for()
frame = page.frame_locator("#preview-result iframe")
expect(frame.locator("[data-preview-id=b_hero]")).to_be_visible()
assert frame.locator("body").evaluate(
"()=>window.__site_script_ran===undefined&&window.__site_bundle_ran===undefined"
)
assert frame.locator("[data-preview-id=b_demo]").count() == 0
checks.extend(["site_scripts_blocked", "feature_hidden_not_rendered"])
assert page.locator("#preview-result iframe").get_attribute("src").startswith(preview)
checks.append("separate_origin_preview")
frame.locator("[data-preview-id=lh_header]").click(position={"x": 10, "y": 10})
expect(page.locator("[data-readonly-inspector]")).to_be_visible()
expect(page.locator("[data-readonly-inspector]")).to_contain_text("layout / default")
checks.append("fixed_readonly_inspector")
tab = context.new_page()
tab.on("dialog", lambda d: d.accept())
tab.goto(admin + "/admin/pages/index")
tab.locator("#preview-result iframe").wait_for()
# Select via the preview bridge; then apply typed values to memory only.
frame.locator("[data-preview-id=b_hero]").click(position={"x": 20, "y": 20})
expect(page.locator(".tree-node.selected")).to_have_attribute("data-tree-id", "b_hero")
expect(page.locator('[data-inspector] [name="p.title"]')).to_be_visible()
page.locator('[data-inspector] [name="p.title"]').fill("Browser buffer hero")
page.locator('[data-inspector] [name="p.image"]').fill("assets/new.svg")
with page.expect_response(lambda r: r.url.endswith("/transform")) as response:
page.get_by_role("button", name=__import__("re").compile("^Применить (к буферу|изменения)$")).click()
assert response.value.status == 200, response.value.text()
expect(source).to_have_value(__import__("re").compile("Browser buffer hero"))
assert (site / "pages/index.md").read_text() == original
expect(
page.frame_locator("#preview-result iframe").get_by_role(
"heading", name="Browser buffer hero", exact=True
)
).to_be_visible()
img = page.frame_locator("#preview-result iframe").locator('img[src*="new.svg"]')
expect(img).to_be_visible()
assert img.evaluate("(e)=>e.complete&&e.naturalWidth>0")
checks.extend(
["preview_to_tree", "constructor_no_write", "unsaved_preview", "workspace_asset"]
)
# Tree navigation scrolls only when needed; the next preview restores that viewport.
page.locator("button[data-tree-id=b_cta]").click()
expect(page.locator(".tree-node.selected")).to_have_attribute("data-tree-id", "b_cta")
expect(
page.frame_locator("#preview-result iframe").locator("[data-preview-id=b_cta]")
).to_have_css("outline-style", "solid")
page.wait_for_timeout(180)
scroll = (
page.frame_locator("#preview-result iframe").locator("body").evaluate("()=>scrollY")
)
assert scroll > 0
page.locator('[data-inspector] [name="p.title"]').fill("Расскажите о сайте")
page.get_by_role("button", name=__import__("re").compile("^Применить (к буферу|изменения)$")).click()
expect(
page.frame_locator("#preview-result iframe").get_by_role(
"heading", name="Расскажите о сайте", exact=True
)
).to_be_visible()
page.wait_for_timeout(180)
restored = (
page.frame_locator("#preview-result iframe").locator("body").evaluate("()=>scrollY")
)
assert abs(scroll - restored) < 4, (scroll, restored)
checks.append("tree_scroll_and_viewport_restore")
# Mode switch changes no serialization; Save commits the exact common buffer.
before = source.input_value()
page.get_by_role("button", name="Эксперт", exact=True).click()
expect(source).to_be_visible()
page.get_by_role("button", name="Конструктор", exact=True).click()
assert source.input_value() == before
page.get_by_role("button", name="Сохранить документ", exact=True).click()
expect(page.locator("#editor-result .success")).to_be_visible()
assert (site / "pages/index.md").read_text() == before
checks.extend(["mode_roundtrip", "explicit_save"])
# Stale second tab must retain its own text and receive both versions.
tab.get_by_role("button", name="Эксперт", exact=True).click()
stale = (
tab.locator("#document-source")
.input_value()
.replace("title: Главная", "title: Second tab")
)
tab.locator("#document-source").fill(stale)
with tab.expect_response(lambda r: r.url.endswith("/save")) as response:
tab.get_by_role("button", name="Сохранить документ", exact=True).click()
assert response.value.status == 409
expect(tab.locator(".conflict-panel")).to_be_visible()
assert tab.locator("#document-source").input_value() == stale
tab.locator("[name=confirm_rebase]").check()
tab.locator("[data-rebase]").click()
assert (site / "pages/index.md").read_text() == before
tab.get_by_role("button", name="Сохранить документ", exact=True).click()
expect(tab.locator("#editor-result .success")).to_be_visible()
checks.append("two_tab_conflict_explicit_rebase")
tab.close()
# Invalid expert text and rejected stale response never destroy the buffer.
page.get_by_role("button", name="Эксперт", exact=True).click()
bad = "---\ntitle: A\ntitle: B\n---\nkeep invalid body"
source.fill(bad)
page.get_by_role("button", name="Проверить", exact=True).click()
expect(page.locator("#editor-result")).to_have_attribute("data-valid", "0")
assert source.input_value() == bad
checks.append("invalid_expert_preserved")
page.screenshot(path=str(artifacts / "invalid-expert.png"), full_page=True)
# Reload (explicitly discard dirty) and check normal entry fields and saving.
page.goto(admin + "/admin/content/services/bots")
page.locator('[data-inspector] [name="p.title"]').fill("Browser entry")
page.get_by_role("button", name=__import__("re").compile("^Применить (к буферу|изменения)$")).click()
expect(page.locator("#document-source")).to_have_value(
__import__("re").compile("Browser entry")
)
page.get_by_role("button", name="Сохранить документ", exact=True).click()
expect(page.locator("#editor-result .success")).to_be_visible()
assert "Browser entry" in (site / "content/services/bots.md").read_text()
checks.append("entry_buffer_save")
page.screenshot(path=str(artifacts / "entry.png"), full_page=True)
# Exact original CRLF bytes survive mode changes and an unmodified Save.
page.goto(admin + "/admin/pages/crlf")
page.get_by_role("button", name="Эксперт", exact=True).click()
page.get_by_role("button", name="Конструктор", exact=True).click()
exact = (site / "pages/crlf.md").read_bytes()
page.get_by_role("button", name="Сохранить документ", exact=True).click()
expect(page.locator("#editor-result .success")).to_be_visible()
assert (site / "pages/crlf.md").read_bytes() == exact
checks.append("exact_crlf_source")
# A delayed old preview response cannot replace a newer expert buffer.
page.wait_for_load_state("networkidle")
held = []
page.route("**/admin/editor/pages/crlf/preview", lambda route: held.append(route))
with page.expect_request(lambda r: r.url.endswith("/admin/editor/pages/crlf/preview")):
page.get_by_role("button", name="Обновить превью", exact=True).click()
page.wait_for_timeout(150)
assert held
page.get_by_role("button", name="Эксперт", exact=True).click()
page.locator("#document-source").fill(
"---\ntitle: New buffer\nstatus: draft\n---\nNewer"
)
held.pop().continue_()
page.wait_for_timeout(300)
assert page.locator("#document-source").input_value().endswith("Newer")
page.unroute("**/admin/editor/pages/crlf/preview")
checks.append("stale_preview_rejected")
# Network failures leave text and download available.
page.route("**/admin/editor/pages/crlf/save", lambda route: route.abort())
page.get_by_role("button", name="Сохранить документ", exact=True).click()
expect(page.locator("#editor-notice")).to_contain_text("Нет связи")
assert page.locator("#document-source").input_value().endswith("Newer")
page.unroute("**/admin/editor/pages/crlf/save")
checks.append("network_error_preserves_buffer")
page.goto(admin + "/admin/pages/index")
page.locator("#preview-result iframe").wait_for()
page.screenshot(path=str(artifacts / "constructor.png"), full_page=True)
# Reject each boundary independently: origin, source, snapshot, revision and unknown block.
page.evaluate("""() => {
const root=document.querySelector('#document-editor'),p=document.querySelector('#preview-result'),f=p.querySelector('iframe');
const data={type:'preview:select',snapshot:p.dataset.snapshot,revision:Number(p.dataset.revision),block:{scope:'page',owner:'index',id:'b_dirs'}};
for(const variant of [
{origin:'https://evil.example',source:f.contentWindow,data},
{origin:root.dataset.previewOrigin,source:window,data},
{origin:root.dataset.previewOrigin,source:f.contentWindow,data:{...data,snapshot:'wrong'}},
{origin:root.dataset.previewOrigin,source:f.contentWindow,data:{...data,revision:999999}},
{origin:root.dataset.previewOrigin,source:f.contentWindow,data:{...data,block:{scope:'page',owner:'index',id:'unknown'}}},
{origin:root.dataset.previewOrigin,source:f.contentWindow,data:{...data,block:{scope:'page',owner:'wrong',id:'b_dirs'}}}
]) window.dispatchEvent(new MessageEvent('message',variant));
}""")
page.wait_for_timeout(120)
assert page.locator(".tree-node.selected").get_attribute("data-tree-id") == "b_hero"
checks.append("message_boundaries_checked")
# Forged messages are rejected, and document content never enters localStorage.
page.evaluate(
"window.dispatchEvent(new MessageEvent('message',{origin:'https://evil.example',source:window,data:{type:'preview:select',snapshot:'wrong',revision:0,block:{scope:'page',owner:'index',id:'b_hero'}}}))"
)
storage = page.evaluate("Object.keys(localStorage)")
assert all(k in ["site-admin-theme", "site-admin-narrow"] for k in storage), storage
checks.extend(["forged_messages_rejected", "no_content_storage"])
page.goto(admin + "/admin/publish")
page.get_by_role(
"button", name="Опубликовать текущий черновик сайта", exact=True
).click()
page.get_by_role("button", name="Продолжить", exact=True).click()
expect(page.locator(".status-published")).to_have_count(1)
assert (work / "dist/current/index.html").exists()
public = (work / "dist/current/index.html").read_text()
assert "data-preview-" not in public and "preview:ready" not in public
checks.append("publish_public_html")
first = (work / "dist/current").resolve().name
(site / "pages/crlf.md").write_text("---\ntitle: Updated draft\nstatus: draft\n---\n")
# A different workspace hash creates a second release, then rollback only switches current.
page.get_by_role(
"button", name="Опубликовать текущий черновик сайта", exact=True
).click()
page.get_by_role("button", name="Продолжить", exact=True).click()
expect(page.get_by_role("button", name="Вернуть этот релиз", exact=True)).to_have_count(
1
)
page.get_by_role("button", name="Вернуть этот релиз", exact=True).click()
with page.expect_response(lambda r: "/admin/publish/rollback/" in r.url):
page.get_by_role("button", name="Продолжить", exact=True).click()
expect(page.locator(".status-published")).to_have_count(1)
assert (work / "dist/current").resolve().name == first
assert "Updated draft" in (site / "pages/crlf.md").read_text()
checks.append("rollback_preserves_workspace")
# Ordinary Save also works with JavaScript disabled.
fallback = browser.new_context(
java_script_enabled=False, storage_state=context.storage_state()
)
plain = fallback.new_page()
plain.goto(admin + "/admin/pages/crlf?mode=expert")
plain.locator("#document-source").fill(
"---\ntitle: Full form save\nstatus: draft\n---\nNo JS"
)
plain.get_by_role("button", name="Сохранить документ", exact=True).click()
assert (site / "pages/crlf.md").read_text().endswith("No JS")
assert plain.locator("#editor-result .success").count() == 1
fallback.close()
checks.append("ordinary_form_without_js")
# Epoch revocation keeps open editor source available for download.
page.goto(admin + "/admin/pages/index")
page.get_by_role("button", name="Эксперт", exact=True).click()
before = page.locator("#document-source").input_value()
page.locator("#document-source").fill(before + "\nunsaved after expiry")
(work / "state/auth_epoch").write_text("1")
page.get_by_role("button", name="Сохранить документ", exact=True).click()
expect(page.locator("#editor-notice")).to_contain_text("Сессия истекла")
assert "unsaved after expiry" in page.locator("#document-source").input_value()
with page.expect_download() as download:
page.get_by_role("button", name="Скачать исходник", exact=True).click()
assert download.value.suggested_filename == "index.md"
checks.append("session_expiry_download")
assert not errors, errors
assert not browser_api_requests, browser_api_requests
checks.append("internal_credentials_never_in_browser")
browser.close()
(artifacts / "report.json").write_text(
json.dumps({"checks": checks, "js_errors": errors}, ensure_ascii=False, indent=2)
)
print(json.dumps({"checks": len(checks), "artifacts": str(artifacts)}))
if __name__ == "__main__":
main()
+363
View File
@@ -0,0 +1,363 @@
"""Stage 2: original/runtime visual measurements and real browser interactions."""
import json
import os
import shutil
import tempfile
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 site_engine.build.pipeline import build_site
from site_engine.services.auth import hash_password
from site_engine.web.app import create_app
OUT = Path("/tmp/site-engine-pages-001")
MEASURE = """names => Object.fromEntries(names.map(name => {
const e=document.querySelector(name), r=e.getBoundingClientRect(), s=getComputedStyle(e);
return [name,{x:r.x,y:r.y,width:r.width,height:r.height,fontSize:s.fontSize,
fontFamily:s.fontFamily,fontWeight:s.fontWeight,lineHeight:s.lineHeight,
padding:s.padding,color:s.color,background:s.backgroundColor}];
}))"""
def settled(page):
page.wait_for_function("() => !document.querySelector('.htmx-request,.htmx-swapping,.htmx-settling')")
def main():
OUT.mkdir(exist_ok=True)
report = {"visual": [], "flows": [], "errors": []}
with tempfile.TemporaryDirectory(prefix="cms-pages-") as temp:
work = Path(temp)
site = work / "site"
shutil.copytree(
ROOT / "examples/studio-site", site, ignore=shutil.ignore_patterns(".engine")
)
env = {
"SITE_ROOT": str(site),
"SITE_DIST": str(work / "dist"),
"SITE_STATE_DIR": str(work / "state"),
"SITE_ADMIN_LOGIN": "admin",
"SITE_ADMIN_PASSWORD_HASH": hash_password(PASSWORD, n=2**10),
"SITE_SECRET_KEY": "temporary-pages-qa-secret-" * 2,
"SITE_COOKIE_SECURE": "0",
"SITE_ADMIN_ORIGIN": "",
"SITE_PREVIEW_ORIGIN": "",
"SITE_PUBLIC_HOST": "",
}
with patch.dict(os.environ, env), serve(create_app()) as origin, sync_playwright() as pw:
browser = pw.chromium.launch(headless=True, args=["--no-sandbox"])
context = browser.new_context(
viewport={"width": 1440, "height": 960}, reduced_motion="reduce"
)
page = context.new_page()
page.on("pageerror", lambda e: report["errors"].append(str(e)))
page.on(
"console", lambda m: report["errors"].append(m.text) if m.type == "error" else None
)
page.on(
"response",
lambda r: (
report["errors"].append(f"{r.status} {r.url}") if r.status >= 400 else None
),
)
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/")
reference = browser.new_page(
viewport={"width": 1440, "height": 960}, reduced_motion="reduce"
)
reference.goto((ROOT / "design/antirion-rework.html").as_uri())
for screen in ["pages", "overview"]:
for p in [page, reference]:
p.set_viewport_size({"width": 1440, "height": 960})
page.goto(origin + ("/admin/pages" if screen == "pages" else "/admin/"))
if screen == "overview":
reference.locator('[data-route="overview"]').first.click()
# Compare original component geometry with identical text/data.
# Only original text and row count change; its markup/CSS/layout stay intact.
reference.evaluate(
"""html => {
const source=new DOMParser().parseFromString(html,'text/html');
for(const selector of ['.headline','.ribbon']) {
const a=document.querySelector(selector), b=source.querySelector(selector);
const ta=document.createTreeWalker(a,NodeFilter.SHOW_TEXT), tb=document.createTreeWalker(b,NodeFilter.SHOW_TEXT);
const texts=[]; while(tb.nextNode())if(tb.currentNode.textContent.trim())texts.push(tb.currentNode.textContent);
let i=0;while(ta.nextNode())if(ta.currentNode.textContent.trim() && i<texts.length)ta.currentNode.textContent=texts[i++];
}
if(source.querySelector('#pageRows')) {
const originals=[...document.querySelectorAll('#pageRows tr')];
const rows=[...source.querySelectorAll('#pageRows tr')];
originals.slice(rows.length).forEach(r=>r.remove());
originals.slice(0,rows.length).forEach((r,i)=>{
const originalCells=r.querySelectorAll('td'), cells=rows[i].querySelectorAll('td');
originalCells.forEach((c,j)=>{
if(j===0){c.querySelector('b').textContent=cells[j].querySelector('b').textContent;c.querySelector('small').textContent=cells[j].querySelector('small').textContent;}
else c.innerHTML=cells[j].innerHTML;
});
});
}
}""",
page.content(),
)
selectors = [
".headline",
".headline h2",
".headline p",
".ribbon",
".ribbon-item .number",
]
if screen == "pages":
selectors += [
".toolbar",
".search",
".select",
".tabs",
".workbench",
".data-table",
".data-table thead",
"#pageRows tr",
".inspect-heading",
".preview",
".device-toggle",
]
else:
selectors += [
".overview-stage",
".overview-lead",
".giant",
".overview-live",
".section-grid",
".section-title",
]
for theme in ["light", "dark"]:
for p in [page, reference]:
p.evaluate("theme=>document.body.dataset.skin=theme", theme)
for width in [1440, 1280, 1024, 768, 390, 360]:
for p in [page, reference]:
p.set_viewport_size({"width": width, "height": 960})
reference.wait_for_timeout(200)
actual, expected = (
page.evaluate(MEASURE, selectors),
reference.evaluate(MEASURE, selectors),
)
# Different inspector text/overview state changes vertical content height.
# Compare stable structure and every visual style, record other coordinates.
for selector in selectors:
props = [
"fontSize",
"fontFamily",
"fontWeight",
"lineHeight",
"padding",
"color",
"background",
"x",
"width",
]
if selector in [
".headline",
".headline h2",
".headline p",
".toolbar",
".search",
".select",
".tabs",
".data-table thead",
"#pageRows tr",
] or (selector == ".ribbon" and screen == "pages"):
props += ["y", "height"]
for prop in props:
a, b = actual[selector][prop], expected[selector][prop]
assert (
abs(a - b) < 0.6 if isinstance(a, (float, int)) else a == b
), (screen, theme, width, selector, prop, a, b)
assert not page.evaluate(
"document.documentElement.scrollWidth>innerWidth+1"
), (screen, theme, width)
report["visual"].append(
{
"screen": screen,
"theme": theme,
"width": width,
"runtime": actual,
"reference": expected,
}
)
if width in [1440, 390]:
page.screenshot(
path=str(OUT / f"{screen}-{theme}-{width}.png"), full_page=True
)
reference.screenshot(
path=str(OUT / f"reference-{screen}-{theme}-{width}.png"),
full_page=True,
)
page.set_viewport_size({"width": 1440, "height": 960})
page.goto(origin + "/admin/pages")
expect(page.locator("#pageRows tr.selected")).to_have_attribute("data-page", "index")
page.locator('#pageRows tr[data-page="contacts"] td').nth(1).click()
expect(page.locator(".inspect-heading h3")).to_have_text("Контакты")
assert "/admin/pages?" in page.url
page.locator('#pageRows tr[data-page="index"]').focus()
page.keyboard.press("Enter")
expect(page.locator(".inspect-heading h3")).to_have_text("Главная")
page.locator('[data-page-device="mobile"]').click()
page.locator("#pageSearch").fill("contacts")
expect(page.locator("#pageRows tr[data-page]")).to_have_count(1)
assert page.locator("#pageSearch").evaluate("e=>e===document.activeElement")
page.locator('#pageRows tr[data-page="contacts"]').click()
expect(page.locator(".inspect-heading h3")).to_have_text("Контакты")
expect(page.locator("[data-page-browser]")).to_have_class("browser mobile")
page.locator("[data-reset-pages]").click()
expect(page.locator("#pageRows tr[data-page]")).to_have_count(5)
expect(page.locator("#pageSearch")).to_have_value("")
settled(page)
expect(page.locator(".inspect-heading h3")).to_have_text("Контакты")
page.get_by_role("tab", name="Черновики").click()
expect(page.locator("#pageRows tr[data-page]")).to_have_count(1)
page.go_back()
expect(page.locator("#pageRows tr[data-page]")).to_have_count(5)
settled(page)
page.go_forward()
expect(page.locator("#pageRows tr[data-page]")).to_have_count(1)
settled(page)
page.locator("[data-reset-pages]").click()
expect(page.locator("#pageRows tr[data-page]")).to_have_count(5)
settled(page)
page.locator("#layoutFilter").select_option("default")
page.wait_for_url("**/*layout=default*")
page.get_by_role("tab", name="В каталоге").click()
expect(page.locator("#pageRows tr[data-page]")).to_have_count(4)
assert "layout=default" in page.url and "status=published" in page.url
report["flows"].append(
"row click/keyboard, inspector, mobile miniature, live search/focus, filters, reset, Back/Forward"
)
page.locator("#pageSearch").fill("no-such-document")
expect(page.locator(".empty h3")).to_have_text("Ничего не найдено")
page.get_by_role("link", name="Сбросить фильтры", exact=True).click()
expect(page.locator("#pageRows tr[data-page]")).to_have_count(5)
settled(page)
for opener, dialog in [
("pages-info-dialog", "pages-info-dialog"),
("page-details-dialog", "page-details-dialog"),
("new-page-dialog", "new-page-dialog"),
]:
trigger = page.locator(f'[data-open-modal="{opener}"]')
before = list(site.glob("pages/**/*.md"))
trigger.click()
expect(page.locator("#" + dialog)).to_be_visible()
page.keyboard.press("Tab")
assert page.locator("#" + dialog).evaluate("e=>e.contains(document.activeElement)")
page.screenshot(path=str(OUT / (dialog + ".png")))
if dialog == "new-page-dialog":
page.set_viewport_size({"width": 390, "height": 844})
assert not page.evaluate("document.documentElement.scrollWidth>innerWidth+1")
page.screenshot(path=str(OUT / "new-page-mobile.png"))
page.set_viewport_size({"width": 1440, "height": 960})
page.keyboard.press("Escape")
expect(page.locator("#" + dialog)).not_to_be_visible()
assert trigger.evaluate("e=>e===document.activeElement")
assert list(site.glob("pages/**/*.md")) == before
report["flows"].append(
"info/details/create dialogs: focus, Escape, no writes on open/cancel"
)
page.locator('[data-open-modal="new-page-dialog"]').click()
page.locator('#new-page-dialog [name="title"]').fill("Новая вложенная страница")
page.locator('#new-page-dialog [name="page_id"]').fill("nested/browser")
page.get_by_role("button", name="Создать черновик", exact=True).click()
page.wait_for_url("**/*msg=created*")
expect(page.locator(".inspect-heading h3")).to_have_text("Новая вложенная страница")
settled(page)
assert (site / "pages/nested/browser.md").exists()
assert not (work / "dist/current").exists()
page.locator('[data-open-modal="new-page-dialog"]').click()
page.locator('#new-page-dialog [name="title"]').fill("Duplicate preserved")
page.locator('#new-page-dialog [name="page_id"]').fill("nested/browser")
page.get_by_role("button", name="Создать черновик", exact=True).click()
expect(page.locator('#new-page-dialog [role="alert"]')).to_be_visible()
expect(page.locator('#new-page-dialog [name="title"]')).to_have_value(
"Duplicate preserved"
)
expect(page.locator("#new-page-dialog")).to_be_visible()
settled(page)
page.locator('#new-page-dialog [name="page_id"]').fill("new")
with page.expect_response(lambda response: response.url.endswith('/admin/pages/new') and response.status == 422):
page.get_by_role("button", name="Создать черновик", exact=True).click()
settled(page)
expect(page.locator('#new-page-dialog [name="page_id"]')).to_have_value("new")
expect(page.locator('#new-page-dialog [role="alert"]')).to_be_visible()
assert not (site / "pages/new.md").exists()
# Duplicate/reserved ID intentionally return 409/422.
report["errors"] = [
e
for e in report["errors"]
if not (
any(code in e for code in ["409", "422"])
and ("/admin/pages/new" in e or "Failed to load resource" in e)
)
]
page.keyboard.press("Escape")
report["flows"].append(
"real nested draft creation, list selection, 409/422 with values retained, no publication"
)
build_site(site, work / "dist")
page.goto(origin + "/admin/pages")
expect(page.locator(".ribbon-item").nth(1).locator(".number")).to_have_text("02")
source = site / "pages/index.md"
original = source.read_bytes()
source.write_bytes(original + b"\n")
page.reload()
expect(page.locator(".ribbon-item").nth(1).locator(".number")).to_have_text("03")
source.write_bytes(original)
page.reload()
expect(page.locator(".ribbon-item").nth(1).locator(".number")).to_have_text("02")
page.screenshot(path=str(OUT / "pages-live.png"), full_page=True)
report["flows"].append("real release counts, modified/reverted source, long build ID")
manifest_path = work / "dist/current/manifest.json"
manifest_source = manifest_path.read_bytes()
manifest = json.loads(manifest_source)
del manifest["page_sources"]
manifest_path.write_text(json.dumps(manifest))
page.reload()
expect(page.locator(".ribbon-item").nth(1).locator(".number")).to_have_text("—")
expect(
page.get_by_text(
"Для этого релиза нет данных сравнения. Они появятся после следующей публикации."
)
).to_be_visible()
manifest_path.write_bytes(manifest_source)
report["flows"].append("legacy release comparison is unknown, not a false zero")
nojs = browser.new_context(
java_script_enabled=False, storage_state=context.storage_state()
)
fallback = nojs.new_page()
fallback.goto(origin + "/admin/pages")
fallback.locator("#pageSearch").fill("contacts")
fallback.get_by_role("button", name="Найти", exact=True).click()
expect(fallback.locator("#pageRows tr[data-page]")).to_have_count(1)
fallback.locator('[data-open-modal="new-page-dialog"]').click()
expect(fallback.locator("#new-page-dialog")).to_be_visible()
fallback.locator('#new-page-dialog [name="title"]').fill("Без JavaScript")
fallback.locator('#new-page-dialog [name="page_id"]').fill("no-js")
fallback.get_by_role("button", name="Создать черновик", exact=True).click()
expect(fallback.locator(".inspect-heading h3")).to_have_text("Без JavaScript")
report["flows"].append("no-JavaScript filter and real draft creation")
nojs.close()
assert not report["errors"], report["errors"]
browser.close()
(OUT / "report.json").write_text(json.dumps(report, ensure_ascii=False, indent=2))
print(
json.dumps(
{"visual": len(report["visual"]), "flows": report["flows"], "artifacts": str(OUT)},
ensure_ascii=False,
)
)
if __name__ == "__main__":
main()
+230
View File
@@ -0,0 +1,230 @@
"""Bidirectional selection without POST, including scriptless same-origin preview."""
import json
import os
import shutil
import tempfile
from contextlib import ExitStack
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
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 main():
out = Path(os.environ.get("QA_SELECTION_OUT", "/tmp/site-engine-selection-001"))
out.mkdir(exist_ok=True)
report = {"runs": []}
with sync_playwright() as pw:
kind = getattr(pw, os.environ.get("QA_BROWSER", "chromium"))
options = {"headless": True}
if kind.name == "chromium":
options["args"] = ["--no-sandbox", "--no-proxy-server"]
elif kind.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 = kind.launch(**options)
report["browser"] = {"name": kind.name, "version": browser.version}
for interactive in (False, True):
with tempfile.TemporaryDirectory(prefix="cms-selection-") as tmp, ExitStack() as stack:
work = Path(tmp)
site = work / "site"
shutil.copytree(
ROOT / "examples/studio-site", site, ignore=shutil.ignore_patterns(".engine")
)
original = (site / "pages/index.md").read_bytes()
admin_socket, preview_socket = reserve(), reserve()
admin = f"http://127.0.0.1:{admin_socket.getsockname()[1]}"
preview = f"http://127.0.0.1:{preview_socket.getsockname()[1]}"
stack.enter_context(
patch.dict(
os.environ,
{
"SITE_ROOT": str(site),
"SITE_DIST": str(work / "dist"),
"SITE_STATE_DIR": str(work / "state"),
"SITE_ADMIN_LOGIN": "admin",
"SITE_ADMIN_PASSWORD_HASH": hash_password(PASSWORD, n=2**10),
"SITE_SECRET_KEY": "selection-browser-secret-" * 3,
"SITE_COOKIE_SECURE": "0",
"SITE_ADMIN_ORIGIN": admin if interactive else "",
"SITE_PREVIEW_ORIGIN": preview if interactive else "",
},
)
)
stack.enter_context(serve(create_app(), admin_socket))
if interactive:
stack.enter_context(serve(create_preview_app(), preview_socket))
else:
preview_socket.close()
page = browser.new_page(viewport={"width": 1440, "height": 960})
stack.callback(page.close)
errors, posts, native_dialogs = [], [], []
page.on("pageerror", lambda e, errors=errors: errors.append(str(e)))
page.on(
"console",
lambda m, errors=errors: errors.append(m.text) if m.type == "error" else None,
)
page.on(
"request",
lambda r, posts=posts: posts.append(r.url) if r.method == "POST" else None,
)
def reject_native(dialog, native_dialogs=native_dialogs):
native_dialogs.append({"type": dialog.type, "message": dialog.message})
dialog.dismiss()
page.on("dialog", reject_native)
page.goto(admin + "/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(admin + "/admin/")
page.goto(admin + "/admin/pages/index")
frame = page.frame_locator("#preview-result iframe")
expect(frame.locator("[data-preview-id=b_hero]")).to_have_attribute(
"data-preview-selected", "true"
)
page.wait_for_load_state("networkidle")
source = page.locator("#document-source").input_value()
snapshot = page.locator("#preview-result").get_attribute("data-snapshot")
page.locator("#preview-result iframe").evaluate("e=>e.__qaSelectionFrame=true")
posts.clear()
# Even offline selection is immediate: neither inspector nor preview needs a POST.
page.route("**/admin/editor/**/select", lambda route: route.abort())
for identity in ("b_steps", "b_dirs", "b_hero", "b_cta"):
page.locator(f"[data-tree-id='{identity}']").click()
expect(frame.locator(f"[data-preview-id='{identity}']")).to_have_attribute(
"data-preview-selected", "true"
)
expect(page.locator("#inspectpane [name=block_id]").first).to_have_value(
identity
)
assert not page.locator("[data-constructor]").evaluate("e=>e.inert")
page.screenshot(
path=str(out / f"{'bridge' if interactive else 'scriptless'}-tree.png")
)
# Click the actual rendered section; inspector/tree follow without replacing iframe.
frame.locator("[data-preview-id=b_dirs] h2").click()
expect(page.locator("[data-tree-id=b_dirs]")).to_have_class(
__import__("re").compile("selected")
)
expect(page.locator("#inspectpane [name=block_id]").first).to_have_value("b_dirs")
# Fixed layout roots select the read-only inspector in both directions.
page.locator("[data-tree-scope=layout]").last.click()
expect(page.locator("[data-readonly-inspector]")).to_be_visible()
expect(frame.locator("[data-preview-scope=layout]").last).to_have_attribute(
"data-preview-selected", "true"
)
assert not posts, posts
assert page.locator("#document-source").input_value() == source
assert page.locator("#preview-result").get_attribute("data-snapshot") == snapshot
assert page.locator("#preview-result iframe").evaluate("e=>e.__qaSelectionFrame")
assert (site / "pages/index.md").read_bytes() == original
assert not (work / "dist/current").exists()
assert page.locator("#preview-result iframe").get_attribute("sandbox") == (
"allow-scripts allow-same-origin" if interactive else "allow-same-origin"
)
if not interactive:
assert (
frame.locator("body").evaluate("()=>typeof window.siteDocument")
== "undefined"
)
# Changes still flush before switching, without an extra /select request.
page.locator("[data-tree-id=b_hero]").click()
page.locator('[data-inspector] [name="p.title"]').fill("Pending selection edit")
page.locator("[data-tree-id=b_dirs]").click()
expect(page.locator("#document-source")).to_have_value(
__import__("re").compile("Pending selection edit")
)
expect(page.locator("#inspectpane [name=block_id]").first).to_have_value("b_dirs")
assert not any(url.endswith(("/select", "/save")) for url in posts)
assert (site / "pages/index.md").read_bytes() == original
page.wait_for_load_state("networkidle")
# A second cached inspector still submits the live source, not its cached copy.
page.locator("[data-tree-id=b_hero]").click()
expect(page.locator('[data-inspector] [name="p.title"]')).to_have_value(
"Pending selection edit"
)
page.locator('[data-inspector] [name="p.title"]').fill("Second cached edit")
page.locator("[data-tree-id=b_dirs]").click()
expect(page.locator("#document-source")).to_have_value(
__import__("re").compile("Second cached edit")
)
# Internal navigation uses the designer modal; Escape keeps all unsaved edits.
picker = page.locator("#page-picker")
other = picker.locator("option").evaluate_all(
"options=>options.find(o=>o.value!=='index').value"
)
picker.select_option(other)
confirm = page.locator("#builder-confirm-dialog")
expect(confirm).to_be_visible()
page.keyboard.press("Escape")
expect(picker).to_have_value("index")
expect(page.locator("#document-source")).to_have_value(
__import__("re").compile("Second cached edit")
)
page.locator('.sidebar a[href="/admin/pages"]').click()
expect(confirm).to_be_visible()
confirm.locator("[data-close-dialog]").click()
assert page.url == admin + "/admin/pages/index"
page.locator('[data-action="profile"]').click()
page.locator('#profile-dialog button[type="submit"]').click()
expect(confirm).to_be_visible()
page.keyboard.press("Escape")
expect(page.locator("#profile-dialog")).to_be_visible()
page.locator("#profile-dialog [data-close-dialog]").first.click()
picker.select_option(other)
confirm.locator("[data-builder-confirm]").click()
page.wait_for_url(admin + "/admin/pages/" + other + "?mode=constructor")
assert (site / "pages/index.md").read_bytes() == original
# Reloading a dirty tab must not produce a native beforeunload dialog either.
page.goto(admin + "/admin/pages/index?mode=expert")
page.locator("#document-source").fill(source + "\nUnsaved reload probe")
page.locator(".expert-file.selected").click()
expect(page.locator("#builder-confirm-dialog")).to_be_visible()
page.keyboard.press("Escape")
expect(page.locator("#document-source")).to_have_value(
__import__("re").compile("Unsaved reload probe")
)
page.reload()
expect(page.locator("#document-source")).to_have_value(source)
# Entry uses the shared in-product modal and replays confirmed form submission.
page.goto(admin + "/admin/content/services/bots?mode=expert")
entry_source = page.locator("#document-source")
entry_source.fill(entry_source.input_value() + "\nUnsaved entry probe")
page.locator('[data-action="profile"]').click()
page.locator('#profile-dialog button[type="submit"]').click()
shared_confirm = page.locator("#confirm-dialog")
expect(shared_confirm).to_be_visible()
page.keyboard.press("Escape")
expect(entry_source).to_have_value(__import__("re").compile("Unsaved entry probe"))
page.locator('#profile-dialog button[type="submit"]').click()
shared_confirm.locator("[value=confirm]").click()
page.wait_for_url(admin + "/admin/login")
assert not native_dialogs, native_dialogs
assert not errors, errors
report["runs"].append(
{
"interactive_bridge": interactive,
"selection_posts": 0,
"no_file_write": True,
"navigation_modals": True,
"native_dialogs": native_dialogs,
"errors": errors,
}
)
browser.close()
(out / "report.json").write_text(json.dumps(report, ensure_ascii=False, indent=2))
print(json.dumps(report, ensure_ascii=False))
if __name__ == "__main__":
main()
+171
View File
@@ -0,0 +1,171 @@
"""Compare the shared runtime shell with the original Antirion in real Chromium.
All application data and auth state live in a disposable copy of studio-site.
Screenshots/measurements are written outside the checkout.
"""
from __future__ import annotations
import json
import os
import shutil
import tempfile
from pathlib import Path
from unittest.mock import patch
from playwright.sync_api import sync_playwright
from qa_001 import PASSWORD, ROOT, serve
from site_engine.services.auth import hash_password
from site_engine.web.app import create_app
OUT = Path("/tmp/site-engine-shell-001")
MEASURE = """() => {
const names = ['.sidebar','.brand','.brand-logo','.sidebar-nav','.sidebar-bottom',
'.topbar','.cmd','.header-btn[data-action=theme]','.user-chip',
'.sidebar .nav-item.active','.sidebar .nav-item.active svg'];
return Object.fromEntries(names.map(name => {
const e=document.querySelector(name), r=e.getBoundingClientRect(), s=getComputedStyle(e);
return [name,{x:r.x,y:r.y,width:r.width,height:r.height,fontSize:s.fontSize,
color:s.color,background:s.backgroundColor,padding:s.padding}];
}));
}"""
def main():
OUT.mkdir(exist_ok=True)
report = {"geometry": [], "flows": [], "errors": []}
with tempfile.TemporaryDirectory(prefix="cms-shell-") as temp:
work = Path(temp)
shutil.copytree(ROOT / "examples/studio-site", work / "site", ignore=shutil.ignore_patterns(".engine"))
env = {
"SITE_ROOT": str(work / "site"), "SITE_DIST": str(work / "dist"),
"SITE_STATE_DIR": str(work / "state"), "SITE_ADMIN_LOGIN": "admin",
"SITE_ADMIN_PASSWORD_HASH": hash_password(PASSWORD, n=2**10),
"SITE_SECRET_KEY": "temporary-shell-qa-secret-" * 2, "SITE_COOKIE_SECURE": "0",
"SITE_ADMIN_ORIGIN": "", "SITE_PREVIEW_ORIGIN": "", "SITE_PUBLIC_HOST": "",
}
with patch.dict(os.environ, env), serve(create_app()) as origin, sync_playwright() as pw:
browser = pw.chromium.launch(headless=True, args=["--no-sandbox"])
page = browser.new_page(viewport={"width": 1440, "height": 960}, reduced_motion="reduce")
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)
page.on("response", lambda response: report["errors"].append(f"{response.status} {response.url}") if response.status >= 400 else None)
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")
page.locator("#topbar .cmd").wait_for()
reference = browser.new_page(viewport={"width": 1440, "height": 960})
reference.goto((ROOT / "design/antirion-rework.html").as_uri())
reference.locator("#topbar .cmd").wait_for()
# Compare the same content. Only fixture labels/status/counts differ from the mock.
labels = page.evaluate("""() => ({site:document.querySelector('.sitelabel b').textContent,
host:document.querySelector('.crumb span').textContent,
small:document.querySelector('.sitelabel small').textContent,
count:document.querySelector('.nav-item .count').textContent})""")
reference.evaluate("""labels => {
document.querySelector('.sitelabel b').textContent=labels.site;
document.querySelector('.sitelabel small').textContent=labels.small;
document.querySelector('.crumb span').textContent=labels.host;
document.querySelector('.nav-item .count').textContent=labels.count;
document.querySelectorAll('.nav-item .count').forEach((e,i)=>{if(i)e.remove()});
document.querySelector('.live-pip').classList.add('no-release');
document.querySelector('.live-pip').textContent='НЕТ РЕЛИЗА';
document.querySelector('.user-chip').textContent='AD';
}""", labels)
for theme in ["light", "dark"]:
if theme == "dark":
page.locator(".topbar [data-action=theme]").click()
reference.locator(".topbar [data-action=theme]").click()
# The prototype rebuilds its shell on theme changes.
reference.evaluate("""labels => {
document.querySelector('.sitelabel b').textContent=labels.site;
document.querySelector('.sitelabel small').textContent=labels.small;
document.querySelector('.crumb span').textContent=labels.host;
document.querySelector('.nav-item .count').textContent=labels.count;
document.querySelectorAll('.nav-item .count').forEach((e,i)=>{if(i)e.remove()});
document.querySelector('.live-pip').textContent='НЕТ РЕЛИЗА';
document.querySelector('.user-chip').textContent='AD';
}""", labels)
for width in [1440, 1280, 1024, 768, 390, 360]:
for p in [page, reference]:
p.set_viewport_size({"width": width, "height": 960})
reference.wait_for_timeout(180)
actual, expected = page.evaluate(MEASURE), reference.evaluate(MEASURE)
for selector in actual:
for prop in ["x", "y", "width", "height", "fontSize", "padding", "color", "background"]:
assert actual[selector][prop] == expected[selector][prop], (theme,width,selector,prop,actual[selector],expected[selector])
assert not page.evaluate("document.documentElement.scrollWidth > innerWidth+1")
report["geometry"].append({"theme":theme,"width":width,"runtime":actual,"reference":expected})
if width in [1440, 390]:
page.screenshot(path=str(OUT / f"runtime-{theme}-{width}.png"))
reference.screenshot(path=str(OUT / f"reference-{theme}-{width}.png"))
page.set_viewport_size({"width": 1440, "height": 960})
page.locator(".topbar [data-action=theme]").click()
page.locator('[data-action="collapse"]').click()
assert page.locator(".sidebar").bounding_box()["width"] == 66
page.screenshot(path=str(OUT / "collapsed.png"))
page.reload()
assert page.locator(".sidebar").bounding_box()["width"] == 66
page.locator('[data-action="collapse"]').click()
report["flows"].append("collapse and persisted preference")
page.keyboard.press("Control+k")
assert page.locator("#cmd-input").evaluate("e=>e===document.activeElement")
page.locator("#cmd-input").fill("contacts")
assert page.locator("[data-command-result]:visible").count() == 1
page.screenshot(path=str(OUT / "command.png"))
page.locator("#cmd-input").fill("does-not-exist")
assert page.locator("[data-command-empty]").is_visible()
page.locator("#cmd-input").fill("Контент")
page.locator("[data-command-result]:visible").click()
page.wait_for_url(origin + "/admin/content")
assert page.locator(".nav-item.active").inner_text() == "Контент"
report["flows"].append("Ctrl+K, real pages/sections, empty search, htmx navigation")
page.locator('[data-action="profile"]').click()
assert page.locator("#profile-dialog").is_visible()
page.keyboard.press("Escape")
assert page.locator('[data-action="profile"]').evaluate("e=>e===document.activeElement")
report["flows"].append("profile, Escape and return focus")
page.set_viewport_size({"width": 390, "height": 844})
page.get_by_role("button", name="Открыть меню").click()
page.screenshot(path=str(OUT / "mobile-menu.png"))
page.keyboard.press("Shift+Tab")
assert page.locator(".sidebar").evaluate("e=>e.contains(document.activeElement)")
page.keyboard.press("Escape")
assert page.get_by_role("button", name="Открыть меню").evaluate("e=>e===document.activeElement")
assert page.locator(".main").evaluate("e=>!e.inert")
report["flows"].append("mobile menu, focus trap, Escape, return focus")
page.locator('[data-action="command"]').click()
page.screenshot(path=str(OUT / "command-mobile.png"))
page.keyboard.press("Escape")
page.get_by_role("button", name="Открыть меню").click()
page.locator("#cover").click(position={"x":350,"y":300})
assert page.locator(".sidebar.open").count() == 0
page.set_viewport_size({"width": 1440, "height": 960})
page.goto(origin + "/admin/publish")
page.get_by_role("button", name="Опубликовать текущий черновик сайта", exact=True).click()
page.locator("#confirm-dialog button[value=confirm]").click()
page.locator(".live-pip:not(.no-release) .mono").wait_for()
page.goto(origin + "/admin/pages")
assert page.locator(".live-pip .mono").inner_text().strip()
page.screenshot(path=str(OUT / "live-release.png"))
for width in [1440, 1280, 1024, 768, 600, 430, 421, 390, 360]:
page.set_viewport_size({"width":width,"height":960})
assert not page.evaluate("document.documentElement.scrollWidth > innerWidth+1"), ("live",width)
page.set_viewport_size({"width":1440,"height":960})
report["flows"].append("actual live build after publication and navigation")
page.locator('[data-action="profile"]').click()
page.get_by_role("button", name="Выйти", exact=True).click()
page.wait_for_url(origin + "/admin/login")
report["flows"].append("profile logout through real CSRF form")
assert not report["errors"], report["errors"]
browser.close()
(OUT / "report.json").write_text(json.dumps(report, ensure_ascii=False, indent=2))
print(json.dumps({"geometry":len(report["geometry"]),"flows":report["flows"],"artifacts":str(OUT)},ensure_ascii=False))
if __name__ == "__main__":
main()
+44
View File
@@ -0,0 +1,44 @@
"""Transfer designer CSS/SVG verbatim, isolating its document reset from the shared shell."""
import json
import re
import sys
from pathlib import Path
from css_scope import scope_css
ROOT = Path(__file__).resolve().parents[1]
def main():
def emit(path, content):
if "--check" in sys.argv:
if not path.exists() or path.read_text() != content:
raise SystemExit(f"Designer transfer out of date: {path}")
else:
path.write_text(content)
static = ROOT / "src/site_engine/web/admin/static"
source = (ROOT / "design/assets/builder.css").read_text()
emit(static / "builder-design.css", source)
# All component declarations and media queries remain designer-owned. Only the
# document root becomes the embedded editor root. Ordinary prefixed selectors
# isolate the shell, including in browsers that do not implement CSS @scope.
embedded = re.sub(r"(?<![-\w])(?:html|body)(?![-\w])", ":scope", source)
embedded = embedded.replace(":root", ":scope")
emit(
static / "builder.css",
"/* Generated by scripts/sync_builder_design.py. Do not hand-edit. */\n"
+ scope_css(
embedded, "#document-editor.page-builder", ":where(#document-editor).page-builder"
),
)
js = (ROOT / "design/assets/builder.js").read_text()
icons = dict(re.findall(r"(\w+):'([^']*)'", js.split("const I={", 1)[1].split("};", 1)[0]))
macro = "{% macro bi(name) -%}{% set paths = " + json.dumps(icons, ensure_ascii=False) + " %}"
macro += "<svg viewBox='0 0 24 24' fill='none' stroke='currentColor' stroke-width='1.7' stroke-linecap='round' stroke-linejoin='round' aria-hidden='true'><path d='{{ paths.get(name, paths.blocks) }}'/></svg>{%- endmacro %}\n"
emit(static.parent / "templates/_builder_icons.html.j2", macro)
if __name__ == "__main__":
main()
+109
View File
@@ -0,0 +1,109 @@
"""Install a wheel and smoke real FastAPI outside the checkout, without design/."""
import os
import shutil
import subprocess
import sys
import tempfile
from pathlib import Path
ROOT = Path(__file__).resolve().parents[1]
def main():
with tempfile.TemporaryDirectory(prefix="cms-installed-001-") as tmp:
work = Path(tmp)
project = work / "project"
project.mkdir()
for name in ("pyproject.toml", "README.md"):
shutil.copyfile(ROOT / name, project / name)
shutil.copytree(
ROOT / "src",
project / "src",
ignore=shutil.ignore_patterns("*.egg-info", "__pycache__"),
)
subprocess.run(
[
sys.executable,
"-m",
"pip",
"wheel",
str(project),
"--no-deps",
"--no-build-isolation",
"-q",
"-w",
str(work / "wheels"),
],
check=True,
)
wheel = next((work / "wheels").glob("*.whl"))
target = work / "installed"
subprocess.run(
[
sys.executable,
"-m",
"pip",
"install",
"--no-deps",
"--target",
str(target),
str(wheel),
"-q",
],
check=True,
)
shutil.copytree(
ROOT / "examples/studio-site", work / "site", ignore=shutil.ignore_patterns(".engine")
)
env = dict(
os.environ,
PYTHONPATH=str(target),
SITE_ROOT=str(work / "site"),
SITE_DIST=str(work / "dist"),
SITE_STATE_DIR=str(work / "state"),
SITE_COOKIE_SECURE="0",
SITE_SECRET_KEY="installed-test-secret-" * 3,
SITE_ADMIN_ORIGIN="http://127.0.0.1:9100",
SITE_PREVIEW_ORIGIN="http://127.0.0.1:9101",
)
program = """
import html, os, re
from pathlib import Path
from fastapi.testclient import TestClient
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
import site_engine
assert str(Path(site_engine.__file__).resolve()).startswith(os.environ['PYTHONPATH'])
os.environ['SITE_ADMIN_PASSWORD_HASH']=hash_password('installed wheel password',n=2**10)
os.environ['SITE_ADMIN_LOGIN']='admin'
app=create_app()
with TestClient(app) as client:
response=client.post('/admin/login',data={'login':'admin','password':'installed wheel password'},headers={'Origin':'http://testserver'})
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'):
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')
principal=app.state.auth.authenticate(cookie)
csrf=app.state.auth.csrf_token(principal)
source=(Path(os.environ['SITE_ROOT'])/'pages/index.md').read_text()
from site_engine.storage.fs import etag_of
result=client.post('/admin/editor/pages/index/preview',data={'source':source,'etag':etag_of(source.encode()),'csrf':csrf},headers={'Origin':'http://testserver','HX-Request':'true'})
assert result.status_code==200,result.text
url=html.unescape(re.search(r"src='([^']+)'",result.text)[1])
with TestClient(create_preview_app()) as preview:
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 app.state.api_calls>0
print('installed wheel: static, templates, API, bridge, separate preview OK; design/ absent')
"""
subprocess.run([sys.executable, "-c", program], cwd=work, env=env, check=True)
if __name__ == "__main__":
main()