| """AX STRUCTURE tests for CodeEdit (app.codeedit.CodeEdit). |
| |
| Generated ONLY from verifier/recon.md (## APP / ## PRIMITIVES / ## AX_TREE / ## STRUCTURE). |
| |
| Lane contract |
| ------------- |
| * 4 pure-existence GATE tests (jump_kind="none", depth=0): the fresh-launch surfaces that |
| must exist — the welcome window + its 3 named action buttons, the recent-projects |
| AXOutline + role diversity, the AXMenuBar with its 10 named menus, and the welcome |
| window's interactive-widget inventory + AX tree depth. |
| * 11 shape-delta REACH tests (jump_kind="reach"), one per row of recon's |
| `Shape-delta pairs` table, each proved with kit.rb_showing() before/after ONE navigation |
| chain and kit.rb_reach() as the assertion, plus the SPECIFIC named widgets recon recorded. |
| * 4 of the reach tests are depth>=2 (workspace -> editor text area, workspace -> inspector |
| pane, workspace -> navigator hide/restore, Settings -> "Text Editing" pane detail). |
| |
| Environment constraints honoured (recon "ENVIRONMENT CONSTRAINTS") |
| ------------------------------------------------------------------ |
| * no plain keystrokes / Escape anywhere — sheets and panels are dismissed with their own |
| "Cancel" button (dismiss_panel_or_sheet), |
| * CG clicks (never AXPress) for SwiftUI list rows, Settings sidebar panes and workspace |
| toolbar buttons, |
| * none of the forbidden controls is ever pressed (Quit, Close Workspace, Check for |
| updates.../Check Now, Install, Contributors, Help items, Locations path buttons, |
| Discard All Changes...). |
| """ |
|
|
| |
| import json |
| import os |
| import shutil |
| import subprocess |
| import time |
|
|
| import pytest |
|
|
| import rb_testgen_kit as kit |
| import verifier_helpers as helpers |
|
|
| RESULTS_DIR = os.environ.get("RESULTS_DIR", os.path.join(os.path.dirname(__file__), "results")) |
| FIXTURES_DIR = os.environ.get("FIXTURES_DIR") or os.path.join(os.path.dirname(__file__), "fixtures") |
|
|
|
|
| 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 |
| af = os.path.join(ss_dir, "assertions.json") |
| data = {} |
| if os.path.exists(af): |
| try: |
| with open(af) as f: |
| data = json.load(f) |
| except Exception: |
| data = {} |
| data[f"{test_name}.png"] = description |
| with open(af, "w") as f: |
| json.dump(data, f, indent=2) |
|
|
|
|
| def win_id(ax, w): |
| return ax.get(w.id, ["AXIdentifier"]).get("AXIdentifier") |
|
|
|
|
| def all_windows(ax): |
| return ax.find(role="window", max_depth=1, max_results=20) |
|
|
|
|
| def find_window(ax, ident=None, title=None, timeout=8.0): |
| end = time.time() + timeout |
| while True: |
| for w in all_windows(ax): |
| if ident is not None and win_id(ax, w) == ident: |
| return w |
| if title is not None and (w.name or "") == title: |
| return w |
| if time.time() >= end: |
| return None |
| time.sleep(0.25) |
|
|
|
|
| def close_window(ax, w): |
| if w is None: |
| return False |
| for b in ax.find(role="button", root_id=w.id, max_results=200, max_depth=3): |
| if ax.get(b.id, ["AXSubrole"]).get("AXSubrole") == "AXCloseButton": |
| ax.action(b.id, "AXPress") |
| time.sleep(0.8) |
| return True |
| return False |
|
|
|
|
| def values_in(ax, root_id, max_results=400, max_depth=18): |
| """Every non-empty AXValue string under root (labels, fields, popups).""" |
| out = [] |
| for e in ax.find(root_id=root_id, max_results=max_results, max_depth=max_depth): |
| v = ax.get(e.id, ["AXValue"]).get("AXValue") |
| if isinstance(v, str) and v.strip(): |
| out.append(v) |
| return out |
|
|
|
|
| def names_in(ax, root_id, role=None, max_results=400, max_depth=18): |
| return [e.name for e in ax.find(role=role, root_id=root_id, |
| max_results=max_results, max_depth=max_depth) if e.name] |
|
|
|
|
| def buttons_named(ax, root_id, name): |
| return [b for b in ax.find(role="button", root_id=root_id, max_results=300, max_depth=16) |
| if (b.name or "") == name] |
|
|
|
|
| def menu_item(ax, *path): |
| mbi = [m for m in ax.find(role="menu_bar_item", max_results=20, max_depth=3) |
| if (m.name or "") == path[0]] |
| if not mbi: |
| return None |
| cur = mbi[0].id |
| for label in path[1:]: |
| items = ax.find(role="menu_item", root_id=cur, max_results=300, max_depth=2) |
| hit = [i for i in items if (i.name or "") == label] |
| if not hit: |
| return None |
| cur = hit[0].id |
| return cur |
|
|
|
|
| def menu_items(ax, *path): |
| """Item NAMES directly under a menu-bar item (or a submenu item).""" |
| root = menu_item(ax, *path) if len(path) > 1 else None |
| if root is None: |
| mbi = [m for m in ax.find(role="menu_bar_item", max_results=20, max_depth=3) |
| if (m.name or "") == path[0]] |
| if not mbi: |
| return [] |
| menus = ax.find(role="menu", root_id=mbi[0].id, max_results=2, max_depth=1) |
| if not menus: |
| return [] |
| root = menus[0].id |
| else: |
| menus = ax.find(role="menu", root_id=root, max_results=2, max_depth=1) |
| if not menus: |
| return [] |
| root = menus[0].id |
| return [i.name for i in ax.find(role="menu_item", root_id=root, max_results=100, max_depth=1) |
| if (i.name or "")] |
|
|
|
|
| def rb_enter_menu_item(ax, *path, wait=1.6): |
| mid = menu_item(ax, *path) |
| if mid is None: |
| return False |
| ax.action(mid, "AXPress") |
| time.sleep(wait) |
| return True |
|
|
|
|
| def rb_enter_welcome(ax): |
| w = find_window(ax, ident="welcome", timeout=3) |
| if w is None: |
| rb_enter_menu_item(ax, "Window", "Welcome to CodeEdit") |
| w = find_window(ax, ident="welcome", timeout=6) |
| return w |
|
|
|
|
| def rb_enter_settings_window(ax): |
| w = find_window(ax, ident="settings", timeout=1) |
| if w is None: |
| rb_enter_menu_item(ax, "CodeEdit", "Settings...", wait=2.0) |
| w = find_window(ax, ident="settings", timeout=8) |
| return w |
|
|
|
|
| def rb_reach_settings_pane(ax, pane): |
| """Select a Settings sidebar pane. MUST be a CG click (AXPress does NOT select).""" |
| w = rb_enter_settings_window(ax) |
| if w is None: |
| return None |
| bs = buttons_named(ax, w.id, pane) |
| if not bs: |
| return None |
| ax.click_element_cg(bs[-1].id) |
| time.sleep(1.0) |
| return find_window(ax, ident="settings", timeout=3) |
|
|
|
|
| def rb_enter_about_window(ax): |
| rb_enter_menu_item(ax, "CodeEdit", "About CodeEdit", wait=2.0) |
| return find_window(ax, ident="about", timeout=6) |
|
|
|
|
| def rb_enter_extensions_window(ax): |
| rb_enter_menu_item(ax, "Extensions", "Open Extensions Window", wait=2.0) |
| return find_window(ax, ident="extensions", timeout=6) |
|
|
|
|
| def rb_enter_clone_sheet(ax): |
| w = rb_enter_welcome(ax) |
| bs = buttons_named(ax, w.id, "Clone Git Repository...") |
| if not bs: |
| return None |
| ax.action(bs[0].id, "AXPress") |
| end = time.time() + 6 |
| while time.time() < end: |
| s = ax.find(role="sheet", max_results=3, max_depth=6) |
| if s: |
| return s[0] |
| time.sleep(0.25) |
| return None |
|
|
|
|
| def rb_enter_save_panel(ax): |
| w = rb_enter_welcome(ax) |
| bs = buttons_named(ax, w.id, "Create New File...") |
| if bs: |
| ax.action(bs[0].id, "AXPress") |
| return find_window(ax, title="Save", timeout=8) |
|
|
|
|
| def rb_enter_open_panel(ax): |
| w = rb_enter_welcome(ax) |
| bs = buttons_named(ax, w.id, "Open File or Folder...") |
| if bs: |
| ax.action(bs[0].id, "AXPress") |
| return find_window(ax, title="Open Workspace or File", timeout=8) |
|
|
|
|
| def dismiss_panel_or_sheet(ax): |
| """Escape does not work here — press the panel/sheet's own Cancel button.""" |
| for b in ax.find(role="button", max_results=120, max_depth=10): |
| if (b.name or "") == "Cancel": |
| ax.action(b.id, "AXPress") |
| time.sleep(1.0) |
| return True |
| return False |
|
|
|
|
| def rb_enter_workspace(ax, folder_name="sample_project", timeout=20.0): |
| """Open the fixture folder as a workspace the way Finder does: hand the folder to the |
| RUNNING app's own bundle (discovered from its pid at runtime — portable).""" |
| from AppKit import NSWorkspace, NSRunningApplication, NSWorkspaceOpenConfiguration |
| from Foundation import NSURL |
| src = os.path.join(FIXTURES_DIR, folder_name) |
| base = os.path.join("/tmp", "rb_codeedit_ws") |
| dst = os.path.join(base, folder_name) |
| if os.path.isdir(base): |
| shutil.rmtree(base, ignore_errors=True) |
| os.makedirs(base, exist_ok=True) |
| shutil.copytree(src, dst) |
| ra = NSRunningApplication.runningApplicationWithProcessIdentifier_(int(ax._pid)) |
| cfg = NSWorkspaceOpenConfiguration.configuration() |
| cfg.setActivates_(True) |
| NSWorkspace.sharedWorkspace().openURLs_withApplicationAtURL_configuration_completionHandler_( |
| [NSURL.fileURLWithPath_(dst)], ra.bundleURL(), cfg, None) |
| return find_window(ax, ident="workspace", timeout=timeout) |
|
|
|
|
| def project_navigator(ax, ws): |
| for o in ax.find(role="outline", root_id=ws.id, max_results=10, max_depth=14): |
| if (o.name or "") == "Project Navigator": |
| return o |
| return None |
|
|
|
|
| def navigator_rows(ax, ws): |
| nav = project_navigator(ax, ws) |
| if nav is None: |
| return [] |
| return [ax.get(t.id, ["AXValue"]).get("AXValue") |
| for t in ax.find(role="text_field", root_id=nav.id, max_results=60, max_depth=8)] |
|
|
|
|
| def rb_reach_editor(ax, ws, filename): |
| """Click a file row in the Project Navigator; returns the editor AXTextArea (or None).""" |
| nav = project_navigator(ax, ws) |
| if nav is None: |
| return None |
| rows = ax.find(role="text_field", root_id=nav.id, max_results=60, max_depth=8) |
| tgt = [t for t in rows if ax.get(t.id, ["AXValue"]).get("AXValue") == filename] |
| if not tgt: |
| return None |
| ax.click_element_cg(tgt[0].id) |
| end = time.time() + 8 |
| while time.time() < end: |
| ta = ax.find(role="text_area", root_id=ws.id, max_results=5, max_depth=18) |
| if ta: |
| return ta[0] |
| time.sleep(0.3) |
| return None |
|
|
|
|
| def rb_enter_command_palette(ax, ws): |
| """Command Palette / Open Quickly only exist while a WORKSPACE window is open.""" |
| ax.action(ws.id, "AXRaise") |
| time.sleep(0.5) |
| rb_enter_menu_item(ax, "View", "Show Command Palette", wait=1.6) |
| return _overlay_window(ax) |
|
|
|
|
| def rb_enter_open_quickly(ax, ws): |
| ax.action(ws.id, "AXRaise") |
| time.sleep(0.5) |
| rb_enter_menu_item(ax, "File", "Open Quickly", wait=1.6) |
| return _overlay_window(ax) |
|
|
|
|
| def _overlay_window(ax): |
| """The palette/quick-open overlay is a borderless AXWindow: no title, no AXIdentifier.""" |
| for w in all_windows(ax): |
| if win_id(ax, w) is None and not (w.name or ""): |
| return w |
| return None |
|
|
|
|
| def overlay_rows(ax, pal): |
| return [v for v in (ax.get(t.id, ["AXValue"]).get("AXValue") |
| for t in ax.find(role="label", root_id=pal.id, |
| max_results=60, max_depth=14)) if v] |
|
|
|
|
| def overlay_type(ax, pal, text): |
| tf = ax.find(role="text_field", root_id=pal.id, max_results=5, max_depth=8) |
| if not tf: |
| return False |
| ax.set_value(tf[0].id, text) |
| time.sleep(1.3) |
| return True |
|
|
|
|
| def switch_for_label(ax, root_id, label): |
| """The AXCheckBox(AXSwitch) that follows the AXStaticText whose AXValue == label.""" |
| seq = ax.find(root_id=root_id, max_results=400, max_depth=18) |
| idx = None |
| for i, e in enumerate(seq): |
| if e.role == "label" and ax.get(e.id, ["AXValue"]).get("AXValue") == label: |
| idx = i |
| break |
| if idx is None: |
| return None |
| for e in seq[idx + 1:idx + 4]: |
| if e.role == "checkbox": |
| return e |
| return None |
|
|
|
|
| def popup_for_label(ax, root_id, label): |
| seq = ax.find(root_id=root_id, max_results=400, max_depth=18) |
| idx = None |
| for i, e in enumerate(seq): |
| if e.role == "label" and ax.get(e.id, ["AXValue"]).get("AXValue") == label: |
| idx = i |
| break |
| if idx is None: |
| return None |
| for e in seq[idx + 1:idx + 4]: |
| if e.role == "popup": |
| return e |
| return None |
|
|
|
|
| def popup_options(ax, popup): |
| ax.action(popup.id, "AXPress") |
| time.sleep(0.8) |
| menus = ax.find(role="menu", root_id=popup.id, max_results=3, max_depth=2) |
| out = [] |
| if menus: |
| for i in ax.find(role="menu_item", root_id=menus[0].id, max_results=40, max_depth=2): |
| out.append(i.name or ax.get(i.id, ["AXValue"]).get("AXValue")) |
| ax.action(menus[0].id, "AXCancel") |
| time.sleep(0.4) |
| return [o for o in out if o] |
|
|
|
|
| def popup_pick(ax, popup, option): |
| ax.action(popup.id, "AXPress") |
| time.sleep(0.8) |
| menus = ax.find(role="menu", root_id=popup.id, max_results=3, max_depth=2) |
| if not menus: |
| return False |
| for i in ax.find(role="menu_item", root_id=menus[0].id, max_results=40, max_depth=2): |
| if (i.name or ax.get(i.id, ["AXValue"]).get("AXValue")) == option: |
| ax.action(i.id, "AXPick") |
| time.sleep(1.0) |
| return True |
| ax.action(menus[0].id, "AXCancel") |
| return False |
|
|
|
|
| |
| |
| |
| |
|
|
| WELCOME_TITLE = "Welcome To CodeEdit" |
| WELCOME_BUTTONS = ("Create New File...", "Clone Git Repository...", "Open File or Folder...") |
| MENU_BAR_ITEMS = ["CodeEdit", "File", "Edit", "View", "Find", "Navigate", |
| "Source Control", "Extensions", "Window", "Help"] |
| SETTINGS_PANES = ["General", "Accounts", "Navigation", "Themes", "Text Editing", |
| "Terminal", "Search", "Source Control", "Locations"] |
| WELCOME_ROLES = ("button", "label", "image", "scroll_area", "outline", "column", "group") |
| NAV_ROWS = ("sample_project", "src", "README.md", "hello.py", "notes.txt") |
| |
| |
| |
| DEEP = 16 |
|
|
|
|
| def tree_depth(node, d=0): |
| """Max AX nesting depth of an ax.tree() dict (0 == the root node itself).""" |
| kids = (node or {}).get("children") or [] |
| if not kids: |
| return d |
| return max(tree_depth(k, d + 1) for k in kids) |
|
|
|
|
| def node_count(node): |
| return 1 + sum(node_count(k) for k in ((node or {}).get("children") or [])) |
|
|
|
|
| def roles_under(ax, root_id, max_depth=10, max_results=300): |
| return {e.role for e in ax.find(root_id=root_id, max_results=max_results, |
| max_depth=max_depth)} |
|
|
|
|
| def shows(ax, snapshot, role, name, root_id=None, max_depth=DEEP): |
| """True iff a widget with this short ROLE and this visible NAME is present — either as a |
| 'role|name' key in the rb_showing() snapshot, or (depth-proof fallback) by a scoped |
| ax.find that also accepts the label carried in AXValue instead of AXTitle. Locating by |
| role + visible label keeps the check framework-agnostic (no child index, no tree path).""" |
| if f"{role}|{name}" in snapshot: |
| return True |
| for e in ax.find(role=role, root_id=root_id, max_results=400, max_depth=max_depth): |
| if (e.name or "") == name: |
| return True |
| if str(ax.get(e.id, ["AXValue"]).get("AXValue") or "") == name: |
| return True |
| return False |
|
|
|
|
| def window_containing(ax, role, name, max_depth=8): |
| """The AXWindow holding a descendant with this ROLE + visible NAME (semantic locator, |
| used for the About window whose own title is the empty string).""" |
| for w in all_windows(ax): |
| for e in ax.find(role=role, root_id=w.id, max_results=200, max_depth=max_depth): |
| if (e.name or "") == name: |
| return w |
| return None |
|
|
|
|
| def rb_enter_welcome_surface(ax): |
| """The fresh-launch welcome window: AXIdentifier 'welcome' OR title 'Welcome To CodeEdit'.""" |
| w = find_window(ax, ident="welcome", title=WELCOME_TITLE, timeout=3) |
| if w is None: |
| rb_enter_welcome(ax) |
| w = find_window(ax, ident="welcome", title=WELCOME_TITLE, timeout=6) |
| return w |
|
|
|
|
| def rb_enter_settings_surface(ax, pane_title="General"): |
| """CodeEdit > Settings... -> the settings window (id 'settings' OR title == the pane).""" |
| w = find_window(ax, ident="settings", title=pane_title, timeout=0.2) |
| if w is not None: |
| return w |
| rb_enter_menu_item(ax, "CodeEdit", "Settings...", wait=2.0) |
| return find_window(ax, ident="settings", title=pane_title, timeout=8) |
|
|
|
|
| def rb_reach_settings_pane_surface(ax, pane): |
| """Select a Settings sidebar pane with a REAL CG click (AXPress does NOT select a |
| SwiftUI List row). Takes buttons_named(...)[-1] because 'Search' names two buttons.""" |
| w = rb_enter_settings_surface(ax) |
| if w is None: |
| return None |
| bs = buttons_named(ax, w.id, pane) |
| if not bs: |
| return None |
| ax.click_element_cg(bs[-1].id) |
| time.sleep(1.2) |
| return find_window(ax, ident="settings", title=pane, timeout=4) |
|
|
|
|
| def rb_enter_about_surface(ax): |
| """CodeEdit > About CodeEdit -> the about window (title is ''; id 'about' or content).""" |
| rb_enter_menu_item(ax, "CodeEdit", "About CodeEdit", wait=2.0) |
| w = find_window(ax, ident="about", timeout=4) |
| if w is None: |
| w = window_containing(ax, "button", "Acknowledgements") |
| return w |
|
|
|
|
| def rb_enter_extensions_surface(ax): |
| """Extensions > Open Extensions Window -> window id 'extensions' / title 'Extensions'.""" |
| rb_enter_menu_item(ax, "Extensions", "Open Extensions Window", wait=2.0) |
| return find_window(ax, ident="extensions", title="Extensions", timeout=6) |
|
|
|
|
| def rb_enter_workspace_surface(ax, folder_name="sample_project"): |
| """Open FIXTURES_DIR/<folder_name> as a workspace; accept id 'workspace' OR the folder |
| name as the window title.""" |
| ws = rb_enter_workspace(ax, folder_name=folder_name, timeout=3.0) |
| if ws is None: |
| ws = find_window(ax, ident="workspace", title=folder_name, timeout=15) |
| return ws |
|
|
|
|
| def rb_reach_workspace_toolbar(ax, ws, name, wait=1.8): |
| """Toggle a workspace toolbar button by its visible NAME (Navigator Sidebar / Inspector |
| Sidebar). Workspace toolbar buttons need a REAL CG click (recon ENVIRONMENT CONSTRAINT 3). |
| Searched in the AXToolbar first (cheap) and only then window-wide, so a recreation that |
| puts the control elsewhere in the hierarchy still matches.""" |
| ax.action(ws.id, "AXRaise") |
| time.sleep(0.4) |
| bs = [] |
| for tb in ax.find(role="toolbar", root_id=ws.id, max_results=3, max_depth=5): |
| bs = [b for b in ax.find(role="button", root_id=tb.id, max_results=60, max_depth=6) |
| if (b.name or "") == name] |
| if bs: |
| break |
| if not bs: |
| bs = buttons_named(ax, ws.id, name) |
| if not bs: |
| return False |
| ax.click_element_cg(bs[0].id) |
| time.sleep(wait) |
| return True |
|
|
|
|
| |
|
|
| class TestStructureGate: |
| """The <=30% existence gate — no trigger, just the fresh-launch skeleton.""" |
|
|
| @pytest.mark.rb(depth=0, jump_kind="none") |
| def test_gate_welcome_window_and_named_buttons(self, ax): |
| """Exactly ONE welcome AXWindow (AXIdentifier 'welcome', title 'Welcome To CodeEdit') |
| holding the 3 named push buttons plus 'Close', all exposing AXPress.""" |
| cands = [w for w in all_windows(ax) |
| if win_id(ax, w) == "welcome" or "welcome" in (w.name or "").lower()] |
| assert len(cands) == 1, ( |
| "expected exactly 1 welcome AXWindow (AXIdentifier 'welcome' / title " |
| f"'{WELCOME_TITLE}'), got {[(win_id(ax, w), w.name) for w in all_windows(ax)]}") |
| w = cands[0] |
| assert (w.name or "") == WELCOME_TITLE, ( |
| f"welcome window title = {w.name!r}, expected {WELCOME_TITLE!r}") |
|
|
| btn_names = set(names_in(ax, w.id, role="button", max_depth=8)) |
| for label in WELCOME_BUTTONS: |
| assert label in btn_names, ( |
| f"welcome window is missing the push button {label!r} (buttons={sorted(btn_names)})") |
| assert "Close" in btn_names, "welcome window is missing its 'Close' button" |
|
|
| for label in WELCOME_BUTTONS: |
| bs = buttons_named(ax, w.id, label) |
| assert bs, f"button {label!r} vanished between lookups" |
| assert "AXPress" in (bs[0].actions or []), ( |
| f"button {label!r} exposes no AXPress action") |
|
|
| screenshot_assert( |
| "structure_test_welcome_window", |
| "CodeEdit 'Welcome To CodeEdit' window, a centred panel about 740x460: a large " |
| "CodeEdit app icon at the top with the title 'CodeEdit' and 'Version 0.3.1 (42)' " |
| "under it, then three full-width rows with SF-Symbol icons on the left half " |
| "reading 'Create New File...', 'Clone Git Repository...' and " |
| "'Open File or Folder...'; the right column is an empty recent-projects list " |
| "showing 'No Recent Projects'. A small close button sits at the window's top-left.", |
| RESULTS_DIR) |
|
|
| @pytest.mark.rb(depth=0, jump_kind="none") |
| def test_gate_welcome_recent_projects_outline_and_role_diversity(self, ax): |
| """The welcome window contains AXScrollArea > AXOutline 'Sidebar' > AXColumn (the |
| recent-projects list) and exposes at least the 7 recon roles.""" |
| w = rb_enter_welcome_surface(ax) |
| assert w is not None, "no welcome window (AXIdentifier 'welcome' / title 'Welcome To CodeEdit')" |
|
|
| scrolls = ax.find(role="scroll_area", root_id=w.id, max_results=5, max_depth=6) |
| assert scrolls, "welcome window has no AXScrollArea for the recent-projects list" |
| sidebars = [o for o in ax.find(role="outline", root_id=scrolls[0].id, |
| max_results=5, max_depth=4) |
| if (o.name or "") == "Sidebar"] |
| assert sidebars, "no AXOutline named 'Sidebar' inside the welcome AXScrollArea" |
| assert ax.find(role="column", root_id=sidebars[0].id, max_results=5, max_depth=3), \ |
| "the recent-projects AXOutline 'Sidebar' exposes no AXColumn" |
|
|
| roles = roles_under(ax, w.id, max_depth=8) |
| for expected in WELCOME_ROLES: |
| assert expected in roles, ( |
| f"welcome window exposes no {expected!r} role (roles={sorted(roles)})") |
| assert len(roles) >= 7, f"role diversity too low: {sorted(roles)}" |
|
|
| @pytest.mark.rb(depth=0, jump_kind="none") |
| def test_gate_menu_bar_named_menus(self, ax): |
| """The AXMenuBar exposes exactly the 10 named app menus (besides the system 'Apple' |
| item); CodeEdit owns 'Settings...' + 'About CodeEdit' and Extensions owns exactly |
| 'Open Extensions Window'.""" |
| assert ax.find(role="menu_bar", max_results=3, max_depth=2), \ |
| "application exposes no AXMenuBar" |
|
|
| names = [m.name for m in ax.find(role="menu_bar_item", max_results=20, max_depth=3) |
| if (m.name or "")] |
| app_menus = [n for n in names if n != "Apple"] |
| assert app_menus == MENU_BAR_ITEMS, ( |
| f"menu-bar items = {app_menus!r}, expected {MENU_BAR_ITEMS!r}") |
|
|
| code_edit_items = menu_items(ax, "CodeEdit") |
| assert "Settings..." in code_edit_items, f"CodeEdit menu = {code_edit_items!r}" |
| assert "About CodeEdit" in code_edit_items, f"CodeEdit menu = {code_edit_items!r}" |
| ext_items = menu_items(ax, "Extensions") |
| assert ext_items == ["Open Extensions Window"], f"Extensions menu = {ext_items!r}" |
|
|
| @pytest.mark.rb(depth=0, jump_kind="none") |
| def test_gate_welcome_interactive_inventory_and_tree_depth(self, ax): |
| """Interactive inventory of the welcome window: >=4 AXPress-able widgets whose names |
| are the 3 actions + 'Close', a single 'Version …' AXStaticText, >=8 AX nodes total |
| and a subtree at least 4 levels deep (window > group > scroll area > outline > column).""" |
| w = rb_enter_welcome_surface(ax) |
| assert w is not None, "no welcome window (AXIdentifier 'welcome' / title 'Welcome To CodeEdit')" |
|
|
| els = ax.find(root_id=w.id, max_results=300, max_depth=10) |
| pressable = [e for e in els if "AXPress" in (e.actions or [])] |
| assert len(pressable) >= 4, ( |
| f"only {len(pressable)} AXPress-able widgets in the welcome window, expected >=4") |
| pressable_names = {e.name for e in pressable if e.name} |
| for label in WELCOME_BUTTONS + ("Close",): |
| assert label in pressable_names, ( |
| f"{label!r} is not an AXPress-able widget (pressable={sorted(pressable_names)})") |
|
|
| version_labels = [e for e in els if e.role == "label" |
| and str(ax.get(e.id, ["AXValue"]).get("AXValue") or "").startswith("Version")] |
| assert len(version_labels) == 1, ( |
| f"expected exactly 1 'Version …' AXStaticText in the welcome window, " |
| f"got {len(version_labels)}") |
|
|
| subtree = ax.tree(max_depth=10, root_id=w.id) |
| assert node_count(subtree) >= 8, ( |
| f"welcome window subtree has only {node_count(subtree)} AX nodes") |
| depth = tree_depth(subtree) |
| assert depth >= 4, ( |
| f"welcome window AX subtree is only {depth} levels deep, expected >=4 " |
| "(window > hosting group > scroll area > outline > column)") |
|
|
|
|
| |
|
|
| class TestWindowSurfaceReach: |
|
|
| @pytest.mark.rb(depth=1, jump_kind="reach", |
| expect="CodeEdit > Settings... adds window|General (id 'settings') holding " |
| "an AXSplitGroup 'settings, SidebarNavigationSplitView', 2 AXOutline " |
| "'Sidebar', an AXToolbar and the 9 sidebar pane buttons General, " |
| "Accounts, Navigation, Themes, Text Editing, Terminal, Search, " |
| "Source Control, Locations (recon +59 nodes; >=30 asserted)") |
| def test_settings_window_reach(self, ax): |
| before = kit.rb_showing(ax, max_depth=DEEP) |
| w = rb_enter_settings_surface(ax) |
| after = kit.rb_showing(ax, max_depth=DEEP) |
| assert kit.rb_reach(before, after, target="window|General", source=None), ( |
| "no 'General' settings window appeared after CodeEdit > Settings... " |
| f"(new nodes: {sorted(list(after - before))[:12]})") |
|
|
| assert w is not None, "no settings window (AXIdentifier 'settings' / title 'General')" |
| assert (w.name or "") == "General", ( |
| f"settings window title = {w.name!r}, expected the selected pane name 'General'") |
| assert len(after - before) >= 30, ( |
| f"the settings window only added {len(after - before)} AX nodes (recon: +59)") |
|
|
| split = ax.find(role="split_group", root_id=w.id, max_results=10, max_depth=8) |
| assert split, "settings window contains no AXSplitGroup" |
| split_ids = [ax.get(s.id, ["AXIdentifier"]).get("AXIdentifier") for s in split] |
| assert any(sid and "SidebarNavigationSplitView" in str(sid) for sid in split_ids), ( |
| "settings window has no AXSplitGroup identified as the sidebar navigation split " |
| f"view (identifiers = {split_ids!r}, recon: 'settings, SidebarNavigationSplitView')") |
|
|
| outlines = [o for o in ax.find(role="outline", root_id=w.id, max_results=10, max_depth=12) |
| if (o.name or "") == "Sidebar"] |
| assert len(outlines) >= 2, ( |
| f"expected 2 AXOutline 'Sidebar' in the Settings sidebar, got {len(outlines)}") |
| assert ax.find(role="toolbar", root_id=w.id, max_results=3, max_depth=5), \ |
| "settings window has no AXToolbar" |
|
|
| btn_names = set(names_in(ax, w.id, role="button", max_depth=16)) |
| for pane in SETTINGS_PANES: |
| assert pane in btn_names, ( |
| f"Settings sidebar is missing the {pane!r} pane button " |
| f"(buttons={sorted(btn_names)})") |
|
|
| screenshot_assert( |
| "structure_test_settings_window", |
| "CodeEdit Settings window titled 'General' floating over the welcome window: a " |
| "left sidebar with a search field and 9 colour-icon rows (General, Accounts, " |
| "Navigation, Themes, Text Editing, Terminal, Search, Source Control, Locations) " |
| "with 'General' highlighted, and a right detail pane of grouped rows containing " |
| "popup menus (Appearance, Show Issues, Reopen Behavior, File Extensions), several " |
| "toggle switches and two radio pairs (Color/Monochrome and Top/Side).", |
| RESULTS_DIR) |
|
|
| @pytest.mark.rb(depth=1, jump_kind="reach", |
| expect="CodeEdit > About CodeEdit adds the about window (id 'about', empty " |
| "title) with button|Contributors, button|Acknowledgements, " |
| "link|MIT License and label|Copyright © 2022-2024 CodeEdit " |
| "(recon +6 nodes; >=4 asserted)") |
| def test_about_window_reach(self, ax): |
| before = kit.rb_showing(ax, max_depth=DEEP) |
| w = rb_enter_about_surface(ax) |
| after = kit.rb_showing(ax, max_depth=DEEP) |
| assert kit.rb_reach(before, after, target="button|Acknowledgements", source=None), ( |
| "no About window with an 'Acknowledgements' button appeared " |
| f"(new nodes: {sorted(list(after - before))[:12]})") |
|
|
| assert w is not None, "no About window (AXIdentifier 'about' / 'Acknowledgements' button)" |
| assert len(after - before) >= 4, ( |
| f"the About window only added {len(after - before)} AX nodes (recon: +6)") |
|
|
| for role, name in (("button", "Contributors"), ("button", "Acknowledgements"), |
| ("link", "MIT License"), |
| ("label", "Copyright © 2022-2024 CodeEdit")): |
| assert shows(ax, after, role, name, root_id=w.id), ( |
| f"About window is missing the {role} {name!r}") |
|
|
| links = [ln.name for ln in ax.find(role="link", root_id=w.id, |
| max_results=5, max_depth=10)] |
| assert links == ["MIT License"], f"About window AXLinks = {links!r}, expected ['MIT License']" |
|
|
| @pytest.mark.rb(depth=1, jump_kind="reach", |
| expect="Extensions > Open Extensions Window adds window|Extensions " |
| "(id 'extensions') with button|Hide Sidebar, label|Select an " |
| "extension, popup|more toolbar items, an AXToolbar, an AXSplitter " |
| "and one empty AXOutline 'Sidebar' (recon +9 nodes; >=5 asserted)") |
| def test_extensions_window_reach(self, ax): |
| before = kit.rb_showing(ax, max_depth=DEEP) |
| w = rb_enter_extensions_surface(ax) |
| after = kit.rb_showing(ax, max_depth=DEEP) |
| assert kit.rb_reach(before, after, target="window|Extensions", source=None), ( |
| "no 'Extensions' window appeared after Extensions > Open Extensions Window " |
| f"(new nodes: {sorted(list(after - before))[:12]})") |
|
|
| assert w is not None, "no Extensions window (AXIdentifier 'extensions' / title 'Extensions')" |
| assert (w.name or "") == "Extensions", f"Extensions window title = {w.name!r}" |
| assert len(after - before) >= 5, ( |
| f"the Extensions window only added {len(after - before)} AX nodes (recon: +9)") |
|
|
| for role, name in (("button", "Hide Sidebar"), ("label", "Select an extension"), |
| ("popup", "more toolbar items")): |
| assert shows(ax, after, role, name, root_id=w.id), ( |
| f"Extensions window is missing the {role} {name!r}") |
| assert ax.find(role="toolbar", root_id=w.id, max_results=3, max_depth=5), \ |
| "Extensions window has no AXToolbar" |
| assert ax.find(role="splitter", root_id=w.id, max_results=3, max_depth=10), \ |
| "Extensions window has no AXSplitter" |
| outlines = [o.name for o in ax.find(role="outline", root_id=w.id, |
| max_results=5, max_depth=12)] |
| assert "Sidebar" in outlines, ( |
| f"Extensions window outlines = {outlines!r}, expected the extension-list " |
| "AXOutline 'Sidebar'") |
|
|
|
|
| |
|
|
| class TestModalSurfaceReach: |
|
|
| @pytest.mark.rb(depth=1, jump_kind="reach", |
| expect="welcome 'Clone Git Repository...' raises exactly 1 AXSheet with " |
| "label|Clone a repository, label|Enter a git repository URL:, one " |
| "AXTextField, button|Cancel and a DISABLED button|Clone, while the " |
| "welcome window stays the only AXWindow") |
| def test_clone_sheet_reach(self, ax): |
| before = kit.rb_showing(ax, max_depth=DEEP) |
| sheet = rb_enter_clone_sheet(ax) |
| after = kit.rb_showing(ax, max_depth=DEEP) |
| assert kit.rb_reach(before, after, target="label|Clone a repository", source=None), ( |
| "'Clone Git Repository...' raised no sheet titled 'Clone a repository' " |
| f"(new nodes: {sorted(list(after - before))[:12]})") |
|
|
| assert sheet is not None, "'Clone Git Repository...' raised no AXSheet" |
| sheets = ax.find(role="sheet", max_results=5, max_depth=6) |
| assert len(sheets) == 1, f"expected exactly 1 AXSheet, got {len(sheets)}" |
| hosts = [w for w in all_windows(ax) |
| if win_id(ax, w) == "welcome" or (w.name or "") == WELCOME_TITLE] |
| assert len(hosts) == 1, "the clone sheet must sit on the single welcome window" |
|
|
| for role, name in (("label", "Clone a repository"), |
| ("label", "Enter a git repository URL:"), |
| ("button", "Cancel"), ("button", "Clone")): |
| assert shows(ax, after, role, name, root_id=sheet.id), ( |
| f"clone sheet is missing the {role} {name!r}") |
| fields = ax.find(role="text_field", root_id=sheet.id, max_results=5, max_depth=8) |
| assert len(fields) == 1, ( |
| f"expected exactly 1 AXTextField (the git URL) in the clone sheet, got {len(fields)}") |
| clone_btn = buttons_named(ax, sheet.id, "Clone") |
| assert clone_btn, "clone sheet has no 'Clone' button" |
| assert clone_btn[0].enabled is False, \ |
| "'Clone' must be AXEnabled == False while the URL field is empty" |
|
|
| dismiss_panel_or_sheet(ax) |
|
|
| @pytest.mark.rb(depth=1, jump_kind="reach", |
| expect="welcome 'Open File or Folder...' swaps the window list: " |
| "window|Welcome To CodeEdit LEAVES it and window|Open Workspace or " |
| "File (id 'open-panel') with button|Open + button|Cancel appears " |
| "(recon +47 nodes; >=20 asserted)") |
| def test_open_panel_reach(self, ax): |
| before = kit.rb_showing(ax, max_depth=DEEP) |
| panel = rb_enter_open_panel(ax) |
| after = kit.rb_showing(ax, max_depth=DEEP) |
| assert kit.rb_reach(before, after, |
| target="window|Open Workspace or File", |
| source="window|Welcome To CodeEdit"), ( |
| "'Open File or Folder...' did not replace the welcome window with the " |
| f"'Open Workspace or File' panel (new nodes: {sorted(list(after - before))[:12]})") |
|
|
| assert panel is not None, "no window titled 'Open Workspace or File'" |
| assert len(after - before) >= 20, ( |
| f"the open panel only added {len(after - before)} AX nodes (recon: +47)") |
|
|
| titles = [(w.name or "") for w in all_windows(ax)] |
| assert WELCOME_TITLE not in titles, ( |
| "the welcome window must leave the AX window list while the modal open panel " |
| f"is up; window list = {titles!r}") |
| for name in ("Open", "Cancel"): |
| assert shows(ax, after, "button", name, root_id=panel.id), ( |
| f"the open panel is missing the {name!r} button") |
|
|
| dismiss_panel_or_sheet(ax) |
|
|
| @pytest.mark.rb(depth=1, jump_kind="reach", |
| expect="welcome 'Create New File...' adds window|Save (id 'save-panel') " |
| "with label|Save As:, text_field|Untitled, a 'Where:' AXPopUpButton, " |
| "button|Save and button|Cancel (recon +13 nodes; >=6 asserted)") |
| def test_save_panel_reach(self, ax): |
| before = kit.rb_showing(ax, max_depth=DEEP) |
| panel = rb_enter_save_panel(ax) |
| after = kit.rb_showing(ax, max_depth=DEEP) |
| assert kit.rb_reach(before, after, target="window|Save", source=None), ( |
| "'Create New File...' raised no 'Save' panel window " |
| f"(new nodes: {sorted(list(after - before))[:12]})") |
|
|
| assert panel is not None, "no window titled 'Save'" |
| assert len(after - before) >= 6, ( |
| f"the save panel only added {len(after - before)} AX nodes (recon: +13)") |
|
|
| for role, name in (("label", "Save As:"), ("text_field", "Untitled"), |
| ("button", "Save"), ("button", "Cancel")): |
| assert shows(ax, after, role, name, root_id=panel.id), ( |
| f"the save panel is missing the {role} {name!r}") |
| assert ax.find(role="popup", root_id=panel.id, max_results=5, max_depth=12), \ |
| "the save panel has no 'Where:' AXPopUpButton" |
|
|
| dismiss_panel_or_sheet(ax) |
|
|
|
|
| |
|
|
| |
|
|
| class TestSettingsPaneStructureReach: |
|
|
| @pytest.mark.rb(depth=2, jump_kind="reach", |
| expect="Settings (General) -> CG-click the sidebar pane 'Text Editing': the " |
| "window title becomes 'Text Editing', the General row " |
| "label|Reopen Behavior DISAPPEARS and label|Prefer Indent Using, " |
| "label|Indent Width, label|Tab Width, label|Font Size, " |
| "label|Bracket Pair Highlight APPEAR") |
| def test_settings_text_editing_pane_reach(self, ax): |
| w = rb_enter_settings_surface(ax) |
| assert w is not None, "no settings window (AXIdentifier 'settings' / title 'General')" |
| assert (w.name or "") == "General", ( |
| f"Settings must open on the 'General' pane, window title = {w.name!r}") |
|
|
| before = kit.rb_showing(ax, max_depth=DEEP) |
| w2 = rb_reach_settings_pane_surface(ax, "Text Editing") |
| after = kit.rb_showing(ax, max_depth=DEEP) |
| assert kit.rb_reach(before, after, target="label|Prefer Indent Using", |
| source="label|Reopen Behavior"), ( |
| "selecting the 'Text Editing' pane did not swap the General detail rows for the " |
| f"Text Editing ones (new nodes: {sorted(list(after - before))[:12]})") |
|
|
| assert w2 is not None, "the settings window vanished after selecting a pane" |
| assert (w2.name or "") == "Text Editing", ( |
| f"the settings window title should equal the selected pane, got {w2.name!r}") |
| for name in ("Indent Width", "Tab Width", "Font Size", "Bracket Pair Highlight", |
| "Wrap lines to editor width"): |
| assert shows(ax, after, "label", name, root_id=w2.id), ( |
| f"the Text Editing pane is missing the label {name!r}") |
|
|
| btn_names = set(names_in(ax, w2.id, role="button", max_depth=16)) |
| for pane in SETTINGS_PANES: |
| assert pane in btn_names, ( |
| f"the Settings sidebar lost the {pane!r} pane button after switching panes " |
| f"(buttons={sorted(btn_names)})") |
|
|
