191 lines
10 KiB
Python
191 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.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()
|