"""AT-SPI STRUCTURE lane for SolveSpace (parametric 2D/3D CAD, GTK3 + OpenGL). This lane is the GATE (the app's top-level surfaces exist) PLUS tree-SHAPE deltas (an interaction changes the SHAPE of the AT-SPI tree: a modal adds a NEW top-level window; a toggle removes/adds a whole frame). It asserts SHAPE ONLY -- the COUNT / SET of the app's top-level children before -> interact -> after. It never asserts content, values, CHECKED, or focus: those belong to the text / computation / state lanes and are ceded to them here. Every shape delta below was OBSERVED on the running reference (a pre-loaded box with a translate/step group; two top-level frames on the bus -- the graphics window and the Property Browser): * Opening About or Measuring Volume adds a THIRD top-level child, a new `alert` node named "Information" (a separate "Message -- SolveSpace" X window). The app's count of SHOWING top-level children goes 2 -> 3; pressing the alert's OK `push button` removes it (3 -> 2). Pure tree-SHAPE delta -- the dialog's *text* is the text/ computation lane's job, not asserted here. * Toggling "Show Property Browser" off makes the whole "Property Browser -- SolveSpace" frame stop SHOWING, so the app's set of SHOWING frames shrinks 2 -> 1; toggling it back restores 2. The CHECKED state of that menu item is the STATE lane's verdict; here only the frame COUNT is the verdict. A pixel-perfect dead shell whose About/Measure opens no new window, and whose Show Property Browser toggle removes no frame, produces NO shape delta and MUST fail here -- the observable change in the tree's shape is the only signal. Mechanics (proven on the reference): - Menu items have INVALID extents (-2147483648) -> not pixel-clickable. Toggles / PB-nav fire via ``rb_atspi.do_action(item, "click")`` (in place, no focus). The modal-opener About fires via ``rb_atspi.do_action_safe(item, "click")`` (bounded, won't hang on the nested dialog loop). Measure Volume fires via its accelerator (Ctrl+Shift+V) sent to the activated+focused graphics window with the mouse first moved over the canvas. - The message alert is a SEPARATE X window ("Message --"/"Error -- SolveSpace"); a single non-overlapping alert also closes via ``do_action`` on its OK `push button`. The autouse teardown force-closes any leftover dialog (activate its X window, click OK's live bottom-center) and restores the Property Browser, so tests are order-independent on this shared single-instance app. Only ONE dialog is opened per test. No screenshots in this lane: the dialog-appearance is already screenshotted by the menu / computation lanes, and the Property-Browser-hidden state is already captured by the state lane -- shipping them again would be duplicate rendered states. The AT-SPI shape COUNTS are the verdict here. """ import os, time, subprocess, gi gi.require_version('Atspi', '2.0') from gi.repository import Atspi import pytest from pytest_check import check import rb_atspi from rb_atspi import rb_showing, rb_reach # --------------------------------------------------------------------------- # # Embedded helpers (encode the proven SolveSpace tree-shape mechanics; local) # --------------------------------------------------------------------------- # def _gw(app): """The graphics-window frame (owns the menu bar), not the Property Browser.""" for i in range(app.get_child_count()): f = app.get_child_at_index(i) nm = f.get_name() or "" if "SolveSpace" in nm and "Property Browser" not in nm: return f return rb_atspi.get_main_frame(app) def _pb(app): """The Property Browser top-level frame, or None if not present (toggling Show Property Browser off removes it from the tree).""" for i in range(app.get_child_count()): f = app.get_child_at_index(i) if "Property Browser" in (f.get_name() or ""): return f return None def _item(app, name): """A `check menu item` in the graphics window's menu bar, by plain visible label.""" return rb_atspi.find_first(_gw(app), role="check menu item", name=name) def _showing_toplevels(app): """(role, name) of the app's SHOWING top-level children (frames + alerts).""" out = [] for i in range(app.get_child_count()): c = app.get_child_at_index(i) if rb_atspi.is_showing(c): out.append((c.get_role_name(), c.get_name() or "")) return out def _n_showing(app): return len(_showing_toplevels(app)) def _showing_frames(app): """(role, name) of the app's SHOWING top-level FRAMES only (excludes alerts).""" return [ (c.get_role_name(), c.get_name() or "") for i in range(app.get_child_count()) for c in [app.get_child_at_index(i)] if c.get_role_name() == "frame" and rb_atspi.is_showing(c) ] def _n_showing_frames(app): return len(_showing_frames(app)) def _alerts(app): """The app's SHOWING top-level `alert` children (message/error dialogs).""" return [ app.get_child_at_index(i) for i in range(app.get_child_count()) if app.get_child_at_index(i).get_role_name() == "alert" and rb_atspi.is_showing(app.get_child_at_index(i)) ] # --- modal message/error dialog handling (separate X windows) --------------- # def _dialog_wids(app): """X window ids of the app's open Message-/Error- dialogs (separate windows).""" pid = app.get_process_id() r = subprocess.run( ["xdotool", "search", "--pid", str(pid)], capture_output=True, text=True ) out = [] for w in r.stdout.split(): nm = subprocess.run( ["xdotool", "getwindowname", w], capture_output=True, text=True ).stdout.strip() if nm.startswith("Message —") or nm.startswith("Error —"): out.append(w) return out def _dialog_present(app): return len(_dialog_wids(app)) > 0 def _close_dialogs(app, rounds=6): """Force-close any open Message-/Error- dialog by activating its X window and clicking OK's live bottom-center (AT-SPI OK extents go stale under overlap).""" for _ in range(rounds): wids = _dialog_wids(app) if not wids: break for w in wids: g = subprocess.run( ["xdotool", "getwindowgeometry", "--shell", w], capture_output=True, text=True, ).stdout d = dict(l.split("=") for l in g.strip().splitlines() if "=" in l) if not d: continue subprocess.run(["xdotool", "windowactivate", "--sync", w]) time.sleep(0.2) cx = int(d["X"]) + int(d["WIDTH"]) // 2 cy = int(d["Y"]) + int(d["HEIGHT"]) - 22 subprocess.run(["xdotool", "mousemove", str(cx), str(cy), "click", "1"]) time.sleep(0.3) def _gw_wid(app): """X window id of the graphics window (for accelerator focus).""" pid = app.get_process_id() r = subprocess.run( ["xdotool", "search", "--pid", str(pid)], capture_output=True, text=True ) for w in r.stdout.split(): nm = subprocess.run( ["xdotool", "getwindowname", w], capture_output=True, text=True ).stdout.strip() if ( nm.endswith("— SolveSpace") and "Property Browser" not in nm and not nm.startswith(("Message", "Error")) ): return w return None def _accel(app, keys): """Send a keyboard accelerator to the graphics window. REQUIRES windowactivate --sync + windowfocus AND the mouse first moved over the canvas, else the key is dropped (proven by recon).""" wid = _gw_wid(app) if wid: subprocess.run(["xdotool", "windowactivate", "--sync", wid, "windowfocus", wid]) time.sleep(0.4) subprocess.run(["xdotool", "mousemove", "400", "400"]) time.sleep(0.2) subprocess.run(["xdotool", "key", "--clearmodifiers", keys]) time.sleep(0.8) def _restore_pb(app): """If a test left the Property Browser hidden, toggle it back on so the two-frame shape is restored for the next test.""" if _pb(app) is None or not rb_atspi.is_showing(_pb(app)): it = _item(app, "Show Property Browser") if it is not None: rb_atspi.do_action(it, "click") rb_atspi.wait_for( lambda: _pb(app) is not None and rb_atspi.is_showing(_pb(app)), timeout=4.0, ) # --------------------------------------------------------------------------- # # Order-independence: no leftover dialog, PB restored, before + after each test. # --------------------------------------------------------------------------- # @pytest.fixture(autouse=True) def _clean(app): _close_dialogs(app) _restore_pb(app) yield _close_dialogs(app) _restore_pb(app) # --------------------------------------------------------------------------- # # GATE (jump_kind="none", existence) -- kept to exactly these two (<=30% of lane) # --------------------------------------------------------------------------- # @pytest.mark.rb( jump_kind="none", expect="app node exposes both a graphics-window frame and a Property Browser frame, both SHOWING", ) def test_top_level_frames_exist(app): """GATE: the `solvespace` application node exposes its TWO top-level surfaces -- a graphics-window frame (name ends '— SolveSpace', not the Property Browser) AND a 'Property Browser — SolveSpace' frame -- and both are SHOWING. This is the launch surface: no frames / not showing => the app did not come up.""" gw = _gw(app) pb = _pb(app) check.is_true(gw is not None, "graphics-window frame missing under the app node") if gw is not None: check.equal(gw.get_role_name(), "frame", "graphics window should be a frame") nm = gw.get_name() or "" check.is_true( nm.endswith("— SolveSpace") and "Property Browser" not in nm, f"graphics-window frame title unexpected: {nm!r}", ) check.is_true(rb_atspi.is_showing(gw), "graphics-window frame is not SHOWING") check.is_true(pb is not None, "Property Browser frame missing under the app node") if pb is not None: check.equal(pb.get_role_name(), "frame", "Property Browser should be a frame") check.is_true(rb_atspi.is_showing(pb), "Property Browser frame is not SHOWING") # Both distinct surfaces present and showing at rest -> the app's baseline shape is 2. check.equal( _n_showing_frames(app), 2, f"expected exactly 2 showing top-level frames at rest, saw {_showing_frames(app)}", ) @pytest.mark.rb( jump_kind="none", expect="graphics window contains one menu bar with >=8 menu children", ) def test_menu_bar_present_with_menus(app): """GATE: the graphics window contains exactly one `menu bar`, and that menu bar has at least the 8 top-level menus (File/Edit/View/New Group/Sketch/Constrain/Analyze/ Help, among others). Asserts SHAPE only (a menu bar with menu children) -- what those menus DO is the menu lane's job.""" gw = _gw(app) assert gw is not None, "graphics-window frame missing" bars = rb_atspi.find_all(gw, role="menu bar") check.equal(len(bars), 1, f"expected exactly one menu bar, found {len(bars)}") if bars: menus = rb_atspi.find_all(bars[0], role="menu") check.greater_equal( len(menus), 8, f"menu bar should expose >=8 menu children, found {len(menus)}: " f"{[m.get_name() for m in menus]}", ) names = {m.get_name() for m in menus} # A couple of anchor menus that must be present in the top-level bar. for anchor in ("File", "View", "Help"): check.is_in(anchor, names, f"expected a top-level '{anchor}' menu in the menu bar") # --------------------------------------------------------------------------- # # SHAPE DELTAS (interactive) -- the majority of the lane # --------------------------------------------------------------------------- # @pytest.mark.rb( jump_kind="reach", expect="Help>About adds a THIRD top-level child: a new 'Information' alert window (showing top-levels 2->3)", ) def test_about_dialog_adds_toplevel_window(app, rb): """SHAPE DELTA: opening Help > About adds a NEW top-level window to the tree. Before, the app has 2 showing top-level children (graphics + Property Browser) and NO alert; after, there is a THIRD showing child -- an `alert` named 'Information' (a separate 'Message — SolveSpace' X window) -- so the count goes 2 -> 3 and rb_reach confirms the 'Information' surface newly APPEARED. The dialog's TEXT is the text lane's verdict; here only the new-window shape is asserted. Teardown closes it.""" _close_dialogs(app) about = rb_atspi.find_first(_gw(app), role="check menu item", name="About") assert about is not None, "Help>About menu item missing" before = rb_showing(app) n_before = _n_showing(app) check.equal(n_before, 2, f"expected 2 showing top-levels before About, saw {_showing_toplevels(app)}") check.equal(len(_alerts(app)), 0, "an alert window was already open before About") rb.enter("about dialog") # real dialog crossing -> measured depth 1 rb_atspi.do_action_safe(about, "click") # modal-opener: bounded, won't hang appeared = rb_atspi.wait_for(lambda: _n_showing(app) > n_before, timeout=6.0) after = rb_showing(app) # SHAPE verdict: count increased by one AND a new alert node exists. check.is_true(appeared, "About did not add a new top-level window (count did not increase)") check.equal( _n_showing(app), n_before + 1, f"expected showing top-levels {n_before}->{n_before + 1} after About, saw {_showing_toplevels(app)}", ) check.greater_equal(len(_alerts(app)), 1, "no new `alert` node appeared after opening About") # True-jump: the 'Information' alert surface newly appeared (was not there before). check.is_true( rb_reach(before, after, target="Information"), "rb_reach: the 'Information' alert surface did not newly appear after About", ) _close_dialogs(app) @pytest.mark.rb( jump_kind="reach", expect="Analyze>Measure Volume (Ctrl+Shift+V) adds a new 'Information' alert window (showing top-levels 2->3)", ) def test_measure_dialog_adds_toplevel_window(app, rb): """SHAPE DELTA via a DIFFERENT user path (a keyboard accelerator, not a menu action): Measure Volume (Ctrl+Shift+V) also spawns a NEW top-level `alert` ('Information', a separate 'Message — SolveSpace' X window), so the app's showing top-level count goes 2 -> 3 and rb_reach confirms the new surface appeared. The measured VALUE inside is the computation lane's verdict; here only the added-window shape counts. Teardown closes it.""" _close_dialogs(app) before = rb_showing(app) n_before = _n_showing(app) check.equal(n_before, 2, f"expected 2 showing top-levels before Measure, saw {_showing_toplevels(app)}") check.equal(len(_alerts(app)), 0, "an alert window was already open before Measure") rb.enter("measure volume dialog") # real dialog crossing -> measured depth 1 _accel(app, "ctrl+shift+v") appeared = rb_atspi.wait_for(lambda: _n_showing(app) > n_before, timeout=6.0) after = rb_showing(app) check.is_true(appeared, "Measure Volume did not add a new top-level window (count did not increase)") check.equal( _n_showing(app), n_before + 1, f"expected showing top-levels {n_before}->{n_before + 1} after Measure, saw {_showing_toplevels(app)}", ) check.greater_equal(len(_alerts(app)), 1, "no new `alert` node appeared after Measure Volume") check.is_true( rb_reach(before, after, target="Information"), "rb_reach: the 'Information' alert surface did not newly appear after Measure Volume", ) _close_dialogs(app) @pytest.mark.rb( jump_kind="reach", expect="Opening About adds exactly one ALERT top-level while the FRAME count stays 2 (the added surface is a new window, not a re-parented frame)", ) def test_dialog_adds_alert_not_frame(app, rb): """SHAPE DELTA, partitioned by ROLE, to prove WHAT changed: opening a dialog must add the new surface as a top-level `alert`, NOT change the number of `frame`s. Before, the app has 2 frames and 0 alerts; after opening About the alert count goes 0 -> 1 while the FRAME count stays 2 (the two original frames are untouched). This discriminates a real 'new dialog window' shape delta from an app that merely re-labels/re-parents an existing frame -- the frame set is invariant, only an alert is added. Teardown closes it.""" _close_dialogs(app) about = rb_atspi.find_first(_gw(app), role="check menu item", name="About") assert about is not None, "Help>About menu item missing" frames_before = set(_showing_frames(app)) n_frames_before = len(frames_before) n_alerts_before = len(_alerts(app)) check.equal(n_frames_before, 2, f"expected 2 showing frames before the dialog, saw {sorted(frames_before)}") check.equal(n_alerts_before, 0, "an alert was already open before the dialog") rb.enter("about dialog") # real dialog crossing -> measured depth 1 rb_atspi.do_action_safe(about, "click") added_alert = rb_atspi.wait_for(lambda: len(_alerts(app)) > n_alerts_before, timeout=6.0) frames_after = set(_showing_frames(app)) # Verdict: exactly one alert added, and the FRAME set is unchanged. check.is_true(added_alert, "opening About added no `alert` top-level") check.equal( len(_alerts(app)), n_alerts_before + 1, f"expected the alert count 0->1, saw {len(_alerts(app))}", ) check.equal( frames_after, frames_before, f"the FRAME set changed when opening a dialog (should be invariant): " f"before={sorted(frames_before)} after={sorted(frames_after)}", ) check.equal( len(frames_after), n_frames_before, f"the number of showing frames changed on dialog open (expected {n_frames_before})", ) _close_dialogs(app) @pytest.mark.rb( jump_kind="transition", expect="Pressing the alert's OK push button REMOVES the alert window (showing top-levels 3->2)", ) def test_ok_removes_toplevel_window(app, rb): """SHAPE DELTA in the REMOVE direction: with one dialog open (About) the app has N showing top-levels including the 'Information' alert; pressing that alert's OK `push button` (do_action 'click' -- a single non-overlapping alert closes in place) removes the window from the tree, so the count drops N -> N-1 and the alert node is gone. The window-count shrinking is the verdict (not what the button 'says').""" _close_dialogs(app) about = rb_atspi.find_first(_gw(app), role="check menu item", name="About") assert about is not None, "Help>About menu item missing" n_base = _n_showing(app) rb.enter("about dialog") # cross into the dialog we are about to dismiss -> depth 1 rb_atspi.do_action_safe(about, "click") check.is_true( rb_atspi.wait_for(lambda: len(_alerts(app)) >= 1, timeout=6.0), "precondition: About did not open an alert to dismiss", ) n_open = _n_showing(app) check.equal(n_open, n_base + 1, f"expected the alert to raise the count to {n_base + 1}, saw {n_open}") alerts = _alerts(app) assert alerts, "no alert present to press OK on" ok = rb_atspi.find_first(alerts[0], role="push button", name="OK") or rb_atspi.find_first( alerts[0], role="push button" ) assert ok is not None, "the alert has no OK push button" # BEFORE -> interact -> AFTER: pressing OK removes the top-level window. removed = False if rb_atspi.do_action(ok, "click"): removed = rb_atspi.wait_for(lambda: _n_showing(app) < n_open, timeout=6.0) if not removed: # fall back to the live-geometry X-window close, then re-check _close_dialogs(app) removed = _n_showing(app) < n_open check.is_true(removed, "pressing OK did not remove the alert window (count did not decrease)") check.equal( _n_showing(app), n_open - 1, f"expected showing top-levels {n_open}->{n_open - 1} after OK, saw {_showing_toplevels(app)}", ) check.equal(len(_alerts(app)), 0, "the `alert` node is still present after pressing OK") _close_dialogs(app) @pytest.mark.rb( jump_kind="transition", expect="Show Property Browser toggles the whole PB frame out of the showing-frames set (2->1) and back (1->2)", ) def test_show_property_browser_changes_frame_count(app, rb): """SHAPE DELTA on FRAMES (no new window -- a whole frame removed then restored): the app has 2 showing top-level frames (graphics + Property Browser). Clicking View > Show Property Browser makes the 'Property Browser — SolveSpace' frame stop SHOWING, so the set of showing frames shrinks 2 -> 1; clicking again restores it 1 -> 2. The COUNT/SET of showing frames changing then restoring is the verdict -- the item's CHECKED state is the state lane's, deliberately not asserted here. Depth 0: hiding a frame is an in-place toggle, not a navigation into a new surface.""" _close_dialogs(app) it = _item(app, "Show Property Browser") assert it is not None, "View>Show Property Browser menu item missing" frames_before = set(_showing_frames(app)) n_before = len(frames_before) check.equal(n_before, 2, f"expected 2 showing frames before toggle, saw {sorted(frames_before)}") check.is_true( any("Property Browser" in nm for (_r, nm) in frames_before), "Property Browser frame should be among the showing frames before the toggle", ) # Toggle OFF -> the PB frame leaves the showing-frames set. rb_atspi.do_action(it, "click") shrank = rb_atspi.wait_for(lambda: _n_showing_frames(app) < n_before, timeout=5.0) frames_off = set(_showing_frames(app)) check.is_true(shrank, "Show Property Browser off did not reduce the showing-frame count") check.equal( len(frames_off), n_before - 1, f"expected showing frames {n_before}->{n_before - 1} after hiding PB, saw {sorted(frames_off)}", ) check.is_false( any("Property Browser" in nm for (_r, nm) in frames_off), "the Property Browser frame is still showing after toggling it off", ) # Toggle BACK ON -> the PB frame returns; the shape is restored. it2 = _item(app, "Show Property Browser") # re-fetch (tree updates after the action) rb_atspi.do_action(it2, "click") restored = rb_atspi.wait_for(lambda: _n_showing_frames(app) == n_before, timeout=5.0) frames_after = set(_showing_frames(app)) check.is_true(restored, "Show Property Browser on did not restore the showing-frame count") check.equal( len(frames_after), n_before, f"expected showing frames restored to {n_before}, saw {sorted(frames_after)}", ) check.is_true( any("Property Browser" in nm for (_r, nm) in frames_after), "the Property Browser frame did not reappear after toggling Show Property Browser back on", ) check.equal( frames_before, frames_after, "the set of showing frames did not restore to its original membership", )