| """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 |
|
|
|
|
| |
| |
| |
| 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)) |
| ] |
|
|
|
|
| |
| 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, |
| ) |
|
|
|
|
| |
| |
| |
| @pytest.fixture(autouse=True) |
| def _clean(app): |
| _close_dialogs(app) |
| _restore_pb(app) |
| yield |
| _close_dialogs(app) |
| _restore_pb(app) |
|
|
|
|
| |
| |
| |
| @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") |
|
|
| |
| 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} |
| |
| for anchor in ("File", "View", "Help"): |
| check.is_in(anchor, names, f"expected a top-level '{anchor}' menu in the menu bar") |
|
|
|
|
| |
| |
| |
| @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") |
| rb_atspi.do_action_safe(about, "click") |
|
|
| appeared = rb_atspi.wait_for(lambda: _n_showing(app) > n_before, timeout=6.0) |
| after = rb_showing(app) |
|
|
| |
| 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") |
| |
| 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") |
| _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") |
| 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)) |
|
|
| |
| 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") |
| 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" |
|
|
| |
| 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: |
| _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", |
| ) |
|
|
| |
| 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", |
| ) |
|
|
| |
| it2 = _item(app, "Show Property Browser") |
| 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", |
| ) |
|
|
