Files
flexly-cms/tests/test_theme_manager.py
T
phelex 0d171915d7 Add Site Studio themes and Theme Manager
Support categorized fragments, theme presets, block widths, and server-backed theme editing with onboarding and preview.

Include Site Studio, design sources, specification and verification reports; remove the legacy studio-site example.
2026-11-13 14:04:49 +03:00

438 lines
20 KiB
Python

"""Theme contract: real HTML/API boundary, CAS, workflow and isolated previews."""
import datetime as dt
import json
import os
import tempfile
import unittest
from pathlib import Path
from unittest.mock import patch
from urllib.parse import parse_qs, urlsplit
from fastapi.testclient import TestClient
from theme_fixture import document, seed, write
from site_engine.build.pipeline import build_site
from site_engine.errors import ConflictError, EngineError, UnsafePathError
from site_engine.parsing.yamlio import dump_yaml, load_yaml
from site_engine.services.auth import hash_password
from site_engine.services.content import ABSENT, ContentService
from site_engine.services.documents import EditorContext
from site_engine.services.publish import rollback
from site_engine.services.theme import OnboardingService, ThemeCommitError, ThemeService
from site_engine.web.app import create_app
class ThemeManagerTests(unittest.TestCase):
@classmethod
def setUpClass(cls):
cls.password = "theme test password"
cls.password_hash = hash_password(cls.password, n=2**10)
def setUp(self):
tmp = tempfile.TemporaryDirectory()
self.addCleanup(tmp.cleanup)
self.work = Path(tmp.name)
self.site, self.dist, self.state = (
self.work / "site",
self.work / "dist",
self.work / "state",
)
seed(self.site)
env = patch.dict(
os.environ,
{
"SITE_ROOT": str(self.site),
"SITE_DIST": str(self.dist),
"SITE_STATE_DIR": str(self.state),
"SITE_ADMIN_LOGIN": "admin",
"SITE_ADMIN_PASSWORD_HASH": self.password_hash,
"SITE_SECRET_KEY": "theme-integration-secret-" * 4,
"SITE_COOKIE_SECURE": "0",
"SITE_ADMIN_ORIGIN": "",
"SITE_PREVIEW_ORIGIN": "",
},
)
env.start()
self.addCleanup(env.stop)
self.app = create_app()
self.client = TestClient(self.app)
self.addCleanup(self.client.close)
self.cookie = self.app.state.auth.login("admin", self.password, "testclient")
self.client.cookies.set("se_session", self.cookie)
self.app.state.api_credentials["test"] = (self.cookie, "testclient")
self.principal = self.app.state.auth.authenticate(self.cookie)
self.csrf = self.app.state.auth.csrf_token(self.principal)
self.context = EditorContext(self.principal, "testclient")
self.svc = ThemeService(self.site, self.dist, self.state, self.app.state.auth.audit)
def api(self, method, path="/theme", data=None):
return self.client.request(
method, "/admin/api/v1" + path, json=data, headers={"Authorization": "Bearer test"}
)
def post(self, op, data=None, csrf=None, origin="http://testserver"):
return self.client.post(
"/admin/" + op,
data={"csrf": self.csrf if csrf is None else csrf, "payload": json.dumps(data or {})},
headers={"Origin": origin, "HX-Request": "true"},
)
def new_site(self):
raw = load_yaml((self.site / "site.yaml").read_text())
del raw["theme"]
write(self.site, "site.yaml", dump_yaml(raw))
(self.site / "theme.yaml").unlink()
def test_snapshot_and_catalog_share_core(self):
snap = self.api("GET").json()
self.assertEqual(
{
"document",
"etag",
"effective_tokens",
"diagnostics",
"workspace_revision",
"live_build_id",
}
- snap.keys(),
set(),
)
self.assertIsNone(snap["live_build_id"])
self.assertEqual(snap["effective_tokens"]["ui"]["container"]["max_width"], 1080)
presets = self.api("GET", "/theme/presets")
self.assertEqual(presets.status_code, 200)
self.assertEqual(len(presets.json()["presets"]), 6)
for preset in presets.json()["presets"].values():
result = self.api(
"POST", "/theme/validate", {"document": preset["document"], "revision": 9}
)
self.assertEqual(result.status_code, 200, result.text)
self.assertEqual(result.json()["effective_tokens"], preset["effective_tokens"])
def test_validate_and_preview_never_save(self):
before = (self.site / "theme.yaml").read_bytes()
new = document("dark")
validated = self.post("theme/validate", {"document": new, "revision": 42})
self.assertEqual(validated.status_code, 200, validated.text)
self.assertIn("preset: dark", validated.json()["yaml"])
for target in ("sample", "page"):
result = self.post("theme/preview", {"document": new, "revision": 42, "target": target})
self.assertEqual(result.status_code, 200, result.text)
self.assertEqual(result.json()["revision"], 42)
preview = self.client.get(result.json()["url"])
self.assertEqual(preview.status_code, 200, preview.text)
self.assertIn("--color-primary: #a48bfa", preview.text)
self.assertIn("script-src 'none'", preview.headers["content-security-policy"])
self.assertNotIn("<script", preview.text)
self.assertEqual(before, (self.site / "theme.yaml").read_bytes())
self.assertFalse((self.state / "theme-onboarding.json").exists())
def test_demo_keeps_source_viewport_breakpoints_inside_isolated_frame(self):
for width in (390, 1440):
response = self.api(
"POST",
"/theme/preview",
{
"document": document(),
"revision": 2,
"viewport_width": width,
},
)
self.assertEqual(response.status_code, 200, response.text)
html = self.client.get(response.json()["url"]).text
self.assertEqual('<div class="sample-site compact ' in html, width <= 770)
self.assertIn(f"padding-top:clamp(25px,{width * 0.06}px,53px)", html)
for width in (True, 0, 4000):
response = self.api(
"POST",
"/theme/preview",
{
"document": document(),
"viewport_width": width,
},
)
self.assertEqual(response.status_code, 422, response.text)
def test_two_editors_conflict_returns_current_and_preserves_file(self):
etag = self.svc.get()["etag"]
first = self.api(
"PATCH", data={"document": document("dark"), "if_match": etag, "revision": 2}
)
self.assertEqual(first.status_code, 200, first.text)
second = self.api(
"PATCH", data={"document": document("natural"), "if_match": etag, "revision": 3}
)
self.assertEqual(second.status_code, 409, second.text)
error = second.json()["error"]
self.assertEqual(error["current"]["document"]["preset"], "dark")
self.assertEqual(error["current"]["etag"], first.json()["etag"])
self.assertTrue(error["request_id"])
self.assertEqual(self.svc.get()["document"]["preset"], "dark")
self.assertTrue(list((self.site / ".engine/history").rglob("*")))
self.assertIn("theme_save", (self.state / "audit.jsonl").read_text())
def test_first_save_absent_creates_link_and_completed_workflow(self):
self.new_site()
state = self.api("GET", "/theme/onboarding").json()
self.assertTrue(state["needs_setup"])
initial = self.svc.get()
self.assertEqual(initial["etag"], ABSENT)
wrong = self.api(
"PATCH", data={"document": document("dark"), "if_match": "bad", "revision": 1}
)
self.assertEqual(wrong.status_code, 409)
self.assertFalse((self.site / "theme.yaml").exists())
response = self.post(
"theme/save", {"document": document("dark"), "if_match": ABSENT, "revision": 2}
)
self.assertEqual(response.status_code, 200, response.text)
self.assertEqual(
load_yaml((self.site / "site.yaml").read_text())["theme"], {"file": "theme.yaml"}
)
self.assertEqual(OnboardingService(self.svc).status()["status"], "completed")
self.assertFalse((self.dist / "current").exists())
def test_onboarding_skip_restart_existing_and_restart_persistence(self):
self.assertEqual(OnboardingService(self.svc).status()["status"], "existing")
self.assertEqual(self.client.get("/admin/", follow_redirects=False).status_code, 200)
self.new_site()
self.assertEqual(
self.client.get("/admin/", follow_redirects=False).headers["location"],
"/admin/setup/theme",
)
for op, status in [("skip", "skipped"), ("restart", "in_progress")]:
response = self.post("setup/theme/" + op)
self.assertEqual(response.status_code, 200, response.text)
self.assertEqual(response.json()["status"], status)
restarted = ThemeService(self.site, self.dist, self.state)
self.assertEqual(OnboardingService(restarted).status()["status"], status)
self.assertEqual(create_app().state.auth.state_dir, self.state)
self.assertFalse((self.site / "theme.yaml").exists())
self.assertEqual(self.client.get("/admin/", follow_redirects=False).status_code, 200)
def test_release_marks_unconfigured_site_existing(self):
self.new_site()
build_site(self.site, self.dist)
self.assertEqual(OnboardingService(self.svc).status()["status"], "existing")
def test_auth_csrf_and_origin(self):
self.assertEqual(self.client.get("/admin/api/v1/theme").status_code, 401)
for op in (
"theme/save",
"theme/validate",
"theme/preview",
"setup/theme/skip",
"setup/theme/restart",
):
for kwargs in ({"csrf": "bad"}, {"origin": "https://evil.example"}):
self.assertEqual(self.post(op, **kwargs).status_code, 403)
self.app.state.auth.logout(self.principal, "testclient")
self.assertEqual(self.api("GET").status_code, 401)
def test_invalid_tokens_give_paths_and_no_write(self):
before = self.svc.get()
for overrides in (
{"colors": {"primary": "url(javascript:evil)"}},
{"ui": {"container": 3}},
{"type": {"scale": float("nan")}},
):
if "type" in overrides:
# JSON itself rejects NaN; exercise the service boundary separately.
with self.assertRaises(EngineError):
self.svc.save(document(overrides=overrides), before["etag"], self.context)
continue
for op in ("validate", "preview", "save"):
body = {"document": document(overrides=overrides), "revision": 4}
if op == "save":
body["if_match"] = before["etag"]
response = self.post("theme/" + op, body)
self.assertEqual(response.status_code, 422, response.text)
self.assertTrue(
any(
i["path"].startswith("theme.yaml.overrides")
for i in response.json()["error"]["issues"]
)
)
self.assertEqual(before["etag"], self.svc.get()["etag"])
def test_contrast_is_warning_and_save_allowed(self):
result = self.api(
"PATCH",
data={
"document": document(overrides={"colors": {"text": "#ffffff"}}),
"if_match": self.svc.get()["etag"],
"revision": 3,
},
)
self.assertEqual(result.status_code, 200, result.text)
self.assertTrue(any(i["code"] == "W_THEME_CONTRAST" for i in result.json()["diagnostics"]))
def test_path_is_exact_and_reconfiguration_is_rechecked_under_lock(self):
raw = load_yaml((self.site / "site.yaml").read_text())
for path in ("../outside.yaml", "site.yaml", "assets/palette.css"):
raw["theme"] = {"file": path}
write(self.site, "site.yaml", dump_yaml(raw))
with self.assertRaises(UnsafePathError):
self.svc.get()
raw["theme"] = {"file": "config/brand.yaml"}
write(self.site, "site.yaml", dump_yaml(raw))
write(self.site, "config/brand.yaml", dump_yaml(document()))
snapshot = self.svc.get()
self.svc.save(document("bold"), snapshot["etag"], self.context)
self.assertEqual(self.svc.get()["path"], "config/brand.yaml")
content = ContentService(self.site, allowed_paths=("config/brand.yaml",))
with self.assertRaises(UnsafePathError):
content.write("config/another.yaml", "{}", ABSENT)
original = ContentService.update_files
def reconfigure(content, versions, prepare):
raw["theme"] = {"file": "theme.yaml"}
write(self.site, "site.yaml", dump_yaml(raw))
return original(content, versions, prepare)
with (
patch.object(ContentService, "update_files", reconfigure),
self.assertRaises(ConflictError),
):
self.svc.save(document("dark"), self.svc.get()["etag"], self.context)
def test_symlink_escape_is_rejected(self):
raw = load_yaml((self.site / "site.yaml").read_text())
raw["theme"] = {"file": "escape/brand.yaml"}
write(self.site, "site.yaml", dump_yaml(raw))
(self.site / "escape").symlink_to(self.work, target_is_directory=True)
self.assertEqual(self.api("GET").status_code, 403)
def test_disk_failure_does_not_change_theme_and_is_logged(self):
initial = self.svc.get()
with (
patch("site_engine.services.content.atomic_write", side_effect=OSError("disk probe")),
self.assertLogs("uvicorn.error", level="ERROR") as logs,
):
result = self.post(
"theme/save",
{"document": document("bold"), "if_match": initial["etag"], "revision": 6},
)
self.assertEqual(result.status_code, 500, result.text)
self.assertEqual(result.json()["error"]["code"], "storage_error")
self.assertEqual(initial["etag"], self.svc.get()["etag"])
self.assertIn("disk probe", "\n".join(logs.output))
def test_first_save_second_write_failure_restores_both_files(self):
from site_engine.storage.fs import atomic_write
self.new_site()
before = (self.site / "site.yaml").read_bytes()
def fail(path, text):
if path.name == "site.yaml":
raise OSError("config write")
return atomic_write(path, text)
with patch("site_engine.services.content.atomic_write", fail), self.assertRaises(OSError):
self.svc.save(document("dark"), ABSENT, self.context)
self.assertFalse((self.site / "theme.yaml").exists())
self.assertEqual((self.site / "site.yaml").read_bytes(), before)
def test_audit_failure_reports_committed_snapshot_not_a_silent_failure(self):
initial = self.svc.get()
with (
patch.object(self.app.state.auth.audit, "write", side_effect=OSError("audit probe")),
self.assertLogs("uvicorn.error", level="ERROR"),
):
result = self.post(
"theme/save",
{"document": document("dark"), "if_match": initial["etag"], "revision": 11},
)
self.assertEqual(result.status_code, 500, result.text)
err = result.json()["error"]
self.assertEqual(err["code"], "theme_after_commit")
self.assertEqual(err["committed"]["revision"], 11)
self.assertEqual(err["committed"]["etag"], self.svc.get()["etag"])
self.assertEqual(self.svc.get()["document"]["preset"], "dark")
def test_onboarding_write_failure_also_reports_committed(self):
with (
patch("site_engine.services.theme.atomic_write", side_effect=OSError("state probe")),
self.assertRaises(ThemeCommitError) as raised,
):
self.svc.save(document("dark"), self.svc.get()["etag"], self.context, 8)
self.assertEqual(raised.exception.snapshot["revision"], 8)
self.assertEqual(self.svc.get()["document"]["preset"], "dark")
def test_preview_snapshots_are_immutable_and_signed(self):
response = self.api(
"POST", "/theme/preview", {"document": document("dark"), "revision": 10}
).json()
before = self.client.get(response["url"]).text
self.svc.save(document("natural"), self.svc.get()["etag"], self.context)
self.assertEqual(before, self.client.get(response["url"]).text)
self.assertEqual(self.client.get(response["url"] + "bad").status_code, 403)
parts = urlsplit(response["url"])
token = parse_qs(parts.query)["token"][0]
_, data = self.app.state.previews.authorize(response["snapshot"], token)
self.assertEqual(data["revision"], 10)
self.app.state.auth.logout(self.principal, "testclient")
with self.assertRaises(PermissionError):
self.app.state.previews.authorize(response["snapshot"], token)
def test_save_publish_rollback_keep_workspace_and_live_independent(self):
now = dt.datetime(2026, 11, 13, 16, tzinfo=dt.UTC)
first = build_site(self.site, self.dist, now=now)
self.svc.save(document("dark"), self.svc.get()["etag"], self.context)
self.assertEqual(self.svc.get()["live_build_id"], first.build_id)
second = build_site(self.site, self.dist, now=now + dt.timedelta(seconds=1))
self.assertNotEqual(first.build_id, second.build_id)
before = (self.site / "theme.yaml").read_bytes()
rollback(self.dist, first.build_id)
self.assertEqual(before, (self.site / "theme.yaml").read_bytes())
self.assertEqual(self.svc.get()["document"]["preset"], "dark")
self.assertEqual(self.svc.get()["live_build_id"], first.build_id)
def test_html_uses_api_and_never_exposes_internal_credentials(self):
calls = self.app.state.api_calls
result = self.client.get("/admin/theme")
self.assertEqual(result.status_code, 200, result.text)
self.assertGreater(self.app.state.api_calls, calls + 3)
self.assertIn("theme-bootstrap", result.text)
self.assertIn("theme-studio.css", result.text)
self.assertNotIn("Bearer ", result.text)
self.assertNotIn(self.cookie, result.text)
schema = self.app.openapi()["paths"]
self.assertIn("/admin/api/v1/theme", schema)
self.assertIn("patch", schema["/admin/api/v1/theme"])
def test_network_error_keeps_contract_and_does_not_call_services_directly(self):
from site_engine.web.admin.api_client import AdminApi, ApiError
original = AdminApi.call
async def fail(api, method, path, data=None):
if path == "/theme":
raise ApiError(503, {"error": {"code": "api_unavailable", "message": "Нет API"}})
return await original(api, method, path, data)
before = (self.site / "theme.yaml").read_bytes()
with patch.object(AdminApi, "call", fail):
result = self.post(
"theme/save",
{"document": document("dark"), "if_match": self.svc.get()["etag"], "revision": 12},
)
self.assertEqual(result.status_code, 503)
self.assertEqual(result.json()["error"]["code"], "api_unavailable")
self.assertEqual(before, (self.site / "theme.yaml").read_bytes())
def test_explicit_missing_or_bad_theme_is_diagnostic_and_repairable(self):
for text in ("not: [valid", "preset: unknown", "null"):
write(self.site, "theme.yaml", text)
snap = self.svc.get()
self.assertTrue(any(i["severity"] == "error" for i in snap["diagnostics"]))
repaired = self.svc.save(document("dark"), snap["etag"], self.context)
self.assertEqual(repaired["document"]["preset"], "dark")
(self.site / "theme.yaml").unlink()
snap = self.svc.get()
self.assertEqual(snap["etag"], ABSENT)
self.assertTrue(snap["diagnostics"])
self.svc.save(document(), ABSENT, self.context)