Files
flexly-cms/tests/test_editor_forms.py
phelex 88ac95dd19 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.
2026-11-12 21:55:36 +03:00

194 lines
10 KiB
Python

import datetime as dt
import unittest
from site_engine.core import page_ops
from site_engine.core.models import FieldDef
from site_engine.web.admin.forms import UNSET, FormData, build_view, parse_field, parse_props
F = FieldDef
def form(**kw):
return FormData({k.replace("__", "."): ([v] if isinstance(v, str) else v) for k, v in kw.items()})
class ParseTest(unittest.TestCase):
def parse(self, fd, data, name="p.x"):
errors: list[str] = []
value = parse_field(fd, FormData(data), name, errors)
return value, errors
def test_empty_values_are_unset(self):
for fd in (F("x", "text"), F("x", "textarea"), F("x", "number"), F("x", "select", options=["a"]),
F("x", "boolean"), F("x", "list", of="text"), F("x", "link"), F("x", "query")):
self.assertIs(self.parse(fd, {})[0], UNSET, fd.type)
self.assertIs(self.parse(fd, {"p.x": [""]})[0], UNSET, fd.type)
def test_text_number_boolean_select(self):
self.assertEqual(self.parse(F("x", "text"), {"p.x": [" привет "]})[0], "привет")
self.assertEqual(self.parse(F("x", "number"), {"p.x": ["3"]})[0], 3)
self.assertEqual(self.parse(F("x", "number"), {"p.x": ["2,5"]})[0], 2.5)
self.assertEqual(self.parse(F("x", "boolean"), {"p.x": ["false"]})[0], False)
self.assertEqual(self.parse(F("x", "select", options=[2, 3, 4]), {"p.x": ["3"]})[0], 3) # тип варианта сохраняется
def test_errors_are_reported_not_raised(self):
value, errors = self.parse(F("x", "number", label="Число"), {"p.x": ["abc"]})
self.assertIs(value, UNSET)
self.assertIn("Число", errors[0])
self.assertTrue(self.parse(F("x", "select", options=["a"]), {"p.x": ["b"]})[1])
self.assertTrue(self.parse(F("x", "date"), {"p.x": ["31.12.2026"]})[1])
self.assertTrue(self.parse(F("x", "date"), {"p.x": ["2026-02-31"]})[1])
def test_date_becomes_date_object(self):
self.assertEqual(self.parse(F("x", "date"), {"p.x": ["2026-03-12"]})[0], dt.date(2026, 3, 12))
def test_textarea_normalizes_newlines(self):
self.assertEqual(self.parse(F("x", "markdown"), {"p.x": ["a\r\nb\r\n\r\n"]})[0], "a\nb")
def test_bind_wins_over_literal_and_is_validated(self):
value, _ = self.parse(F("x", "markdown"), {"p.x": ["текст"], "p.x._bind": ["page.body"]})
self.assertEqual(value, {"bind": "page.body"})
value, errors = self.parse(F("x", "text"), {"p.x._bind": ["os.environ"]})
self.assertIs(value, UNSET)
self.assertTrue(errors)
def test_link(self):
value, _ = self.parse(F("x", "link"), {"p.x.kind": ["page"], "p.x.target": ["contacts"], "p.x.label": ["Связь"]})
self.assertEqual(value, {"page": "contacts", "label": "Связь"})
value, _ = self.parse(F("x", "link"), {"p.x.kind": ["url"], "p.x.target": ["https://t.me/x"], "p.x.new_tab": ["1"]})
self.assertEqual(value, {"url": "https://t.me/x", "target": "_blank"})
self.assertTrue(self.parse(F("x", "link"), {"p.x.kind": ["file"], "p.x.target": ["a"]})[1])
def test_list_of_groups_skips_blank_and_deleted_rows(self):
fd = F("items", "list", fields=[F("title", "text", required=True), F("text", "markdown")])
data = {
"p.items.0.title": ["Один"], "p.items.0.text": ["a"],
"p.items.1.title": ["Удалить"], "p.items.1._del": ["1"],
"p.items.2.title": ["Три"],
"p.items.3.title": [""], "p.items.3.text": [""], # пустая строка «добавить»
}
value, errors = self.parse(fd, data, "p.items")
self.assertEqual(value, [{"title": "Один", "text": "a"}, {"title": "Три"}])
self.assertEqual(errors, [])
def test_list_of_primitives_and_links(self):
self.assertEqual(self.parse(F("t", "list", of="text"), {"p.t.0": ["a"], "p.t.1": [""], "p.t.2": ["b"]}, "p.t")[0], ["a", "b"])
value, _ = self.parse(F("a", "list", of="link"),
{"p.a.0.kind": ["page"], "p.a.0.target": ["contacts"], "p.a.1.target": [""]}, "p.a")
self.assertEqual(value, [{"page": "contacts"}])
def test_list_row_bind(self):
fd = F("meta", "list", of="text")
value, _ = self.parse(fd, {"p.meta.0._bind": ["entry.tagline"]}, "p.meta")
self.assertEqual(value, [{"bind": "entry.tagline"}])
def test_query(self):
data = {"p.s.collection": ["services"], "p.s.limit": ["3"], "p.s.sort": ["-date"], "p.s.where": ["featured: true"]}
value, errors = self.parse(F("s", "query"), data, "p.s")
self.assertEqual(value, {"query": {"collection": "services", "where": {"featured": True}, "sort": "-date", "limit": 3}})
self.assertEqual(errors, [])
self.assertTrue(self.parse(F("s", "query"), {"p.s.collection": ["a"], "p.s.limit": ["0"]}, "p.s")[1])
self.assertTrue(self.parse(F("s", "query"), {"p.s.collection": ["a"], "p.s.where": ["x: {contains: 1}"]}, "p.s")[1])
def test_refs_and_multiselect(self):
self.assertEqual(self.parse(F("r", "refs", to="s"), {"p.r": ["a, b c"]}, "p.r")[0], ["a", "b", "c"])
self.assertEqual(self.parse(F("m", "multiselect", options=["a", "b"]), {"p.m": ["a", "b"]}, "p.m")[0], ["a", "b"])
def test_parse_props_omits_unset(self):
errors: list[str] = []
props = parse_props([F("a", "text"), F("b", "text")], form(p__a="x"), "p", errors)
self.assertEqual(props, {"a": "x"})
class ViewTest(unittest.TestCase):
CTX = {"collections": ["services"], "assets": ["assets/hero.svg"], "entries": {"services": ["bots"]}, "pages": ["contacts"]}
def test_parse_of_view_roundtrip(self):
# значения → форма → значения: ничего не теряется
fields = [
F("title", "text"), F("variant", "select", options=["light", "dark"]),
F("actions", "list", of="link"),
F("items", "list", fields=[F("title", "text"), F("text", "markdown")]),
F("src", "query"), F("flag", "boolean"),
]
props = {
"title": "Привет", "variant": "dark", "flag": False,
"actions": [{"page": "contacts", "label": "Связь"}, {"url": "https://t.me/x", "target": "_blank"}],
"items": [{"title": "Один", "text": "x"}, {"title": "Два"}],
"src": {"query": {"collection": "services", "limit": 3}},
}
views = {f.key: build_view(f, props.get(f.key), f"p.{f.key}", self.CTX) for f in fields}
self.assertEqual(views["title"]["value"], "Привет")
self.assertEqual([r["blank"] for r in views["items"]["rows"]], [False, False, True])
self.assertEqual(views["actions"]["rows"][0]["item"]["target"], "contacts")
self.assertEqual(views["src"]["limit"], "3")
def test_bind_is_exposed_separately(self):
view = build_view(F("content", "markdown"), {"bind": "page.body"}, "p.content", self.CTX)
self.assertEqual((view["bind"], view["value"]), ("page.body", ""))
def test_select_marks_current_option(self):
view = build_view(F("v", "select", options=["a", "b"]), "b", "p.v", self.CTX)
self.assertEqual([o["selected"] for o in view["options"]], [False, False, True])
class PageOpsTest(unittest.TestCase):
def meta(self):
return {"title": "T", "regions": {"main": [
{"id": "b_a", "fragment": "hero"},
{"id": "b_s", "fragment": "section", "slots": {"content": [
{"id": "b_x", "fragment": "richtext"}, {"id": "b_y", "fragment": "faq"}]}},
{"id": "b_c", "fragment": "cta_banner"},
]}}
def test_find_in_slots(self):
siblings, index, block = page_ops.find_block(self.meta(), "b_y")
self.assertEqual((index, block["fragment"]), (1, "faq"))
self.assertIsNone(page_ops.find_block(self.meta(), "nope"))
def test_move_within_own_list(self):
m = self.meta()
self.assertTrue(page_ops.move_block(m, "b_y", "up"))
self.assertEqual([b["id"] for b in m["regions"]["main"][1]["slots"]["content"]], ["b_y", "b_x"])
self.assertFalse(page_ops.move_block(m, "b_y", "up")) # уже первый
self.assertFalse(page_ops.move_block(m, "b_c", "down")) # уже последний
self.assertFalse(page_ops.move_block(m, "b_c", "sideways"))
def test_delete_nested_and_unknown(self):
m = self.meta()
page_ops.delete_block(m, "b_x")
self.assertEqual([b["id"] for b in m["regions"]["main"][1]["slots"]["content"]], ["b_y"])
with self.assertRaises(KeyError):
page_ops.delete_block(m, "b_x")
def test_add_to_region_and_slot_with_unique_ids(self):
m = self.meta()
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)
self.assertIn("new_region", m["regions"])
with self.assertRaises(KeyError):
page_ops.add_block(m, "image", parent="missing", slot="content")
def test_hidden_and_field_replace_keep_unknown_props(self):
m = self.meta()
block = page_ops.find_block(m, "b_a")[2]
block["props"] = {"title": "Старый", "legacy": 1}
page_ops.replace_block_fields(block, props={"title": "Новый"}, manifest_keys={"title"}, hidden=True,
anchor="top", note=None, requires=["feature.demo"])
self.assertEqual(block["props"], {"title": "Новый", "legacy": 1})
self.assertEqual((block["hidden"], block["anchor"], block["requires"]), (True, "top", ["feature.demo"]))
page_ops.replace_block_fields(block, props={}, manifest_keys={"title", "legacy"}, hidden=False,
anchor=None, note=None, requires=[])
self.assertEqual(block, {"id": "b_a", "fragment": "hero"})
if __name__ == "__main__":
unittest.main()