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:
+1
-1
@@ -17,7 +17,7 @@ class SiteTestCase(unittest.TestCase):
|
||||
self.addCleanup(self._tmp.cleanup)
|
||||
self.tmp = Path(self._tmp.name)
|
||||
self.site = self.tmp / "site"
|
||||
shutil.copytree(EXAMPLE, self.site)
|
||||
shutil.copytree(EXAMPLE, self.site, ignore=shutil.ignore_patterns('.engine'))
|
||||
self.out = self.tmp / "dist"
|
||||
|
||||
def edit(self, rel: str, old: str, new: str) -> None:
|
||||
|
||||
@@ -82,19 +82,19 @@ class AdminHandlersTest(SiteTestCase):
|
||||
result = self.h.login_submit("admin", "super-secret-guess!!", ORIGIN, "1.1.1.1")
|
||||
self.assertNotIn("super-secret-guess", result.body)
|
||||
|
||||
def test_dashboard_lists_pages_collections_and_validation(self):
|
||||
def test_dashboard_shows_workspace_release_changes_and_validation(self):
|
||||
result = self.h.dashboard(self.login())
|
||||
self.assertEqual(result.status, 200)
|
||||
for text in ("Acme Studio", "Главная", "Контакты", "Черновик новой страницы", "status-draft",
|
||||
"опубликовано 3 из 3", "ошибок проверки: 0"):
|
||||
for text in ("Acme Studio", "Главная", "Контакты", "Черновик новой страницы",
|
||||
"Нет публикаций", "Последние изменения", "Ошибок проверки: 0"):
|
||||
self.assertIn(text, result.body)
|
||||
self.assertIn("name='csrf'", result.body)
|
||||
self.assertIn("no-store", result.headers["Cache-Control"])
|
||||
|
||||
def test_dashboard_shows_the_absolute_paths_in_use(self):
|
||||
def test_ordinary_dashboard_omits_developer_paths(self):
|
||||
body = self.h.dashboard(self.login()).body
|
||||
for path in (self.site.resolve(), (self.tmp / "dist").resolve(), (self.tmp / "state").resolve()):
|
||||
self.assertIn(str(path), body)
|
||||
self.assertNotIn(str(path), body)
|
||||
|
||||
def test_missing_site_error_names_the_absolute_path(self):
|
||||
(self.site / "site.yaml").unlink()
|
||||
@@ -126,16 +126,21 @@ class AdminHandlersTest(SiteTestCase):
|
||||
result = self.h.login_page(self.login())
|
||||
self.assertEqual((result.status, result.headers["Location"]), (303, "/admin/"))
|
||||
|
||||
def test_static_css_is_served(self):
|
||||
def test_static_assets_are_served(self):
|
||||
result = self.h.static_css()
|
||||
self.assertEqual(result.status, 200)
|
||||
self.assertTrue(result.content_type.startswith("text/css"))
|
||||
self.assertIn(".login", result.body)
|
||||
script = self.h.static_file("htmx.min.js")
|
||||
self.assertEqual(script.status, 200)
|
||||
self.assertTrue(script.content_type.startswith("text/javascript"))
|
||||
self.assertIn('version:"2.0.11"', script.body)
|
||||
self.assertEqual(script.headers["X-Content-Type-Options"], "nosniff")
|
||||
|
||||
def test_no_inline_scripts_or_styles_in_templates(self):
|
||||
# CSP не разрешает inline: проверяем, что шаблоны её не нарушают
|
||||
for body in (self.h.login_page(None).body, self.h.dashboard(self.login()).body):
|
||||
self.assertNotIn("<script", body)
|
||||
self.assertNotRegex(body, r"<script(?![^>]*\bsrc=)")
|
||||
self.assertNotIn("style=", body)
|
||||
self.assertNotIn("<style", body)
|
||||
|
||||
|
||||
@@ -0,0 +1,351 @@
|
||||
"""Real FastAPI contract and HTML -> ASGI client -> API integration."""
|
||||
|
||||
import os
|
||||
from unittest.mock import patch
|
||||
|
||||
from fastapi.testclient import TestClient
|
||||
from helpers import SiteTestCase
|
||||
|
||||
from site_engine.services.auth import hash_password
|
||||
from site_engine.web.app import create_app
|
||||
|
||||
|
||||
class ApiTests(SiteTestCase):
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
cls.password = "temporary test password"
|
||||
cls.password_hash = hash_password(cls.password, n=2**10)
|
||||
|
||||
def setUp(self):
|
||||
super().setUp()
|
||||
self.env = patch.dict(
|
||||
os.environ,
|
||||
{
|
||||
"SITE_ROOT": str(self.site),
|
||||
"SITE_DIST": str(self.out),
|
||||
"SITE_STATE_DIR": str(self.tmp / "state"),
|
||||
"SITE_ADMIN_LOGIN": "admin",
|
||||
"SITE_ADMIN_PASSWORD_HASH": self.password_hash,
|
||||
"SITE_SECRET_KEY": "test-api-secret-" * 4,
|
||||
"SITE_COOKIE_SECURE": "0",
|
||||
"SITE_ADMIN_ORIGIN": "",
|
||||
"SITE_PREVIEW_ORIGIN": "",
|
||||
},
|
||||
)
|
||||
self.env.start()
|
||||
self.addCleanup(self.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.principal = self.app.state.auth.authenticate(self.cookie)
|
||||
self.csrf = self.app.state.auth.csrf_token(self.principal)
|
||||
self.app.state.api_credentials["test-credential"] = (self.cookie, "testclient")
|
||||
self.headers = {"Authorization": "Bearer test-credential"}
|
||||
|
||||
def api(self, method, path, data=None, headers=None):
|
||||
return self.client.request(
|
||||
method, "/admin/api/v1" + path, json=data, headers=headers or self.headers
|
||||
)
|
||||
|
||||
def source(self):
|
||||
return self.api("GET", "/pages/index/source").json()
|
||||
|
||||
def test_fragment_names_and_descriptions_reach_catalog_through_api(self):
|
||||
fragments = self.source()["schema"]["fragments"]
|
||||
expected = {
|
||||
"collection_list": ("Список коллекций", "Карточки, получаемые из collection"),
|
||||
"section": ("Текстовая секция", "Заголовок и содержимое секции"),
|
||||
"richtext": ("Markdown body", "Выводит Markdown из файла страницы"),
|
||||
"card_grid": ("Карточки", "Сетка преимуществ"),
|
||||
}
|
||||
html = self.client.get("/admin/pages/index").text
|
||||
from html.parser import HTMLParser
|
||||
|
||||
class Catalog(HTMLParser):
|
||||
def __init__(self):
|
||||
super().__init__()
|
||||
self.items, self.current = {}, None
|
||||
|
||||
def handle_starttag(self, tag, attrs):
|
||||
attrs = dict(attrs)
|
||||
if tag == "button" and "data-fragment" in attrs:
|
||||
self.current = attrs["data-fragment"]
|
||||
self.items[self.current] = []
|
||||
|
||||
def handle_data(self, data):
|
||||
if self.current:
|
||||
self.items[self.current].append(data)
|
||||
|
||||
def handle_endtag(self, tag):
|
||||
if tag == "button":
|
||||
self.current = None
|
||||
|
||||
catalog = Catalog()
|
||||
catalog.feed(html)
|
||||
for fid, (name, description) in expected.items():
|
||||
self.assertEqual(fragments[fid]["name"], name)
|
||||
self.assertEqual(fragments[fid]["description"], description)
|
||||
text = " ".join(catalog.items[fid])
|
||||
self.assertIn(name, text)
|
||||
self.assertIn(description, text)
|
||||
|
||||
def test_json_html_and_openapi_separate(self):
|
||||
self.assertEqual(self.client.get("/admin/api/v1/site").status_code, 401)
|
||||
data = self.api("GET", "/site")
|
||||
self.assertEqual(data.status_code, 200)
|
||||
self.assertIn("pages", data.json())
|
||||
self.assertEqual(data.headers["cache-control"], "no-store")
|
||||
schema = self.client.get("/admin/api/openapi.json")
|
||||
self.assertEqual(schema.status_code, 200)
|
||||
self.assertIn("/admin/api/v1/pages/{identity}/save", schema.json()["paths"])
|
||||
self.assertIn("Transform", schema.json()["components"]["schemas"])
|
||||
self.assertIn("InternalUiSession", schema.json()["components"]["securitySchemes"])
|
||||
self.client.cookies.clear()
|
||||
self.assertEqual(self.client.get("/admin/api/openapi.json").status_code, 401)
|
||||
self.assertEqual(self.client.get("/admin/api/docs").status_code, 401)
|
||||
|
||||
def test_html_uses_client_and_removes_request_credentials(self):
|
||||
before = self.app.state.api_calls
|
||||
response = self.client.get("/admin/pages/index")
|
||||
self.assertEqual(response.status_code, 200)
|
||||
self.assertIn("document-editor", response.text)
|
||||
self.assertGreater(self.app.state.api_calls, before)
|
||||
self.assertEqual(set(self.app.state.api_credentials), {"test-credential"})
|
||||
self.assertNotIn("test-credential", response.text)
|
||||
self.assertNotIn("Bearer ", response.text)
|
||||
with patch(
|
||||
"site_engine.web.admin.api_client.AdminApi.call",
|
||||
side_effect=__import__(
|
||||
"site_engine.web.admin.api_client", fromlist=["ApiError"]
|
||||
).ApiError(503, {"error": {"message": "Unavailable"}}),
|
||||
):
|
||||
response = self.client.get("/admin/pages")
|
||||
self.assertEqual(response.status_code, 503)
|
||||
self.assertIn("Unavailable", response.text)
|
||||
|
||||
def test_buffer_validate_transform_save_and_conflict(self):
|
||||
s = self.source()
|
||||
payload = {"source": s["source"], "etag": s["etag"], "revision": 7}
|
||||
transformed = self.api(
|
||||
"POST",
|
||||
"/pages/index/transform",
|
||||
dict(payload, action={"type": "metadata", "values": {"title": "API buffer"}}),
|
||||
)
|
||||
self.assertEqual(transformed.status_code, 200, transformed.text)
|
||||
t = transformed.json()
|
||||
self.assertEqual(t["etag"], s["etag"])
|
||||
self.assertEqual(self.source()["source"], s["source"])
|
||||
saved = self.api("POST", "/pages/index/save", dict(payload, source=t["source"]))
|
||||
self.assertEqual(saved.status_code, 200, saved.text)
|
||||
conflict = self.api("POST", "/pages/index/save", payload)
|
||||
self.assertEqual(conflict.status_code, 409)
|
||||
e = conflict.json()["error"]
|
||||
self.assertEqual(e["current"]["source"], t["source"])
|
||||
self.assertEqual(e["submitted"]["source"], s["source"])
|
||||
self.assertEqual(e["submitted"]["etag"], s["etag"])
|
||||
|
||||
def test_typed_actions_and_error_envelopes(self):
|
||||
s = self.source()
|
||||
payload = {"source": s["source"], "etag": s["etag"]}
|
||||
for action in (
|
||||
{"type": "unimplemented"},
|
||||
{"type": "move", "block_id": "b_hero", "direction": "up", "before": "b_hero"},
|
||||
):
|
||||
response = self.api("POST", "/pages/index/transform", dict(payload, action=action))
|
||||
self.assertEqual(response.status_code, 422)
|
||||
self.assertIn("error", response.json())
|
||||
bad = self.api(
|
||||
"POST", "/pages/index/validate", dict(payload, source="---\na: 1\na: 2\n---\n")
|
||||
)
|
||||
self.assertEqual(bad.status_code, 422)
|
||||
self.assertIsNone(bad.json()["error"]["buffer"]["model"])
|
||||
self.assertEqual(self.api("GET", "/pages/missing/source").status_code, 404)
|
||||
self.assertEqual(self.api("GET", "/assets/..%2f..%2fsite.yaml").status_code, 403)
|
||||
|
||||
def test_builder_catalog_duplicate_and_metadata_use_the_same_contract(self):
|
||||
s = self.source()
|
||||
payload = {"source": s["source"], "etag": s["etag"], "revision": 4}
|
||||
added = self.api(
|
||||
"POST",
|
||||
"/pages/index/transform",
|
||||
dict(
|
||||
payload,
|
||||
action={
|
||||
"type": "add",
|
||||
"fragment": "hero",
|
||||
"region": "main",
|
||||
"props": {"title": "Catalog"},
|
||||
},
|
||||
),
|
||||
)
|
||||
self.assertEqual(added.status_code, 200, added.text)
|
||||
block = added.json()["model"]["meta"]["regions"]["main"][-1]
|
||||
self.assertRegex(block["id"], r"^hero_[a-z0-9]{5}$")
|
||||
duplicate = self.api(
|
||||
"POST",
|
||||
"/pages/index/transform",
|
||||
dict(
|
||||
payload,
|
||||
source=added.json()["source"],
|
||||
action={"type": "duplicate", "block_id": block["id"]},
|
||||
),
|
||||
)
|
||||
self.assertEqual(duplicate.status_code, 200, duplicate.text)
|
||||
blocks = duplicate.json()["model"]["meta"]["regions"]["main"]
|
||||
self.assertNotEqual(blocks[-1]["id"], block["id"])
|
||||
self.assertRegex(blocks[-1]["id"], r"^hero_[a-z0-9]{5}$")
|
||||
self.assertEqual(blocks[-1]["props"], block["props"])
|
||||
response = self.client.post(
|
||||
"/admin/editor/pages/index/transform",
|
||||
data={
|
||||
**payload,
|
||||
"csrf": self.csrf,
|
||||
"operation": "metadata",
|
||||
"title": "Changed title",
|
||||
"status": "published",
|
||||
"seo_title": "Real SEO title",
|
||||
"seo_description": "Description",
|
||||
},
|
||||
headers={"Origin": "http://testserver", "HX-Request": "true"},
|
||||
)
|
||||
self.assertEqual(response.status_code, 200, response.text[:1000])
|
||||
self.assertIn("Real SEO title", response.text)
|
||||
self.assertEqual(self.source()["source"], s["source"])
|
||||
|
||||
def test_nested_create_entry_and_publish_rollback(self):
|
||||
result = self.api("POST", "/pages", {"id": "nested/api", "title": "Nested API"})
|
||||
self.assertEqual(result.status_code, 201, result.text)
|
||||
self.assertEqual(self.api("GET", "/pages/nested/api/source").status_code, 200)
|
||||
self.assertEqual(
|
||||
self.api("POST", "/collections/services/entries", {"id": "api-draft"}).status_code, 201
|
||||
)
|
||||
e = self.api("GET", "/collections/services/entries/bots/source").json()
|
||||
self.assertEqual(e["kind"], "entry")
|
||||
result = self.api("POST", "/publish")
|
||||
self.assertEqual(result.status_code, 200, result.text)
|
||||
build = result.json()["current"]
|
||||
self.assertEqual(self.api("POST", "/rollback/" + build).status_code, 200)
|
||||
|
||||
def test_epoch_revokes_api_credentials(self):
|
||||
self.app.state.auth.logout(self.principal)
|
||||
self.assertEqual(self.api("GET", "/site").status_code, 401)
|
||||
|
||||
def test_pages_comparison_and_html_creation_preserve_list_selection(self):
|
||||
self.assertEqual(len(self.api("GET", "/pages?changed=true").json()), 5)
|
||||
self.assertEqual(self.api("POST", "/publish").status_code, 200)
|
||||
rows = self.api("GET", "/pages?changed=true").json()
|
||||
self.assertEqual([p["id"] for p in rows], ["drafts/next"])
|
||||
self.assertEqual(self.client.get("/admin/pages?selected=missing").status_code, 404)
|
||||
payload = {
|
||||
"csrf": self.csrf,
|
||||
"title": "Nested draft",
|
||||
"page_id": "nested/ui",
|
||||
"layout": "default",
|
||||
}
|
||||
response = self.client.post(
|
||||
"/admin/pages/new",
|
||||
data=payload,
|
||||
headers={"Origin": "http://testserver"},
|
||||
follow_redirects=False,
|
||||
)
|
||||
self.assertEqual(response.status_code, 303, response.text)
|
||||
self.assertEqual(
|
||||
response.headers["location"], "/admin/pages?selected=nested%2Fui&msg=created"
|
||||
)
|
||||
response = self.client.post(
|
||||
"/admin/pages/new", data=payload, headers={"Origin": "http://testserver"}
|
||||
)
|
||||
self.assertEqual(response.status_code, 409, response.text[:500])
|
||||
self.assertIn("open data-auto-open", response.text)
|
||||
self.assertIn("value='Nested draft'", response.text)
|
||||
|
||||
def test_html_csrf_and_full_form_save(self):
|
||||
s = self.source()
|
||||
response = self.client.post(
|
||||
"/admin/editor/pages/index/save",
|
||||
data={"source": s["source"], "etag": s["etag"], "csrf": self.csrf},
|
||||
)
|
||||
self.assertEqual(response.status_code, 403)
|
||||
source = s["source"].replace("title:", "# preserved\ntitle:", 1)
|
||||
response = self.client.post(
|
||||
"/admin/editor/pages/index/save",
|
||||
data={"source": source, "etag": s["etag"], "csrf": self.csrf},
|
||||
headers={"Origin": "http://testserver"},
|
||||
)
|
||||
self.assertEqual(response.status_code, 200, response.text[:1000])
|
||||
self.assertEqual(self.source()["source"], source)
|
||||
response = self.client.post(
|
||||
"/admin/editor/pages/index/save",
|
||||
data={"source": s["source"], "etag": s["etag"], "csrf": self.csrf},
|
||||
headers={"Origin": "http://testserver", "HX-Request": "true"},
|
||||
)
|
||||
self.assertEqual(response.status_code, 409)
|
||||
self.assertIn("data-rebase", response.text)
|
||||
self.assertIn("Серверный исходник", response.text)
|
||||
|
||||
def test_ui_assets_are_binary_and_protected(self):
|
||||
self.write("assets/new.svg", '<svg xmlns="http://www.w3.org/2000/svg"/>')
|
||||
response = self.client.get("/admin/preview/assets/new.svg")
|
||||
self.assertEqual(response.status_code, 200)
|
||||
self.assertIn("image/svg+xml", response.headers["content-type"])
|
||||
self.client.cookies.clear()
|
||||
self.assertEqual(
|
||||
self.client.get("/admin/preview/assets/new.svg", follow_redirects=False).status_code,
|
||||
303,
|
||||
)
|
||||
|
||||
def test_planned_routes_filters_and_readonly_inspector(self):
|
||||
self.assertEqual(self.api("GET", "/collections").status_code, 200)
|
||||
self.assertEqual(self.api("GET", "/pages?q=no-such-document").json(), [])
|
||||
self.assertEqual(self.api("GET", "/pages?status=unknown").status_code, 422)
|
||||
self.assertEqual(self.api("GET", "/entries/services").status_code, 200)
|
||||
s = self.api("GET", "/editor/pages/index/source").json()
|
||||
self.assertEqual(s["kind"], "page")
|
||||
response = self.api(
|
||||
"POST",
|
||||
"/editor/pages/index/validate",
|
||||
{"source": s["source"], "etag": s["etag"], "revision": 2},
|
||||
)
|
||||
self.assertEqual(response.status_code, 200)
|
||||
self.assertEqual(self.client.get("/admin/api/v1/openapi.json").status_code, 200)
|
||||
self.assertEqual(self.client.get("/admin/api/v1/docs").status_code, 200)
|
||||
import json
|
||||
|
||||
response = self.client.post(
|
||||
"/admin/editor/pages/index/select",
|
||||
data={
|
||||
"source": s["source"],
|
||||
"etag": s["etag"],
|
||||
"csrf": self.csrf,
|
||||
"readonly": json.dumps({"scope": "layout", "owner": "default", "id": "lh_header"}),
|
||||
},
|
||||
headers={"Origin": "http://testserver", "HX-Request": "true"},
|
||||
)
|
||||
self.assertEqual(response.status_code, 200)
|
||||
self.assertIn("data-readonly-inspector", response.text)
|
||||
self.assertIn("site_header", response.text)
|
||||
|
||||
def test_incomplete_preview_configuration_keeps_editor_available(self):
|
||||
with patch.dict(
|
||||
os.environ, {"SITE_ADMIN_ORIGIN": "http://127.0.0.1:8000", "SITE_PREVIEW_ORIGIN": ""}
|
||||
):
|
||||
app = create_app()
|
||||
self.assertIsNone(app.state.previews.config)
|
||||
self.assertTrue(app.state.previews.unavailable_reason)
|
||||
|
||||
def test_limits_and_forged_credentials_keep_error_contract(self):
|
||||
response = self.api("GET", "/site", headers={"Authorization": "Bearer forged"})
|
||||
self.assertEqual(response.status_code, 401)
|
||||
self.assertIn("error", response.json())
|
||||
response = self.client.post(
|
||||
"/admin/api/v1/pages/index/validate", content=b"x" * 1048577, headers=self.headers
|
||||
)
|
||||
self.assertEqual(response.status_code, 413)
|
||||
self.assertEqual(response.json()["error"]["code"], "body_too_large")
|
||||
response = self.api("GET", "/site", headers={**self.headers, "HX-Request": "true"})
|
||||
self.assertIn("application/json", response.headers["content-type"])
|
||||
response = self.client.get("/admin/pages/index?mode=expert")
|
||||
self.assertEqual(response.status_code, 200)
|
||||
self.assertIn("name='mode' value='expert'", response.text)
|
||||
@@ -0,0 +1,268 @@
|
||||
"""Service guarantees for the shared editor buffer and explicit CAS save."""
|
||||
|
||||
import concurrent.futures
|
||||
from dataclasses import asdict
|
||||
from unittest.mock import patch
|
||||
|
||||
from helpers import SiteTestCase
|
||||
|
||||
from site_engine.errors import ConflictError, EngineError
|
||||
from site_engine.parsing.yamlio import YamlError, load_yaml
|
||||
from site_engine.services.auth import AuditLog, Principal
|
||||
from site_engine.services.documents import AuditCommitError, EditorContext
|
||||
from site_engine.services.entries import EntryService
|
||||
from site_engine.services.pages import PageService
|
||||
|
||||
|
||||
class DocumentTests(SiteTestCase):
|
||||
def setUp(self):
|
||||
super().setUp()
|
||||
self.audit = AuditLog(self.tmp / "audit.jsonl")
|
||||
self.context = EditorContext(Principal("editor", "session"), "127.0.0.1")
|
||||
self.svc = PageService(self.site, self.audit)
|
||||
|
||||
def test_read_and_buffer_do_not_write(self):
|
||||
s = self.svc.get("index")
|
||||
original = (self.site / s.path).read_bytes()
|
||||
t = self.svc.transform_buffer(
|
||||
"index", s.source, s.etag, {"type": "metadata", "values": {"title": "Unsaved"}}, 9
|
||||
)
|
||||
self.assertTrue(t.report.ok, asdict(t.report))
|
||||
self.assertEqual(t.model["meta"]["title"], "Unsaved")
|
||||
self.assertEqual(t.etag, s.etag)
|
||||
self.assertEqual(t.revision, 9)
|
||||
self.assertEqual((self.site / s.path).read_bytes(), original)
|
||||
self.assertFalse((self.site / ".engine").exists())
|
||||
self.assertFalse(self.audit.path.exists())
|
||||
self.svc.overlay("index", t.source, s.etag)
|
||||
self.assertEqual((self.site / s.path).read_bytes(), original)
|
||||
|
||||
def test_exact_source_save_history_and_single_audit(self):
|
||||
s = self.svc.get("index")
|
||||
source = s.source.replace("title:", "# original comment\ntitle:", 1)
|
||||
saved = self.svc.save_source("index", source, s.etag, self.context)
|
||||
self.assertEqual((self.site / s.path).read_bytes(), source.encode())
|
||||
self.assertEqual(saved.source, source)
|
||||
self.assertNotEqual(saved.etag, s.etag)
|
||||
self.assertEqual(len(self.audit.path.read_text().splitlines()), 1)
|
||||
self.assertTrue(list((self.site / ".engine/history").rglob("*.md")))
|
||||
with self.assertRaises(ConflictError):
|
||||
self.svc.save_source("index", s.source, s.etag, self.context)
|
||||
self.assertEqual(len(self.audit.path.read_text().splitlines()), 1)
|
||||
|
||||
def test_invalid_text_never_writes_or_histories(self):
|
||||
s = self.svc.get("index")
|
||||
bad = "---\ntitle: first\ntitle: duplicate\n---\n"
|
||||
result = self.svc.validate_source("index", bad, s.etag)
|
||||
self.assertIsNone(result.model)
|
||||
self.assertEqual(result.source, bad)
|
||||
with self.assertRaises(EngineError):
|
||||
self.svc.save_source("index", bad, s.etag, self.context)
|
||||
self.assertEqual(self.svc.get("index").source, s.source)
|
||||
self.assertFalse((self.site / ".engine/history").exists())
|
||||
|
||||
def test_two_writers_only_one_commits(self):
|
||||
s = self.svc.get("index")
|
||||
|
||||
def write(title):
|
||||
t = self.svc.transform_buffer(
|
||||
"index", s.source, s.etag, {"type": "metadata", "values": {"title": title}}
|
||||
)
|
||||
try:
|
||||
self.svc.save_source("index", t.source, s.etag, self.context)
|
||||
return "saved"
|
||||
except ConflictError:
|
||||
return "conflict"
|
||||
|
||||
with concurrent.futures.ThreadPoolExecutor(2) as pool:
|
||||
outcomes = list(pool.map(write, ("A", "B")))
|
||||
self.assertCountEqual(outcomes, ["saved", "conflict"])
|
||||
|
||||
def test_current_layout_schema_is_checked_under_lock(self):
|
||||
s = self.svc.get("index")
|
||||
self.write("layouts/default/layout.yaml", "id: default\nregions:\n other: {}\n")
|
||||
with self.assertRaises(EngineError):
|
||||
self.svc.save_source("index", s.source, s.etag, self.context)
|
||||
self.assertEqual((self.site / s.path).read_text(), s.source)
|
||||
|
||||
def test_nested_page_and_create_draft(self):
|
||||
s = self.svc.create("nested/test", "Nested", None, self.context)
|
||||
self.assertEqual(s.model["meta"]["status"], "draft")
|
||||
self.assertEqual(self.svc.get("nested/test").etag, s.etag)
|
||||
with self.assertRaises(ConflictError):
|
||||
self.svc.create("nested/test", "Again", None, self.context)
|
||||
for bad in ("../outside", "/absolute", "new", "a/blocks", "a//b"):
|
||||
with self.assertRaises(EngineError):
|
||||
self.svc.create(bad, "Bad", None, self.context)
|
||||
|
||||
def test_blocks_round_trip_and_read_only_layout(self):
|
||||
s = self.svc.get("index")
|
||||
for action in (
|
||||
{"type": "toggle", "block_id": "b_hero"},
|
||||
{"type": "move", "block_id": "b_hero", "direction": "down"},
|
||||
):
|
||||
s = self.svc.transform_buffer("index", s.source, s.etag, action)
|
||||
self.assertTrue(s.report.ok, asdict(s.report))
|
||||
denied = self.svc.transform_buffer(
|
||||
"index", s.source, s.etag, {"type": "delete", "block_id": "missing_fixed"}
|
||||
)
|
||||
self.assertFalse(denied.report.ok)
|
||||
self.assertEqual(denied.source, s.source)
|
||||
|
||||
def test_entry_fields_identity_and_exact_save(self):
|
||||
svc = EntryService(self.site, self.audit, "services")
|
||||
s = svc.get("bots")
|
||||
t = svc.transform_buffer(
|
||||
"bots",
|
||||
s.source,
|
||||
s.etag,
|
||||
{"type": "entry_fields", "values": {"title": "Buffer entry"}, "body": "Markdown\n"},
|
||||
)
|
||||
self.assertTrue(t.report.ok, asdict(t.report))
|
||||
self.assertEqual(svc.get("bots").source, s.source)
|
||||
saved = svc.save_source("bots", t.source, t.etag, self.context)
|
||||
self.assertEqual(saved.model["body"], "Markdown\n")
|
||||
self.assertFalse(
|
||||
svc.validate_source(
|
||||
"bots", saved.source.replace("status:", "slug: another\nstatus:", 1), saved.etag
|
||||
).report.ok
|
||||
)
|
||||
|
||||
def test_duplicate_subtree_generates_ids_preserves_sources_and_does_not_write(self):
|
||||
from site_engine.core.page_ops import all_ids
|
||||
from site_engine.parsing import frontmatter
|
||||
|
||||
self.write(
|
||||
"fragments/slot_probe/fragment.yaml",
|
||||
"id: slot_probe\nname: Slots\ncategory: test\nfields: []\nslots:\n main: {}\n",
|
||||
)
|
||||
self.write("fragments/slot_probe/template.html.j2", "{{ slots.main }}")
|
||||
snapshot = self.svc.get("index")
|
||||
meta, body = frontmatter.parse(snapshot.source)
|
||||
hero = meta["regions"]["main"][0]
|
||||
hero["anchor"] = "hero-anchor"
|
||||
hero["props"]["title"] = {"bind": "page.title"}
|
||||
parent = {
|
||||
"id": "b_parent",
|
||||
"fragment": "slot_probe",
|
||||
"anchor": "parent-anchor",
|
||||
"hidden": True,
|
||||
"note": "Keep me",
|
||||
"slots": {"main": [hero]},
|
||||
}
|
||||
meta["regions"]["main"][0] = parent
|
||||
source = frontmatter.dumps(meta, body)
|
||||
result = self.svc.transform_buffer(
|
||||
"index", source, snapshot.etag, {"type": "duplicate", "block_id": "b_parent"}, 7
|
||||
)
|
||||
self.assertTrue(result.report.ok, asdict(result.report))
|
||||
original, clone = result.model["meta"]["regions"]["main"][:2]
|
||||
self.assertEqual(original, parent)
|
||||
self.assertNotEqual(clone["id"], parent["id"])
|
||||
self.assertRegex(clone["id"], r"^slot_probe_[a-z0-9]{5}$")
|
||||
self.assertRegex(clone["slots"]["main"][0]["id"], r"^hero_[a-z0-9]{5}$")
|
||||
self.assertNotEqual(clone["slots"]["main"][0]["id"], hero["id"])
|
||||
self.assertNotIn("anchor", clone)
|
||||
self.assertNotIn("anchor", clone["slots"]["main"][0])
|
||||
self.assertEqual(clone["slots"]["main"][0]["props"], hero["props"])
|
||||
self.assertEqual(clone["note"], "Keep me")
|
||||
self.assertTrue(clone["hidden"])
|
||||
self.assertEqual(len(all_ids(result.model["meta"])), len(all_ids(meta)) + 2)
|
||||
self.assertEqual(self.svc.get("index").source, snapshot.source)
|
||||
self.assertEqual(result.revision, 7)
|
||||
self.assertFalse(self.audit.path.exists())
|
||||
|
||||
def test_catalog_props_are_validated_and_fixed_blocks_cannot_duplicate(self):
|
||||
snapshot = self.svc.get("index")
|
||||
action = {
|
||||
"type": "add",
|
||||
"fragment": "hero",
|
||||
"region": "main",
|
||||
"props": {"title": "Catalog title"},
|
||||
}
|
||||
result = self.svc.transform_buffer("index", snapshot.source, snapshot.etag, action)
|
||||
self.assertTrue(result.report.ok, asdict(result.report))
|
||||
self.assertEqual(
|
||||
result.model["meta"]["regions"]["main"][-1]["props"]["title"], "Catalog title"
|
||||
)
|
||||
for denied in (
|
||||
{"type": "duplicate", "block_id": "lh_header"},
|
||||
dict(action, region="header"),
|
||||
dict(action, props={"title": 42}),
|
||||
):
|
||||
refused = self.svc.transform_buffer("index", snapshot.source, snapshot.etag, denied)
|
||||
self.assertFalse(refused.report.ok)
|
||||
self.assertEqual(refused.source, snapshot.source)
|
||||
self.assertIsNotNone(refused.model)
|
||||
self.assertEqual(self.svc.get("index").source, snapshot.source)
|
||||
|
||||
def test_audit_failure_reports_committed_snapshot(self):
|
||||
s = self.svc.get("index")
|
||||
with (
|
||||
patch.object(self.audit, "write", side_effect=OSError("disk")),
|
||||
self.assertRaises(AuditCommitError) as raised,
|
||||
):
|
||||
self.svc.save_source("index", s.source, s.etag, self.context)
|
||||
self.assertEqual(raised.exception.snapshot.etag, self.svc.get("index").etag)
|
||||
|
||||
def test_duplicates_and_aliases_rejected(self):
|
||||
for text in (
|
||||
"a: 1\na: 2",
|
||||
"a:\n b: 1\n b: 2",
|
||||
"a: &x value\nb: *x",
|
||||
"[" * 2000 + "0" + "]" * 2000,
|
||||
):
|
||||
with self.assertRaises(YamlError):
|
||||
load_yaml(text)
|
||||
|
||||
def test_scope_cannot_be_bypassed_through_symlink_or_traversal(self):
|
||||
from site_engine.errors import UnsafePathError
|
||||
|
||||
target = self.site / "layouts/default/layout.html.j2"
|
||||
original = target.read_bytes()
|
||||
link = self.site / "pages/code.md"
|
||||
link.symlink_to(target)
|
||||
for rel in ("pages/code.md", "pages/../layouts/default/layout.html.j2"):
|
||||
with self.assertRaises(UnsafePathError):
|
||||
self.svc.content.write(rel, "code changed", "absent")
|
||||
self.assertEqual(target.read_bytes(), original)
|
||||
|
||||
def test_invalid_structural_action_retains_valid_input(self):
|
||||
s = self.svc.get("index")
|
||||
t = self.svc.transform_buffer(
|
||||
"index", s.source, s.etag, {"type": "add", "fragment": "hero", "region": "missing"}
|
||||
)
|
||||
self.assertFalse(t.report.ok)
|
||||
self.assertEqual(t.source, s.source)
|
||||
self.assertIsNotNone(t.model)
|
||||
|
||||
def test_nested_slots_queries_and_bindings_survive_constructor(self):
|
||||
self.write(
|
||||
"fragments/slot_probe/fragment.yaml",
|
||||
"id: slot_probe\nname: Slots\ncategory: test\nfields: []\nslots:\n main: {}\n",
|
||||
)
|
||||
self.write("fragments/slot_probe/template.html.j2", "<section>{{ slots.main }}</section>")
|
||||
from site_engine.parsing import frontmatter
|
||||
|
||||
s = self.svc.get("index")
|
||||
meta, body = frontmatter.parse(s.source)
|
||||
original = meta["regions"]["main"][0]
|
||||
meta["regions"]["main"][0] = {
|
||||
"id": "b_parent",
|
||||
"fragment": "slot_probe",
|
||||
"slots": {"main": [original]},
|
||||
}
|
||||
source = frontmatter.dumps(meta, body)
|
||||
t = self.svc.transform_buffer(
|
||||
"index", source, s.etag, {"type": "toggle", "block_id": "b_hero"}
|
||||
)
|
||||
self.assertTrue(t.report.ok, asdict(t.report))
|
||||
hero = t.model["meta"]["regions"]["main"][0]["slots"]["main"][0]
|
||||
self.assertTrue(hero["hidden"])
|
||||
self.assertEqual(hero["props"], original["props"])
|
||||
self.assertEqual(t.model["meta"]["regions"]["main"][1], meta["regions"]["main"][1])
|
||||
cycle = self.svc.transform_buffer(
|
||||
"index", t.source, s.etag, {"type": "move", "block_id": "b_parent", "before": "b_hero"}
|
||||
)
|
||||
self.assertFalse(cycle.report.ok)
|
||||
self.assertEqual(cycle.source, t.source)
|
||||
@@ -92,15 +92,18 @@ class AccessTest(EditorTestCase):
|
||||
self.assertEqual(result.status, 200, path)
|
||||
self.assertIn("frame-ancestors 'none'", result.headers["Content-Security-Policy"], path)
|
||||
self.assertEqual(result.headers["Cache-Control"], "no-store")
|
||||
for bad in ("<script", "style=", "<style", "onclick="):
|
||||
self.assertNotRegex(result.body, r"<script(?![^>]*\bsrc=)")
|
||||
for bad in ("style=", "<style", "onclick="):
|
||||
self.assertNotIn(bad, result.body, f"{path}: {bad}")
|
||||
|
||||
def test_htmx_is_enabled_only_when_the_file_is_present(self):
|
||||
self.assertNotIn("hx-boost", self.get("/pages").body)
|
||||
with mock.patch("site_engine.web.admin.editor.htmx_available", return_value=True):
|
||||
body = self.get("/pages").body
|
||||
body = self.get("/pages").body
|
||||
self.assertIn("hx-boost='true'", body)
|
||||
self.assertIn("src='/admin/static/htmx.min.js'", body)
|
||||
with mock.patch("site_engine.web.admin.editor.htmx_available", return_value=False):
|
||||
fallback = self.get("/pages").body
|
||||
self.assertNotIn("<body data-skin='light' hx-boost='true'", fallback)
|
||||
self.assertNotIn("src='/admin/static/htmx.min.js'", fallback)
|
||||
|
||||
def test_titles_are_escaped(self):
|
||||
self.edit("pages/privacy.md", "title: Политика обработки персональных данных", "title: '<script>alert(1)</script>'")
|
||||
@@ -277,7 +280,7 @@ class BlockTest(EditorTestCase):
|
||||
"region": "main", "fragment": "disclaimer"})
|
||||
self.assertEqual(result.status, 303)
|
||||
location = result.headers["Location"]
|
||||
self.assertRegex(location, r"^/admin/pages/privacy/blocks/b_[a-z0-9]{5}\?msg=added$")
|
||||
self.assertRegex(location, r"^/admin/pages/privacy/blocks/disclaimer_[a-z0-9]{5}\?msg=added$")
|
||||
block_id = location.split("/blocks/")[1].split("?")[0]
|
||||
path = f"/pages/privacy/blocks/{block_id}"
|
||||
self.submit_form(path, f"/admin{path}", p__text="Важная **оговорка**")
|
||||
|
||||
@@ -166,6 +166,9 @@ class PageOpsTest(unittest.TestCase):
|
||||
a = page_ops.add_block(m, "image", region="main")
|
||||
b = page_ops.add_block(m, "disclaimer", parent="b_s", slot="content")
|
||||
c = page_ops.add_block(m, "image", region="new_region")
|
||||
self.assertRegex(a, r"^image_[a-z0-9]{5}$")
|
||||
self.assertRegex(b, r"^disclaimer_[a-z0-9]{5}$")
|
||||
self.assertRegex(c, r"^image_[a-z0-9]{5}$")
|
||||
self.assertEqual(len({a, b, c, "b_a", "b_s", "b_x", "b_y", "b_c"}), 8)
|
||||
self.assertEqual(m["regions"]["main"][-1]["id"], a)
|
||||
self.assertEqual(m["regions"]["main"][1]["slots"]["content"][-1]["id"], b)
|
||||
|
||||
+64
-7
@@ -1,36 +1,92 @@
|
||||
import shutil
|
||||
import unittest
|
||||
|
||||
from helpers import NOW, SiteTestCase
|
||||
from helpers import NOW, ROOT, SiteTestCase
|
||||
|
||||
from site_engine.core.registry import load_site
|
||||
from site_engine.core.render import Renderer
|
||||
from site_engine.core.routes import build_route_table
|
||||
from site_engine.errors import Report
|
||||
|
||||
CORE_15 = {
|
||||
CORE_FRAGMENTS = {
|
||||
"site_header", "site_footer", "hero", "page_header", "section", "columns", "richtext",
|
||||
"image", "card_grid", "collection_list", "entry_header", "cta_banner", "form", "faq", "disclaimer",
|
||||
}
|
||||
|
||||
|
||||
class BuiltinFragmentsTest(SiteTestCase):
|
||||
def test_builtin_set_is_exactly_the_15_from_adr_006(self):
|
||||
def test_builtin_set_matches_adr_006(self):
|
||||
reg = load_site(self.site)
|
||||
builtin = {f.id for f in reg.fragments.values() if f.builtin}
|
||||
self.assertEqual(builtin, CORE_15)
|
||||
self.assertEqual(builtin, CORE_FRAGMENTS)
|
||||
|
||||
def test_all_templates_compile_in_sandbox(self):
|
||||
reg = load_site(self.site)
|
||||
renderer = Renderer(reg, build_route_table(reg, Report()), Report(), now=NOW)
|
||||
for fid in CORE_15:
|
||||
for fid in CORE_FRAGMENTS:
|
||||
renderer.env.get_template(f"fragment/{fid}")
|
||||
|
||||
def test_every_builtin_has_style_and_flat_unique_id(self):
|
||||
reg = load_site(self.site)
|
||||
self.assertEqual(reg.report.errors, [])
|
||||
for fid in CORE_15:
|
||||
for fid in CORE_FRAGMENTS:
|
||||
self.assertTrue(reg.fragments[fid].style, fid)
|
||||
|
||||
def test_steps_support_more_than_three_items_and_escape_titles(self):
|
||||
shutil.copytree(
|
||||
ROOT / "examples/ai-studio/fragments/steps",
|
||||
self.site / "fragments/steps",
|
||||
dirs_exist_ok=True,
|
||||
)
|
||||
self.write("pages/process.md", """---
|
||||
schema: 1
|
||||
title: Процесс
|
||||
status: published
|
||||
regions:
|
||||
main:
|
||||
- id: process_steps
|
||||
fragment: steps
|
||||
props:
|
||||
title: Этапы
|
||||
items:
|
||||
- {title: Исследование, text: '**Проверяем** задачу.'}
|
||||
- {title: Разработка}
|
||||
- {title: Внедрение}
|
||||
- {title: '<script>unsafe()</script>'}
|
||||
---
|
||||
""")
|
||||
from site_engine.build.pipeline import build_site
|
||||
|
||||
build_site(self.site, self.out, now=NOW)
|
||||
html = (self.out / "current/process/index.html").read_text(encoding="utf-8")
|
||||
self.assertEqual(html.count("class='f-steps__item'"), 4)
|
||||
self.assertIn("aria-hidden='true'>04</span>", html)
|
||||
self.assertIn("<strong>Проверяем</strong>", html)
|
||||
self.assertIn("<script>unsafe()</script>", html)
|
||||
self.assertNotIn("<script>unsafe()", html)
|
||||
|
||||
def test_legacy_card_grid_steps_remains_supported(self):
|
||||
self.write("pages/legacy-steps.md", """---
|
||||
schema: 1
|
||||
title: Старые этапы
|
||||
status: published
|
||||
regions:
|
||||
main:
|
||||
- id: legacy_steps
|
||||
fragment: card_grid
|
||||
props:
|
||||
variant: steps
|
||||
items:
|
||||
- {title: Прежний этап}
|
||||
---
|
||||
""")
|
||||
from site_engine.build.pipeline import build_site
|
||||
|
||||
build_site(self.site, self.out, now=NOW)
|
||||
html = (self.out / "current/legacy-steps/index.html").read_text(encoding="utf-8")
|
||||
self.assertIn("f-card_grid--steps", html)
|
||||
self.assertIn("Прежний этап", html)
|
||||
|
||||
def test_nested_slots_render(self):
|
||||
self.write("pages/layout-test.md", """---
|
||||
title: Колонки
|
||||
@@ -39,7 +95,7 @@ regions:
|
||||
main:
|
||||
- id: s1
|
||||
fragment: section
|
||||
props: {title: Секция}
|
||||
props: {title: Секция, text: 'Вводный **текст** секции'}
|
||||
slots:
|
||||
content:
|
||||
- id: c1
|
||||
@@ -58,6 +114,7 @@ regions:
|
||||
html = (self.out / "current" / "layout-test" / "index.html").read_text(encoding="utf-8")
|
||||
self.assertIn("Левая колонка", html)
|
||||
self.assertIn("f-columns--2", html)
|
||||
self.assertIn("Вводный <strong>текст</strong> секции", html)
|
||||
|
||||
def test_slot_depth_limit(self):
|
||||
from site_engine.core.models import parse_block
|
||||
|
||||
@@ -45,7 +45,11 @@ class PackagingTest(unittest.TestCase):
|
||||
after = {name: (ROOT / name).exists() for name in before}
|
||||
self.assertEqual(after, before, "сборка wheel не должна оставлять мусор в рабочем каталоге")
|
||||
for needed in ("site_engine/web/admin/templates/login.html.j2", "site_engine/web/admin/templates/page_edit.html.j2",
|
||||
"site_engine/web/admin/static/admin.css", "site_engine/builtin/base.css",
|
||||
"site_engine/web/admin/static/admin.css", "site_engine/web/admin/static/htmx.min.js",
|
||||
"site_engine/web/admin/static/VENDOR.md", "site_engine/web/admin/static/admin.js",
|
||||
"site_engine/web/admin/static/editor.js", "site_engine/web/admin/static/preview.js",
|
||||
"site_engine/web/admin/templates/document.html.j2", "site_engine/web/admin/templates/editor_result.html.j2",
|
||||
"site_engine/web/admin/templates/preview_result.html.j2", "site_engine/builtin/base.css",
|
||||
"site_engine/builtin/fragments/hero/template.html.j2"):
|
||||
self.assertIn(needed, names)
|
||||
|
||||
|
||||
@@ -0,0 +1,189 @@
|
||||
"""Preview tokens, origins, protected assets and public-build separation."""
|
||||
|
||||
import os
|
||||
from unittest.mock import patch
|
||||
from urllib.parse import urlsplit
|
||||
|
||||
from fastapi.testclient import TestClient
|
||||
from helpers import SiteTestCase
|
||||
|
||||
from site_engine.build.pipeline import build_site
|
||||
from site_engine.errors import UnsafePathError
|
||||
from site_engine.services.auth import Principal
|
||||
from site_engine.services.pages import PageService
|
||||
from site_engine.services.preview import PreviewConfig, PreviewStore, asset_path
|
||||
from site_engine.web.preview_app import create_preview_app
|
||||
|
||||
|
||||
class PreviewTests(SiteTestCase):
|
||||
def setUp(self):
|
||||
super().setUp()
|
||||
self.state = self.tmp / "state"
|
||||
self.config = PreviewConfig("http://127.0.0.1:9100", "http://127.0.0.1:9101")
|
||||
self.time = [1000.0]
|
||||
self.store = PreviewStore(
|
||||
self.state, b"secret-" * 8, self.config, clock=lambda: self.time[0]
|
||||
)
|
||||
self.svc = PageService(self.site)
|
||||
self.principal = Principal("admin", "session")
|
||||
self.s = self.svc.get("index")
|
||||
|
||||
def preview(self):
|
||||
return self.store.render(self.svc, "index", self.s.source, self.s.etag, 4, self.principal)
|
||||
|
||||
def token(self, p):
|
||||
return urlsplit(p["url"]).query.removeprefix("token=")
|
||||
|
||||
def test_token_identity_expiry_epoch_and_cleanup(self):
|
||||
p = self.preview()
|
||||
token = self.token(p)
|
||||
folder, data = self.store.authorize(p["snapshot"], token)
|
||||
self.assertEqual(data["revision"], 4)
|
||||
for snapshot, tok in ((p["snapshot"], token + "bad"), ("a" * 32, token)):
|
||||
with self.assertRaises(PermissionError):
|
||||
self.store.authorize(snapshot, tok)
|
||||
self.time[0] += 601
|
||||
with self.assertRaises(PermissionError):
|
||||
self.store.authorize(p["snapshot"], token)
|
||||
self.time[0] = 1000
|
||||
self.state.joinpath("auth_epoch").write_text("1")
|
||||
with self.assertRaises(PermissionError):
|
||||
self.store.authorize(p["snapshot"], token)
|
||||
self.preview()
|
||||
self.assertFalse(folder.exists())
|
||||
|
||||
def test_last_twenty_snapshots_per_session_document(self):
|
||||
first = self.preview()
|
||||
for i in range(21):
|
||||
self.time[0] += 1
|
||||
self.preview()
|
||||
self.assertEqual(len(list(self.store.directory.iterdir())), 20)
|
||||
with self.assertRaises(PermissionError):
|
||||
self.store.authorize(first["snapshot"], self.token(first))
|
||||
|
||||
def test_immutable_assets_unsaved_source_and_no_canonical_write(self):
|
||||
self.write("assets/new.svg", '<svg xmlns="http://www.w3.org/2000/svg"/>')
|
||||
original = (self.site / self.s.path).read_bytes()
|
||||
source = self.s.source.replace("title: Главная", "title: Unsaved preview")
|
||||
p = self.store.render(self.svc, "index", source, self.s.etag, 5, self.principal)
|
||||
folder, _ = self.store.authorize(p["snapshot"], self.token(p))
|
||||
html = (folder / "index.html").read_text()
|
||||
self.assertIn("Unsaved preview", html)
|
||||
self.assertIn('data-preview-scope="page"', html)
|
||||
self.assertIn('data-preview-scope="layout"', html)
|
||||
self.assertIn("preview:ready", html)
|
||||
self.assertEqual(
|
||||
(folder / "assets/new.svg").read_bytes(), (self.site / "assets/new.svg").read_bytes()
|
||||
)
|
||||
self.write("assets/new.svg", "changed")
|
||||
self.assertIn("<svg", (folder / "assets/new.svg").read_text())
|
||||
self.assertEqual((self.site / self.s.path).read_bytes(), original)
|
||||
self.assertFalse((self.out / "current").exists())
|
||||
|
||||
def test_scriptless_preview_has_selection_markers_without_enabling_scripts(self):
|
||||
from site_engine.web.preview_app import snapshot_response
|
||||
|
||||
with patch.object(self.store, "config", None):
|
||||
preview = self.preview()
|
||||
folder, _ = self.store.authorize(preview["snapshot"], self.token(preview))
|
||||
html = (folder / "index.html").read_text()
|
||||
self.assertIn('data-preview-scope="page"', html)
|
||||
self.assertIn('data-preview-scope="layout"', html)
|
||||
self.assertIn("data-preview-selected", html)
|
||||
self.assertNotIn("preview:ready", html)
|
||||
self.assertFalse(preview["interactive"])
|
||||
response = snapshot_response(self.store, preview["snapshot"], self.token(preview))
|
||||
self.assertIn("script-src 'none'", response.headers["content-security-policy"])
|
||||
self.assertEqual(response.headers["x-frame-options"], "SAMEORIGIN")
|
||||
|
||||
def test_symlink_and_traversal_rejected(self):
|
||||
self.write("assets/real.txt", "inside")
|
||||
(self.site / "assets/link.txt").symlink_to(self.site / "assets/real.txt")
|
||||
for rel in ("../site.yaml", "link.txt", "a/../real.txt", "/etc/passwd"):
|
||||
with self.assertRaises((UnsafePathError, FileNotFoundError)):
|
||||
asset_path(self.site / "assets", rel)
|
||||
with self.assertRaises(UnsafePathError):
|
||||
self.preview()
|
||||
|
||||
def test_separate_app_has_no_admin_and_checks_every_resource(self):
|
||||
p = self.preview()
|
||||
env = {
|
||||
"SITE_ADMIN_ORIGIN": self.config.admin,
|
||||
"SITE_PREVIEW_ORIGIN": self.config.preview,
|
||||
"SITE_STATE_DIR": str(self.state),
|
||||
"SITE_SECRET_KEY": ("secret-" * 8),
|
||||
}
|
||||
with patch.dict(os.environ, env):
|
||||
app = create_preview_app()
|
||||
# Factory uses wall clock: use a live-clock snapshot for actual ASGI requests.
|
||||
store = PreviewStore(self.state, b"secret-" * 8, self.config)
|
||||
self.write("assets/new.svg", '<svg xmlns="http://www.w3.org/2000/svg"/>')
|
||||
p = store.render(self.svc, "index", self.s.source, self.s.etag, 4, self.principal)
|
||||
parsed = urlsplit(p["url"])
|
||||
with TestClient(app) as client:
|
||||
self.assertEqual(client.get("/admin/login").status_code, 404)
|
||||
self.assertEqual(client.get("/admin/api/v1/site").status_code, 404)
|
||||
self.assertEqual(client.get(parsed.path).status_code, 403)
|
||||
response = client.get(parsed.path + "?" + parsed.query)
|
||||
self.assertEqual(response.status_code, 200)
|
||||
self.assertNotIn("x-frame-options", response.headers)
|
||||
self.assertIn(
|
||||
"frame-ancestors " + self.config.admin, response.headers["content-security-policy"]
|
||||
)
|
||||
self.assertNotIn("script-src 'self'", response.headers["content-security-policy"])
|
||||
asset = f"/s/{p['snapshot']}/assets/new.svg"
|
||||
self.assertEqual(client.get(asset).status_code, 403)
|
||||
self.assertEqual(client.get(asset + "?" + parsed.query).status_code, 200)
|
||||
self.state.joinpath("auth_epoch").write_text("1")
|
||||
self.assertEqual(client.get(asset + "?" + parsed.query).status_code, 403)
|
||||
|
||||
def test_display_markers_and_public_build_no_bridge(self):
|
||||
from site_engine.services.entries import EntryService
|
||||
|
||||
svc = EntryService(self.site, collection="services")
|
||||
s = svc.get("bots")
|
||||
p = self.store.render(svc, "bots", s.source, s.etag, 1, self.principal)
|
||||
folder, _ = self.store.authorize(p["snapshot"], self.token(p))
|
||||
self.assertIn('data-preview-scope="display"', (folder / "index.html").read_text())
|
||||
build_site(self.site, self.out)
|
||||
html = "".join(p.read_text() for p in (self.out / "current").rglob("*.html"))
|
||||
self.assertNotIn("data-preview-", html)
|
||||
self.assertNotIn("preview:ready", html)
|
||||
|
||||
def test_origin_validation(self):
|
||||
invalid = [
|
||||
("https://cms.example", "https://cms.example"),
|
||||
("http://cms.example", "https://p.example"),
|
||||
("https://cms.example/", "https://p.example"),
|
||||
("https://cms.example", ""),
|
||||
("https://CMS.example", "https://cms.example:443"),
|
||||
]
|
||||
for a, p in invalid:
|
||||
with (
|
||||
patch.dict(os.environ, {"SITE_ADMIN_ORIGIN": a, "SITE_PREVIEW_ORIGIN": p}),
|
||||
self.assertRaises(ValueError),
|
||||
):
|
||||
PreviewConfig.from_env()
|
||||
|
||||
def test_css_dependencies_have_tokens_and_normalized_paths(self):
|
||||
from site_engine.services.preview import rewrite_css
|
||||
|
||||
text = rewrite_css(
|
||||
'@import "other.css";a{background:url(../image.svg?v=1)}',
|
||||
"css/main.css",
|
||||
"/s/snapshot/assets/",
|
||||
"TOKEN",
|
||||
)
|
||||
self.assertIn("/s/snapshot/assets/css/other.css?token=TOKEN", text)
|
||||
self.assertIn("/s/snapshot/assets/image.svg?v=1&token=TOKEN", text)
|
||||
|
||||
def test_markers_do_not_add_wrappers_or_confuse_scopes(self):
|
||||
from site_engine.core.preview_marks import mark_roots
|
||||
|
||||
html = '<section><img src="x"><p>Text</p></section><aside>Other</aside>'
|
||||
page = mark_roots(html, "page", "index", "same")
|
||||
layout = mark_roots(html, "layout", "default", "same")
|
||||
self.assertEqual(page.count('data-preview-id="same"'), 2)
|
||||
self.assertEqual(page.count("<section"), 1)
|
||||
self.assertIn('data-preview-scope="layout"', layout)
|
||||
self.assertIn('data-preview-owner="default"', layout)
|
||||
@@ -0,0 +1,77 @@
|
||||
"""Live comparison must follow the actual immutable release, including rollback."""
|
||||
|
||||
import hashlib
|
||||
import json
|
||||
|
||||
from helpers import NOW, SiteTestCase
|
||||
|
||||
from site_engine.build.pipeline import build_site
|
||||
from site_engine.services.publish import rollback
|
||||
from site_engine.services.workspace import filter_pages, workspace
|
||||
|
||||
|
||||
class WorkspaceTest(SiteTestCase):
|
||||
def view(self):
|
||||
return workspace(self.site, self.out, self.tmp / "state")
|
||||
|
||||
def row(self, identity="index"):
|
||||
return next(p for p in self.view()["pages"] if p["id"] == identity)
|
||||
|
||||
def test_manifest_indexes_only_published_page_hashes(self):
|
||||
build_site(self.site, self.out, now=NOW)
|
||||
manifest = json.loads((self.out / "current/manifest.json").read_text())
|
||||
indexed = manifest["page_sources"]
|
||||
self.assertEqual(len(indexed), 4)
|
||||
self.assertNotIn("pages/drafts/next.md", indexed)
|
||||
self.assertEqual(
|
||||
indexed["pages/index.md"],
|
||||
hashlib.sha256((self.site / "pages/index.md").read_bytes()).hexdigest(),
|
||||
)
|
||||
|
||||
def test_edit_revert_publish_and_rollback_use_current_snapshot(self):
|
||||
self.assertTrue(all(p["changed"] for p in self.view()["pages"]))
|
||||
first = build_site(self.site, self.out, now=NOW)
|
||||
self.assertFalse(self.row()["changed"])
|
||||
self.assertTrue(self.row("drafts/next")["changed"])
|
||||
original = (self.site / "pages/index.md").read_bytes()
|
||||
(self.site / "pages/index.md").write_bytes(original + b"\n")
|
||||
self.assertTrue(self.row()["changed"])
|
||||
(self.site / "pages/index.md").write_bytes(original)
|
||||
self.assertFalse(self.row()["changed"])
|
||||
(self.site / "pages/index.md").write_bytes(original + b"\n")
|
||||
build_site(self.site, self.out, now=NOW.replace(minute=1))
|
||||
self.assertFalse(self.row()["changed"])
|
||||
rollback(self.out, first.build_id)
|
||||
self.assertTrue(self.row()["changed"])
|
||||
self.assertEqual(self.view()["release"]["current"], first.build_id)
|
||||
|
||||
def test_legacy_release_has_unknown_comparison(self):
|
||||
build_site(self.site, self.out, now=NOW)
|
||||
path = self.out / "current/manifest.json"
|
||||
manifest = json.loads(path.read_text())
|
||||
del manifest["page_sources"]
|
||||
path.write_text(json.dumps(manifest))
|
||||
self.assertFalse(self.view()["comparison_available"])
|
||||
self.assertIsNone(self.row()["changed"])
|
||||
self.assertEqual(filter_pages(self.view()["pages"], changed=True), [])
|
||||
|
||||
def test_search_filter_intersection_and_real_metadata(self):
|
||||
rows = self.view()["pages"]
|
||||
self.assertEqual(
|
||||
[
|
||||
p["id"]
|
||||
for p in filter_pages(
|
||||
rows, q="SERVICES/INDEX", status="published", layout="default", changed=True
|
||||
)
|
||||
],
|
||||
["services/index"],
|
||||
)
|
||||
self.assertEqual(filter_pages(rows, q="services", status="draft"), [])
|
||||
self.assertIn("T", self.row()["updated_at"])
|
||||
self.assertFalse(self.row()["on_live"])
|
||||
self.edit(
|
||||
"pages/index.md",
|
||||
"description: Telegram-боты, AI-системы и автоматизации под ваши процессы",
|
||||
"description: {bind: site.name}",
|
||||
)
|
||||
self.assertEqual(self.row()["description"], "")
|
||||
Reference in New Issue
Block a user