| """AX button behaviour tests for massCode (Electron/Vue snippet manager).""" |
| import json |
| import os |
| import re |
| import subprocess |
| import time |
|
|
| import pytest |
| import rb_testgen_kit as kit |
|
|
| RESULTS_DIR = os.environ.get("RESULTS_DIR", os.path.dirname(os.path.abspath(__file__))) |
|
|
|
|
| def screenshot_assert(test_name, description, results_dir=None): |
| results_dir = results_dir or RESULTS_DIR |
| ss_dir = os.path.join(results_dir, "screenshots") |
| os.makedirs(ss_dir, exist_ok=True) |
| ss_path = os.path.join(ss_dir, f"{test_name}.png") |
| try: |
| subprocess.run(["screencapture", "-x", ss_path], timeout=5) |
| except Exception: |
| pass |
| assertions_file = os.path.join(ss_dir, "assertions.json") |
| assertions = {} |
| if os.path.exists(assertions_file): |
| try: |
| with open(assertions_file) as f: |
| assertions = json.load(f) |
| except Exception: |
| assertions = {} |
| assertions[f"{test_name}.png"] = description |
| with open(assertions_file, "w") as f: |
| json.dump(assertions, f, indent=2) |
|
|
|
|
| def _enable_web_ax(ax, timeout=10.0): |
| """Chromium/Electron builds its web-content AX tree only once an AT announces itself.""" |
| from ApplicationServices import AXUIElementSetAttributeValue |
| try: |
| AXUIElementSetAttributeValue(ax._app_ref, "AXEnhancedUserInterface", True) |
| except Exception: |
| pass |
| deadline = time.time() + timeout |
| while time.time() < deadline: |
| if ax.find(role="label", max_results=1, max_depth=16): |
| return True |
| time.sleep(0.25) |
| return False |
|
|
|
|
| def app_ready(ax): |
| """MANDATORY bring-up: build the web AX tree and foreground the app.""" |
| _enable_web_ax(ax) |
| try: |
| from AppKit import NSRunningApplication |
| a = NSRunningApplication.runningApplicationWithProcessIdentifier_(int(ax.get_pid())) |
| if a is not None: |
| a.activateWithOptions_(1 << 1) |
| except Exception: |
| pass |
| time.sleep(0.4) |
| return ax |
|
|
|
|
| def labels(ax): |
| return [l.value for l in ax.find(role="label", max_results=250, max_depth=26) if l.value] |
|
|
|
|
| def field(ax, placeholder): |
| for t in ax.find(role="text_field", max_results=15, max_depth=26): |
| if (t.name or "") == placeholder: |
| return t |
| return None |
|
|
|
|
| def named_button(ax, name): |
| for b in ax.find(role="button", max_results=40, max_depth=26): |
| if (b.name or "").strip() == name.strip(): |
| return b |
| return None |
|
|
|
|
| def text_areas(ax): |
| return ax.find(role="text_area", max_results=8, max_depth=26) |
|
|
|
|
| def press_labelled_group(ax, text): |
| for g in ax.find(role="group", max_results=600, max_depth=26): |
| if "AXPress" not in (g.actions or []): |
| continue |
| labs = ax.find(role="label", root_id=g.id, max_results=3, max_depth=2) |
| if any((l.value or "").strip() == text for l in labs): |
| return ax.action(g.id, "AXPress") |
| return False |
|
|
|
|
| def webarea(ax): |
| w = ax.find(role="webarea", max_results=1, max_depth=6) |
| return w[0] if w else None |
|
|
|
|
| def webarea_buttons(ax): |
| """(x, y, element) for every button inside the web content, DOM order.""" |
| wa = webarea(ax) |
| if wa is None: |
| return [] |
| out = [] |
| for b in ax.find(role="button", root_id=wa.id, max_results=30, max_depth=26): |
| p = ax.get(b.id, ["AXPosition"]).get("AXPosition", "") or "" |
| try: |
| x = float(p.split("x:")[1].split(" ")[0]) |
| y = float(p.split("y:")[1].split(" ")[0]) |
| except Exception: |
| x = y = -1.0 |
| out.append((x, y, b)) |
| return out |
|
|
|
|
| def snippet_header_buttons(ax): |
| """The snippet-header tool buttons, left→right. For a Plain Text snippet there are |
| exactly 4: [screenshot, code-preview, add-description, new-fragment].""" |
| wa = webarea(ax) |
| if wa is None: |
| return [] |
| name_field = field(ax, "Type snippet name") |
| if name_field is None: |
| return [] |
| p = ax.get(name_field.id, ["AXPosition"]).get("AXPosition", "") or "" |
| try: |
| ny = float(p.split("y:")[1].split(" ")[0]) |
| nx = float(p.split("x:")[1].split(" ")[0]) |
| except Exception: |
| return [] |
| out = [(x, y, b) for (x, y, b) in webarea_buttons(ax) |
| if abs(y - ny) < 40 and x > nx] |
| return [b for (_x, _y, b) in sorted(out, key=lambda t: t[0])] |
|
|
|
|
| def add_snippet_button(ax): |
| """The '+' at the top of the snippet-list column: the button that sits on the same |
| row as the Search box and to its right.""" |
| s = field(ax, "Search...") |
| if s is None: |
| return None |
| p = ax.get(s.id, ["AXPosition"]).get("AXPosition", "") or "" |
| try: |
| sy = float(p.split("y:")[1].split(" ")[0]) |
| sx = float(p.split("x:")[1].split(" ")[0]) |
| except Exception: |
| return None |
| cands = [(x, y, b) for (x, y, b) in webarea_buttons(ax) |
| if abs(y - sy) < 25 and x > sx] |
| cands.sort(key=lambda t: t[0]) |
| return cands[0][2] if cands else None |
|
|
|
|
| def menu_el(ax, path): |
| items = ax.find(role="menu_bar_item", name=path[0], max_results=3, max_depth=3) |
| if not items: |
| return None |
| cur = items[0] |
| for lbl in path[1:]: |
| kids = ax.find(role="menu_item", name=lbl, root_id=cur.id, max_results=3, max_depth=3) |
| if not kids: |
| return None |
| cur = kids[0] |
| return cur |
|
|
|
|
| def rb_enter_menu(ax, path, settle=1.2): |
| """NAVIGATION: fire a menu item, crossing into whatever surface it opens.""" |
| el = menu_el(ax, path) |
| if el is None: |
| return False |
| ok = ax.action(el.id, "AXPress") |
| time.sleep(settle) |
| return ok |
|
|
|
|
| def rb_enter_close_surface(ax, settle=1.3): |
| """NAVIGATION: leave Preferences / Developer Tools / Presentation.""" |
| wa = webarea(ax) |
| if wa is None: |
| return False |
| btns = ax.find(role="button", root_id=wa.id, max_results=5, max_depth=24) |
| if not btns: |
| return False |
| ok = ax.action(btns[0].id, "AXPress") |
| time.sleep(settle) |
| return ok |
|
|
|
|
| def rb_enter_devtool(ax, tool_name, settle=1.3): |
| """NAVIGATION: open Developer Tools (if needed) and select a tool in its left rail.""" |
| if "Developer Tools" not in labels(ax): |
| rb_enter_menu(ax, ["massCode", "Developer Tools…"], settle=1.6) |
| ok = press_labelled_group(ax, tool_name) |
| time.sleep(settle) |
| return ok |
|
|
|
|
| def rb_enter_new_snippet(ax): |
| """NAVIGATION: create + select a fresh snippet (the editor surface).""" |
| return rb_enter_menu(ax, ["File", "New Snippet"], settle=1.6) |
|
|
|
|
| def go_home(ax): |
| for _ in range(3): |
| ls = labels(ax) |
| if "Preferences" in ls or "Developer Tools" in ls or "1 / 0" in ls: |
| if rb_enter_close_surface(ax): |
| continue |
| break |
| if "Inbox" not in labels(ax): |
| press_labelled_group(ax, "LIBRARY") |
| time.sleep(0.8) |
| return ax |
|
|
|
|
| |
| |
|
|
| def rb_enter_sidebar_row(ax, row_name, settle=1.0): |
| """NAVIGATION: select a sidebar collection (Inbox / Trash / All Snippets / …). |
| Located by the row's visible LABEL, never by index.""" |
| ok = press_labelled_group(ax, row_name) |
| time.sleep(settle) |
| return ok |
|
|
|
|
| def rb_enter_preferences(ax): |
| """NAVIGATION: open the Preferences/Settings surface from the app menu. |
| Tries the macOS 13+ 'Settings…' wording first, then the classic 'Preferences…'.""" |
| for label in ("Settings…", "Preferences…", "Settings...", "Preferences..."): |
| if rb_enter_menu(ax, ["massCode", label], settle=1.6): |
| return True |
| return False |
|
|
|
|
| def press_named(ax, name, settle=0.8): |
| """AXPress a button located by its accessible NAME (devtools buttons have names).""" |
| b = named_button(ax, name) |
| if b is None: |
| return False |
| ok = ax.action(b.id, "AXPress") |
| time.sleep(settle) |
| return ok |
|
|
|
|
| def button_names(ax): |
| return [(b.name or "") for b in ax.find(role="button", max_results=40, max_depth=26)] |
|
|
|
|
| def out_value(ax, index=1, timeout=2.0): |
| """Poll the devtools output text_area until it is non-empty (reactive tools lag).""" |
| deadline = time.time() + timeout |
| val = None |
| while time.time() < deadline: |
| tas = text_areas(ax) |
| if len(tas) > index: |
| val = tas[index].value |
| if (val or "").strip(): |
| return val |
| time.sleep(0.2) |
| return val |
|
|
|
|
| def set_case_input(ax, text): |
| tas = text_areas(ax) |
| assert len(tas) >= 2, f"expected an input+output text_area pair, found {len(tas)}" |
| ax.set_value(tas[0].id, text) |
| time.sleep(0.4) |
| return tas |
|
|
|
|
| |
|
|
| class TestSnippetCreationButtons: |
| """The '+' button in the snippet-list column must MATERIALISE a snippet editor.""" |
|
|
| @pytest.mark.rb(depth=1, jump_kind="reach", |
| expect="snippet name box + language dropdown + Line 1, Column 1 appear") |
| def test_add_snippet_button_creates_snippet(self, ax): |
| app_ready(ax) |
| go_home(ax) |
| |
| |
| assert rb_enter_sidebar_row(ax, "Trash"), "sidebar 'Trash' row is not pressable" |
| before = kit.rb_showing(ax) |
| rb_enter_sidebar_row(ax, "Inbox") |
| b = add_snippet_button(ax) |
| assert b is not None, "no '+' add-snippet button beside the Search box" |
| assert "AXPress" in (b.actions or []), "add-snippet button exposes no AXPress action" |
| assert ax.action(b.id, "AXPress"), "AXPress on the add-snippet button failed" |
| time.sleep(1.6) |
| after = kit.rb_showing(ax) |
| screenshot_assert( |
| "buttons_new_snippet", |
| "massCode home shell after pressing the '+' button at the top of the middle " |
| "snippet-list column (right of the 'Search...' box): the right editor pane no " |
| "longer says 'No Snippet Selected' but shows a new snippet — a 'Type snippet " |
| "name' box filled with 'Untitled snippet', an 'Add Tag' row, an empty code " |
| "editor, a 'Plain Text' language dropdown and the 'Line 1, Column 1' status. " |
| "A new 'Untitled snippet' row is listed in the snippet-list column.", |
| ) |
| assert kit.rb_reach(before, after, |
| target="Type snippet name", source="No Snippet Selected"), ( |
| "'+' did not open a snippet editor (name box never appeared / " |
| "'No Snippet Selected' never went away)") |
|
|
|
|
| class TestSnippetHeaderToolButtons: |
| """The 4 icon-only tool buttons to the right of the snippet name box.""" |
|
|
| @pytest.mark.rb(depth=2, jump_kind="reach", |
| expect="screenshot palette with Background / Dark Mode and PNG / SVG buttons") |
| def test_screenshot_preview_button_opens_palette(self, ax): |
| app_ready(ax) |
| go_home(ax) |
| assert rb_enter_new_snippet(ax), "File ▸ New Snippet did not fire" |
| hb = snippet_header_buttons(ax) |
| assert len(hb) >= 4, f"expected >=4 snippet-header tool buttons, found {len(hb)}" |
| before = kit.rb_showing(ax) |
| assert ax.action(hb[0].id, "AXPress"), "AXPress on the screenshot button failed" |
| time.sleep(1.5) |
| after = kit.rb_showing(ax) |
| screenshot_assert( |
| "buttons_screenshot_palette", |
| "massCode snippet screenshot palette: the editor pane's tag row, 'Plain Text' " |
| "language dropdown and 'Line N, Column M' status are replaced by a screenshot " |
| "export panel showing a 'Background' colour control, a 'Dark Mode' switch and " |
| "two export buttons labelled 'PNG' and 'SVG' (not pressed — they write files). " |
| "The left sidebar and the snippet list are still visible.", |
| ) |
| assert kit.rb_reach(before, after, target="Dark Mode", source="Add Tag"), ( |
| "the screenshot tool button did not swap the editor footer for the " |
| "screenshot palette") |
| names = button_names(ax) |
| assert any("PNG" in n for n in names), f"no PNG export button in {names}" |
| assert any("SVG" in n for n in names), f"no SVG export button in {names}" |
| |
| hb2 = snippet_header_buttons(ax) |
| ax.action((hb2[0] if hb2 else hb[0]).id, "AXPress") |
| time.sleep(0.8) |
|
|
| @pytest.mark.rb(depth=2, jump_kind="reach", |
| expect="'Add description' text area appears") |
| def test_add_description_button_reveals_textarea(self, ax): |
| app_ready(ax) |
| go_home(ax) |
| assert rb_enter_new_snippet(ax), "File ▸ New Snippet did not fire" |
| hb = snippet_header_buttons(ax) |
| assert len(hb) >= 3, f"expected >=3 snippet-header tool buttons, found {len(hb)}" |
| before = kit.rb_showing(ax) |
| assert ax.action(hb[2].id, "AXPress"), "AXPress on the add-description button failed" |
| time.sleep(1.4) |
| after = kit.rb_showing(ax) |
| assert kit.rb_reach(before, after, target="Add description"), ( |
| "the add-description button did not reveal the description area") |
| assert len(text_areas(ax)) >= 2, ( |
| "description area did not add a second text_area next to the code editor") |
|
|
| @pytest.mark.rb(depth=2, jump_kind="reach", |
| expect="Fragment 1 / Fragment 2 tab bar appears") |
| def test_new_fragment_button_creates_fragment_tabs(self, ax): |
| app_ready(ax) |
| go_home(ax) |
| assert rb_enter_new_snippet(ax), "File ▸ New Snippet did not fire" |
| hb = snippet_header_buttons(ax) |
| assert len(hb) >= 4, f"expected >=4 snippet-header tool buttons, found {len(hb)}" |
| before = kit.rb_showing(ax) |
| assert ax.action(hb[3].id, "AXPress"), "AXPress on the new-fragment button failed" |
| time.sleep(1.5) |
| after = kit.rb_showing(ax) |
| assert kit.rb_reach(before, after, target="Fragment 2"), ( |
| "the new-fragment button did not add a second fragment tab") |
| ls = labels(ax) |
| assert "Fragment 1" in ls, f"no 'Fragment 1' tab beside 'Fragment 2': {ls[:40]}" |
|
|
|
|
| class TestSurfaceCloseButton: |
| """The single webarea button on a full-window surface must return to the home shell.""" |
|
|
| @pytest.mark.rb(depth=2, jump_kind="reach", expect="home shell restored") |
| def test_preferences_close_button_returns_home(self, ax): |
| app_ready(ax) |
| go_home(ax) |
| assert rb_enter_preferences(ax), "could not open the Preferences/Settings surface" |
| before = kit.rb_showing(ax) |
| assert any("Preferences" in (l or "") for l in labels(ax)), ( |
| "Preferences surface did not render") |
| assert rb_enter_close_surface(ax), "no close button inside the Preferences webarea" |
| after = kit.rb_showing(ax) |
| assert kit.rb_reach(before, after, target="All Snippets", source="Preferences"), ( |
| "the Preferences close button did not bring back the home shell") |
|
|
|
|
| |
|
|
| class TestDevtoolsCaseConverterButtons: |
| """Developer Tools ▸ Case Converter — each named button must produce its exact string.""" |
|
|
| @pytest.mark.rb(depth=1, jump_kind="value", expect="helloWorldExample") |
| def test_case_converter_camel_button(self, ax): |
| app_ready(ax) |
| assert rb_enter_devtool(ax, "Case Converter"), "could not open Case Converter" |
| tas = text_areas(ax) |
| assert len(tas) >= 2, f"Case Converter needs 2 text areas, found {len(tas)}" |
| assert ax.set_value(tas[0].id, "hello world example"), "could not fill Input String" |
| time.sleep(0.8) |
| btn = named_button(ax, "camelCase") |
| assert btn is not None, f"no 'camelCase' button; saw {button_names(ax)}" |
| assert "AXPress" in (btn.actions or []), "camelCase button exposes no AXPress action" |
| assert ax.action(btn.id, "AXPress"), "AXPress on camelCase failed" |
| time.sleep(0.8) |
| out = out_value(ax, 1) |
| screenshot_assert( |
| "buttons_case_converter", |
| "massCode Developer Tools page, Case Converter pane: left rail lists Text Tools " |
| "(Case Converter, Slug Generator, Sort Lines, URL Parser), Cryptography / " |
| "Security and Encoders / Decoders. The pane shows an 'Input String' box holding " |
| "'hello world example', a row of case buttons (lower case, UPPER CASE, camelCase, " |
| "PascalCase, snake_case, kebab-case, Start Case) plus Clear/Copy, and an 'Output " |
| "String' box now reading 'helloWorldExample' after camelCase was pressed.", |
| ) |
| assert kit.rb_value(out, "helloWorldExample"), f"camelCase produced {out!r}" |
|
|
| @pytest.mark.rb(depth=1, jump_kind="value", expect="kebab/snake/Pascal conversions") |
| def test_case_converter_kebab_snake_pascal_buttons(self, ax): |
| app_ready(ax) |
| assert rb_enter_devtool(ax, "Case Converter"), "could not open Case Converter" |
| expected = [("kebab-case", "hello-world-example"), |
| ("snake_case", "hello_world_example"), |
| ("PascalCase", "HelloWorldExample")] |
| for label, want in expected: |
| set_case_input(ax, "hello world example") |
| btn = named_button(ax, label) |
| assert btn is not None, f"no {label!r} button; saw {button_names(ax)}" |
| assert ax.action(btn.id, "AXPress"), f"AXPress on {label} failed" |
| time.sleep(0.7) |
| got = out_value(ax, 1) |
| assert kit.rb_value(got, want), f"{label} produced {got!r}, expected {want!r}" |
|
|
|
|
| class TestDevtoolsSortAndGenerateButtons: |
| """Developer Tools buttons whose consequence is a computed value.""" |
|
|
| @pytest.mark.rb(depth=1, jump_kind="value", expect="sorted then reversed lines") |
| def test_sort_lines_buttons(self, ax): |
| app_ready(ax) |
| assert rb_enter_devtool(ax, "Sort Lines"), "could not open Sort Lines" |
| tas = text_areas(ax) |
| assert len(tas) >= 2, f"Sort Lines needs 2 text areas, found {len(tas)}" |
| assert ax.set_value(tas[0].id, "banana\napple\ncherry"), "could not fill the input" |
| time.sleep(0.8) |
| assert press_named(ax, "Sort", settle=0.9), ( |
| f"no pressable 'Sort' button; saw {button_names(ax)}") |
| sorted_out = out_value(ax, 1) |
| assert kit.rb_value(sorted_out, "apple\nbanana\ncherry"), ( |
| f"Sort produced {sorted_out!r}") |
| assert press_named(ax, "Revers", settle=0.9), ( |
| f"no pressable 'Revers' button; saw {button_names(ax)}") |
| reversed_out = out_value(ax, 1) |
| assert kit.rb_value(reversed_out, "cherry\napple\nbanana"), ( |
| f"Revers produced {reversed_out!r}") |
|
|
| @pytest.mark.rb(depth=1, jump_kind="value", expect="24-character generated password") |
| def test_password_generate_button_honours_length(self, ax): |
| app_ready(ax) |
| assert rb_enter_devtool(ax, "Password Generator"), ( |
| "could not open Password Generator") |
| fields = ax.find(role="text_field", max_results=10, max_depth=26) |
| assert len(fields) >= 2, ( |
| f"Password Generator needs a Length + Result field, found {len(fields)}") |
| assert ax.set_value(fields[0].id, "24"), "could not set the Length field" |
| time.sleep(0.6) |
| assert press_named(ax, "Generate", settle=1.0), ( |
| f"no pressable 'Generate' button; saw {button_names(ax)}") |
| fields = ax.find(role="text_field", max_results=10, max_depth=26) |
| assert len(fields) >= 2, "Result field vanished after Generate" |
| result = (fields[1].value or "") |
| assert not re.search(r"\s", result), f"password contains whitespace: {result!r}" |
| assert kit.rb_value(len(result), 24), ( |
| f"Generate honoured neither Length=24 nor produced a password: {result!r}") |
|
|
|
|
| |
|
|
| class TestButtonToggles: |
| """Buttons whose consequence is a reversible state flip.""" |
|
|
| @pytest.mark.rb(depth=1, jump_kind="transition", |
| expect="Snippets Showcase preview pane appears/disappears") |
| def test_code_preview_button_toggles_preview(self, ax): |
| app_ready(ax) |
| go_home(ax) |
| assert rb_enter_new_snippet(ax), "File ▸ New Snippet did not fire" |
| hb = snippet_header_buttons(ax) |
| assert len(hb) >= 2, f"expected >=2 snippet-header tool buttons, found {len(hb)}" |
| before = "Snippets Showcase" in labels(ax) |
| assert ax.action(hb[1].id, "AXPress"), "AXPress on the code-preview button failed" |
| time.sleep(1.5) |
| after = "Snippets Showcase" in labels(ax) |
| assert kit.rb_flip(before, after, expect="code-preview pane toggles"), ( |
| f"code-preview button did not toggle the preview pane (stayed {before})") |
| hb2 = snippet_header_buttons(ax) |
| toggle_back = hb2[1] if len(hb2) >= 2 else hb[1] |
| assert ax.action(toggle_back.id, "AXPress"), "second AXPress on code-preview failed" |
| time.sleep(1.5) |
| restored = "Snippets Showcase" in labels(ax) |
| assert kit.rb_flip(after, restored, expect="code-preview pane toggles back"), ( |
| "code-preview button is not a toggle — the second press changed nothing") |
| assert restored == before, ( |
| f"code-preview did not return to its original state ({before} -> {restored})") |
|
|
| @pytest.mark.rb(depth=1, jump_kind="transition", expect="input and result cleared") |
| def test_devtools_clear_button_empties_fields(self, ax): |
| app_ready(ax) |
| assert rb_enter_devtool(ax, "Base64 Encoder / Decoder"), ( |
| "could not open Base64 Encoder / Decoder") |
| tas = text_areas(ax) |
| assert len(tas) >= 2, f"Base64 tool needs 2 text areas, found {len(tas)}" |
| assert ax.set_value(tas[0].id, "Hello massCode"), "could not fill the input" |
| time.sleep(1.0) |
| encoded = out_value(ax, 1) |
| tas = text_areas(ax) |
| before = ((tas[0].value or ""), (encoded or "")) |
| assert before[0].strip(), "the input text area stayed empty after set_value" |
| assert before[1].strip(), "the Base64 result never computed — nothing to clear" |
| assert press_named(ax, "Clear", settle=0.8), ( |
| f"no pressable 'Clear' button; saw {button_names(ax)}") |
| tas = text_areas(ax) |
| assert len(tas) >= 2, "text areas vanished after Clear" |
| after = ((tas[0].value or ""), (tas[1].value or "")) |
| assert kit.rb_flip(before, after, expect="Clear empties input and result"), ( |
| f"Clear changed nothing: {before!r}") |
| assert not after[0].strip(), f"input not cleared: {after[0]!r}" |
| assert not after[1].strip(), f"result not cleared: {after[1]!r}" |
|
|
