Spaces:
Running
Running
| """Self-check: what the builder makes has to be something YOOtheme will render. | |
| The failure this guards against is silent. YOOtheme does not reject a headline | |
| placed straight into a section — it renders an empty band, the operator sees a | |
| gap where their change should be, and nothing in any log says why. So the | |
| nesting contract is enforced before the write, and the presets are checked | |
| against the same contract they are supposed to demonstrate. | |
| Run: python3 test_builder.py | |
| """ | |
| import builder | |
| def test_the_nesting_contract_is_refused_not_rendered_blank(): | |
| for parent, child in ((builder.section(), builder.headline("x")), | |
| (builder.section(), builder.column()), | |
| (builder.row(), builder.text("x")), | |
| (builder.column(), builder.section())): | |
| try: | |
| builder.place(parent, child) | |
| except ValueError as e: | |
| assert parent["type"] in str(e) or "column" in str(e) | |
| else: | |
| raise AssertionError( | |
| f"a {child['type']} inside a {parent['type']} must be refused") | |
| def test_the_legal_nesting_is_accepted(): | |
| page = {"type": "layout", "children": []} | |
| sec = builder.place(page, builder.section()) | |
| r = builder.place(sec, builder.row()) | |
| col = builder.place(r, builder.column("1-2")) | |
| builder.place(col, builder.headline("Hello")) | |
| builder.place(col, builder.button("Go", "/somewhere")) | |
| assert [c["type"] for c in col["children"]] == ["headline", "button"] | |
| assert col["props"]["width_default"] == "1-2" | |
| def test_a_bare_element_gets_the_column_it_needs(): | |
| """The common request is "add a button here". A button with no column around | |
| it renders nothing, so the wrapper is built rather than the request refused.""" | |
| wrapped = builder.wrap(builder.button("Donate")) | |
| assert wrapped["type"] == "section" | |
| assert wrapped["children"][0]["type"] == "row" | |
| assert wrapped["children"][0]["children"][0]["type"] == "column" | |
| assert wrapped["children"][0]["children"][0]["children"][0]["type"] == "button" | |
| # something already well-formed is passed through untouched | |
| sec = builder.section() | |
| assert builder.wrap(sec) is sec | |
| def test_a_grid_divides_evenly_unless_told_otherwise(): | |
| three = builder.grid([[builder.text("a")], [builder.text("b")], [builder.text("c")]]) | |
| assert [c["props"]["width_default"] for c in three["children"]] == ["1-3"] * 3 | |
| split = builder.grid([[builder.text("a")], [builder.text("b")]], widths=["2-3", "1-3"]) | |
| assert [c["props"]["width_default"] for c in split["children"]] == ["2-3", "1-3"] | |
| def test_moving_a_node_stays_within_its_siblings(): | |
| col = builder.column(children=[builder.text("a"), builder.text("b"), builder.text("c")]) | |
| builder.move(col, 0, 2) | |
| assert [c["props"]["content"] for c in col["children"]] == ["b", "c", "a"] | |
| builder.move(col, 2, 99) # clamped, not an error | |
| assert [c["props"]["content"] for c in col["children"]] == ["b", "c", "a"] | |
| try: | |
| builder.move(col, 7, 0) | |
| except ValueError as e: | |
| assert "index" in str(e) | |
| else: | |
| raise AssertionError("moving a child that is not there must be refused") | |
| def test_every_catalogued_preset_loads_and_is_a_section(): | |
| """A preset listed but missing is worse than one never offered — the | |
| catalogue is what a builder reads before it commits to a plan.""" | |
| cat = builder.catalogue() | |
| assert cat["sections"], "no presets were found at all" | |
| for entry in cat["sections"]: | |
| node = builder.preset(entry["name"]) | |
| assert node.get("type") == "section", f"{entry['name']} is not a section" | |
| assert node.get("children"), f"{entry['name']} is empty" | |
| def test_presets_obey_the_contract_they_demonstrate(): | |
| for entry in builder.catalogue()["sections"]: | |
| node = builder.preset(entry["name"]) | |
| stack = [node] | |
| while stack: | |
| parent = stack.pop() | |
| for child in parent.get("children") or []: | |
| builder.check(parent, child) # raises if the nesting is wrong | |
| stack.append(child) | |
| def test_a_preset_is_fresh_every_time(): | |
| """Callers mutate what they get. Handing out one shared dict would let the | |
| second page inherit the first page's edits.""" | |
| first = builder.preset(builder.catalogue()["sections"][0]["name"]) | |
| first["props"]["name"] = "changed" | |
| second = builder.preset(builder.catalogue()["sections"][0]["name"]) | |
| assert second["props"].get("name") != "changed" | |
| def test_unknown_elements_and_bad_props_say_what_is_wrong(): | |
| try: | |
| builder.element("carousel") | |
| except ValueError as e: | |
| assert "carousel" in str(e) and "headline" in str(e) | |
| else: | |
| raise AssertionError("an unknown element must be named in the error") | |
| try: | |
| builder.element("headline", nonsense=1) | |
| except ValueError as e: | |
| assert "headline" in str(e) | |
| else: | |
| raise AssertionError("an impossible prop must be refused") | |
| def test_a_prop_key_is_only_ever_recorded_when_it_was_seen(): | |
| """The line this whole module draws. The docs name 39 elements and describe | |
| their settings in words; the real keys live in element.php inside the theme, | |
| which nothing here can read. So a documented element stays unconfirmed until | |
| a layout proves its slug, and a wrong key is worse than a missing one — it | |
| renders without complaint and the setting silently does nothing.""" | |
| import vocabulary | |
| for slug, entry in vocabulary.documented().items(): | |
| assert not entry.get("props"), f"{slug} was never seen but claims prop keys" | |
| for slug in vocabulary.confirmed(): | |
| assert vocabulary.props(slug) or slug in vocabulary.STRUCTURAL, \ | |
| f"{slug} is marked confirmed with nothing observed" | |
| def test_learning_a_layout_adds_only_what_that_layout_contained(): | |
| import vocabulary | |
| layout = {"type": "layout", "children": [ | |
| {"type": "section", "props": {}, "children": [ | |
| {"type": "row", "props": {}, "children": [ | |
| {"type": "column", "props": {}, "children": [ | |
| {"type": "invented_element", "props": {"made_up_key": 1}}]}]}]}]} | |
| got = vocabulary.learn(layout, save=False) | |
| assert "invented_element" in got["new_elements"] | |
| assert "invented_element.made_up_key" in got["new_props"] | |
| # and nothing was invented on its behalf | |
| assert not [p for p in got["new_props"] if p.startswith("invented_element.") | |
| and p != "invented_element.made_up_key"] | |
| def test_the_documented_catalogue_matches_what_yootheme_publishes(): | |
| """39 elements across three pages, checked against the live docs on | |
| 2026-07-28: 16 basic + 16 multiple-items + 7 system. If a future import | |
| disagrees, the scrape lost something.""" | |
| import json | |
| import vocabulary | |
| data = json.loads(vocabulary.FILE.read_text()) | |
| pages = [e.get("documented_in") for e in data["elements"].values() if e.get("documented_in")] | |
| assert pages.count("basic-elements") == 16, pages.count("basic-elements") | |
| assert pages.count("multiple-items-elements") == 16 | |
| assert pages.count("system-elements") == 7 | |
| if __name__ == "__main__": | |
| for name, fn in sorted(globals().items()): | |
| if name.startswith("test_"): | |
| fn() | |
| print(f"ok {name}") | |
| print("builder self-check passed") | |