Add Site Studio themes and Theme Manager
Support categorized fragments, theme presets, block widths, and server-backed theme editing with onboarding and preview. Include Site Studio, design sources, specification and verification reports; remove the legacy studio-site example.
This commit is contained in:
@@ -0,0 +1,437 @@
|
||||
"""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)
|
||||
Reference in New Issue
Block a user