"""AX STATE verification suite — DB Browser for SQLite (Qt6). Sole owner of AXMenuItemMarkChar (CHECKED), AXEnabled flips, AXFocused and the mode/selection indicators. KEY MECHANISM (recon ST1/ST2): Qt tab-bar radios expose AXValue == None and AXSelected == None, so selection CANNOT be read from the radio. The tab-bar `group`'s AXTitle equals the currently selected tab name; a tab bar is located by its exact list of direct radio children (never by index / tree path). Every test declares depth + jump rigor via @pytest.mark.rb(...) and backs a transition with kit.rb_flip / a value with kit.rb_value. """ import json import os 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__))) MAIN_TABS = ["Database Structure", "Browse Data", "Edit Pragmas", "Execute SQL"] DOCK_TABS = ["SQL Log", "Plot", "DB Schema", "Remote"] REMOTE_TABS = ["DBHub.io", "Local", "Current Database"] DIALOG_TABS = ["Fields", "Index Constraints", "Foreign Keys", "Check Constraints"] PREFS_TABS = ["General", "Database", "Data Browser", "SQL", "Extensions", "Remote"] PRAGMA_CHECKBOXES = ["Automatic Index", "Case Sensitive Like", "Checkpoint Full FSYNC", "Foreign Keys", "Full FSYNC", "Ignore Check Constraints", "Recursive Triggers", "Secure Delete"] VIEW_TOGGLES = ["SQL Log", "Plot", "DB Schema", "Edit Database Cell", "Remote", "DB Toolbar", "Extra DB Toolbar", "Project Toolbar", "Database Structure", "Browse Data", "Edit Pragmas", "Execute SQL"] def screenshot_assert(test_name, description, 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 _esc(times=1): for _ in range(times): subprocess.run(["osascript", "-e", 'tell application "System Events" to key code 53'], capture_output=True) time.sleep(0.3) def _key(code): subprocess.run(["osascript", "-e", 'tell application "System Events" to key code %d' % code], capture_output=True) time.sleep(0.35) def open_menu(ax, top): mb = ax.find(role="menu_bar_item", name=top, max_results=1) if not mb: return None ax.action(mb[0].id, "AXPress") time.sleep(0.6) m = ax.find(role="menu", root_id=mb[0].id, max_results=1, max_depth=1) return m[0] if m else None def menu_item_map(ax, top, attrs=("AXEnabled", "AXMenuItemMarkChar")): """Open `top`, read {name: {attr: value}} for its named items, then close the menu.""" m = open_menu(ax, top) out = {} if m is not None: for it in ax.find(role="menu_item", root_id=m.id, max_results=80, max_depth=1): if it.name: out[it.name] = ax.get(it.id, list(attrs)) _esc(2) return out def rb_reach_menu_item(ax, top, item_name): m = open_menu(ax, top) if m is None: return False for it in ax.find(role="menu_item", root_id=m.id, max_results=80, max_depth=1): if (it.name or "") == item_name: ok = ax.action(it.id, "AXPress") time.sleep(1.4) return bool(ok) _esc(2) return False def find_window(ax, title_substr): for w in ax.find(role="window", max_results=10, max_depth=1): if title_substr.lower() in (w.name or "").lower(): return w return None def rb_enter_inmemory_db(ax): """File > New In-Memory Database, then dismiss the auto-opened table dialog.""" rb_reach_menu_item(ax, "File", "New In-Memory Database") w = find_window(ax, "Edit table definition") if w is not None: c = ax.find(role="button", name="Cancel", root_id=w.id, max_results=2) if c: ax.action(c[0].id, "AXPress") time.sleep(1.0) return find_window(ax, "Edit table definition") is None def switch_tab(ax, name, root_id=None): r = ax.find(role="radio", name=name, max_results=1, root_id=root_id) if not r: return False ok = ax.action(r[0].id, "AXPress") time.sleep(1.0) return bool(ok) def tabbar(ax, kids, root_id=None): """The tab-bar `group` whose direct radio children == kids. AXTitle == selected tab.""" for g in ax.find(role="group", max_results=250, root_id=root_id): ks = [k.name for k in ax.find(role="radio", root_id=g.id, max_results=10, max_depth=1)] if ks == kids: return g return None def selected_tab(ax, kids, root_id=None): g = tabbar(ax, kids, root_id=root_id) return None if g is None else g.name def find_button(ax, name, root_id=None): for b in ax.find(role="button", max_results=90, root_id=root_id): if (b.name or "") == name: return b return None def enabled(ax, el): return bool(ax.get(el.id, ["AXEnabled"]).get("AXEnabled")) def btn_enabled(ax, name): b = find_button(ax, name) return None if b is None else enabled(ax, b) def checkbox_containing(ax, needle, root_id=None): """Pragma checkbox AXTitles are literal HTML -> match by substring.""" for c in ax.find(role="checkbox", max_results=60, root_id=root_id): if needle in (c.name or ""): return c return None def incrementor_containing(ax, needle, root_id=None): for c in ax.find(role="incrementor", max_results=30, root_id=root_id): if needle in (c.name or ""): return c return None def cb_value(ax, el): return ax.get(el.id, ["AXValue"]).get("AXValue") def combo_named(ax, names, root_id=None): for c in ax.find(role="combobox", max_results=30, root_id=root_id): if (c.name or "") in names: return c return None def combo_change(ax, combo, direction_code): """Qt combobox: AXPress opens the popup, then arrow + Return commits. direction_code: 125 = Down, 126 = Up.""" ax.action(combo.id, "AXPress") time.sleep(0.9) _key(direction_code) _key(36) time.sleep(0.9) def sql_editor(ax): for t in ax.find(role="text_area", max_results=15): if not ax.is_attribute_settable(t.id, "AXValue"): continue v = str(ax.get(t.id, ["AXValue"]).get("AXValue") or "") if "PRAGMA" in v or "EXECUTING" in v: continue return t return None # ─────────────────────────── extra local helpers ─────────────────────────── # All batched: ONE tree walk per role (12 separate full-tree walks blow the # 30 s per-test budget on a ~325-node tree). PRAGMA_INCREMENTORS = ["Journal Size Limit", "Max Page Count", "User Version", "WAL Auto Checkpoint"] TOOLS_ITEMS = ["Compact Database...", "Load Extension...", "Integrity Check", "Quick Integrity Check", "Foreign-Key Check", "Optimize", "Show Row Counts"] EDIT_DDL_ITEMS = ["Create Table...", "Create Index...", "Modify Table...", "Delete Table..."] # The app-menu Preferences item AXTitle is NOT stable ('Preferences...' vs # 'Settings…') — always match by keyword (EN + ZH fallbacks). PREF_KEYS = ("prefer", "etting", "偏好", "设置") def _i(v): """Normalize a checkbox AXValue (0/1, '0'/'1', bool) to an int.""" if isinstance(v, bool): return int(v) try: return int(v) except (TypeError, ValueError): return v def _numstr(v): """Normalize a spin-box AXValue to its plain string form ('1000', '-1').""" if v is None: return None if isinstance(v, bool): return str(int(v)) if isinstance(v, float) and v.is_integer(): return str(int(v)) return str(v) def buttons_by_name(ax, names, root_id=None): """{name: element} for the wanted button AXTitles — one tree walk.""" out = {} for b in ax.find(role="button", max_results=120, root_id=root_id): n = b.name or "" if n in names and n not in out: out[n] = b return out def button_names(ax, root_id=None): return [b.name or "" for b in ax.find(role="button", max_results=120, root_id=root_id)] def radio_names(ax, root_id=None): return [r.name or "" for r in ax.find(role="radio", max_results=30, root_id=root_id)] def combo_names(ax, root_id=None): return [c.name or "" for c in ax.find(role="combobox", max_results=30, root_id=root_id)] def label_texts(ax, root_id=None): """Visible label text (AXValue and AXTitle both count — a recreation may use either) for every `label` in the tree.""" out = set() for el in ax.find(role="label", max_results=150, root_id=root_id): if el.value: out.add(str(el.value)) if el.name: out.add(str(el.name)) return out def pragma_widgets(ax): """({readable name: checkbox}, {readable name: incrementor}) — 2 tree walks. Pragma AXTitles are literal HTML, so match by substring.""" cbs = ax.find(role="checkbox", max_results=60) incs = ax.find(role="incrementor", max_results=30) cmap, imap = {}, {} for n in PRAGMA_CHECKBOXES: for c in cbs: if n in (c.name or ""): cmap[n] = c break for n in PRAGMA_INCREMENTORS: for el in incs: if n in (el.name or ""): imap[n] = el break return cmap, imap def pragma_enabled_list(ax): """[AXEnabled] for the 8 pragma checkboxes then the 4 incrementors (None when the widget is missing, so a gap FAILS instead of silently passing).""" cmap, imap = pragma_widgets(ax) out = [] for n in PRAGMA_CHECKBOXES: out.append(None if n not in cmap else enabled(ax, cmap[n])) for n in PRAGMA_INCREMENTORS: out.append(None if n not in imap else enabled(ax, imap[n])) return out def pragma_value_maps(ax): cmap, imap = pragma_widgets(ax) cvals = {n: (None if n not in cmap else _i(cb_value(ax, cmap[n]))) for n in PRAGMA_CHECKBOXES} ivals = {n: (None if n not in imap else _numstr(cb_value(ax, imap[n]))) for n in PRAGMA_INCREMENTORS} return cvals, ivals def menu_enabled_map(item_map, names): return {n: (bool(item_map[n].get("AXEnabled")) if n in item_map else None) for n in names} def mark_of(item_map, name): return item_map.get(name, {}).get("AXMenuItemMarkChar") def option_texts(ax, el): """Visible option texts of a Qt combobox (its popup `list` holds one label per option). Accepts AXTitle or AXValue so framework differences don't matter.""" out = [] for lb in ax.find(role="label", root_id=el.id, max_results=40): t = lb.name or lb.value or "" if t: out.append(str(t)) return out def type_sql(ax, sql): """QScintilla ignores set_value -> CG click + ⌘A + keystroke (recon COMPUTATION).""" e = sql_editor(ax) if e is None: return False ax.click_element_cg(e.id) time.sleep(0.4) subprocess.run(["osascript", "-e", 'tell application "System Events" to keystroke "a" using command down'], capture_output=True) time.sleep(0.25) subprocess.run(["osascript", "-e", 'tell application "System Events" to keystroke ' + json.dumps(sql)], capture_output=True) time.sleep(0.5) return True def exec_sql(ax): b = find_button(ax, "Execute SQL") if b is None: return False ok = ax.action(b.id, "AXPress") time.sleep(1.9) return bool(ok) def find_prefs_window(ax): for w in ax.find(role="window", max_results=10, max_depth=1): n = (w.name or "").lower() if any(k in n for k in PREF_KEYS): return w return None def rb_reach_preferences(ax): """Open the Preferences/Settings surface by KEYWORD (recon: the menu item's AXTitle is UNSTABLE — 'Preferences...' on one build, 'Settings…' on another). Tries the app menu first, then the other menus, then the ⌘, hotkey.""" w = find_prefs_window(ax) if w is not None: return w tops = [t for t in ax.find(role="menu_bar_item", max_results=12, max_depth=3) if (t.name or "") and (t.name or "").lower() != "apple"] tops.sort(key=lambda t: 0 if any(k in (t.name or "").lower() for k in ("sqlite", "browser", "db4s")) else 1) for t in tops[:4]: m = open_menu(ax, t.name) if m is None: continue target = None for it in ax.find(role="menu_item", root_id=m.id, max_results=80, max_depth=1): nm = (it.name or "").lower() if not nm or "service" in nm: continue if any(k in nm for k in PREF_KEYS): target = it break if target is not None: ax.action(target.id, "AXPress") time.sleep(1.5) w = find_prefs_window(ax) if w is not None: return w _esc(2) subprocess.run(["osascript", "-e", 'tell application "System Events" to keystroke "," using command down'], capture_output=True) time.sleep(1.5) return find_prefs_window(ax) def close_scoped(ax, win, name="Cancel"): """Close a dialog with ITS OWN scoped button (a global find(name='Cancel') would also match the Edit-Pragmas / Preferences Cancel).""" if win is None: return False b = ax.find(role="button", name=name, root_id=win.id, max_results=2) if not b: return False ax.action(b[0].id, "AXPress") time.sleep(0.8) return True def ext_widget_counts(ax, root_id): """(n_checkboxes, n_buttons) whose visible label mentions "extension" — the Extensions prefs page signature.""" cbs = [c for c in ax.find(role="checkbox", max_results=60, root_id=root_id) if "xtension" in (c.name or "").lower()] bts = [b for b in ax.find(role="button", max_results=90, root_id=root_id) if "xtension" in (b.name or "").lower()] return len(cbs), len(bts) # ══════════════════════════════ TAB-BAR SELECTION ══════════════════════════════ class TestTabBarSelectionState: """ST1/ST2/ST3 — the mode/selection indicator is the tab-bar group's AXTitle.""" @pytest.mark.rb(depth=1, jump_kind="transition", expect="main tab-bar group AXTitle 'Database Structure'->'Execute SQL'" "->'Browse Data'->'Edit Pragmas'->back to 'Database Structure'") def test_main_tab_bar_selection_indicator_walks_all_four(self, ax): fresh = selected_tab(ax, MAIN_TABS) assert fresh == "Database Structure", ( f"fresh main tab-bar AXTitle should be 'Database Structure', got {fresh!r}") seq = [fresh] for name in ["Execute SQL", "Browse Data", "Edit Pragmas", "Database Structure"]: assert switch_tab(ax, name), f"could not AXPress main tab radio {name!r}" now = selected_tab(ax, MAIN_TABS) assert now == name, ( f"after pressing radio {name!r} the tab-bar AXTitle should be {name!r}, " f"got {now!r}") seq.append(now) assert seq == ["Database Structure", "Execute SQL", "Browse Data", "Edit Pragmas", "Database Structure"], seq assert kit.rb_flip(seq[:-1], seq[1:]), ( "the selection indicator never changed across the 4 main tabs") screenshot_assert( "states_test_main_tab_bar_selection", "DB Browser for SQLite main window with the 4-tab bar Database Structure / " "Browse Data / Edit Pragmas / Execute SQL. The walk ended back on " "Database Structure, so that tab is the highlighted/selected one and the " "left pane shows the empty object tree with Create Table, Create Index and " "Modify Table buttons above it (all greyed out, no database open).", RESULTS_DIR) @pytest.mark.rb(depth=0, jump_kind="value", expect="tab radios report AXValue None and AXSelected None; selection is " "only readable from the tab-bar group AXTitle") def test_main_tab_radios_expose_no_selection_attribute(self, ax): g = tabbar(ax, MAIN_TABS) assert g is not None, "main tab bar (radios == MAIN_TABS) not found" radios = ax.find(role="radio", root_id=g.id, max_results=10, max_depth=1) assert [r.name for r in radios] == MAIN_TABS, [r.name for r in radios] for r in radios: attrs = ax.get(r.id, ["AXValue", "AXSelected"]) assert attrs.get("AXValue") is None, ( f"radio {r.name!r} AXValue should be None, got {attrs.get('AXValue')!r}") assert attrs.get("AXSelected") is None, ( f"radio {r.name!r} AXSelected should be None, " f"got {attrs.get('AXSelected')!r}") assert kit.rb_value(selected_tab(ax, MAIN_TABS), "Database Structure") @pytest.mark.rb(depth=1, jump_kind="transition", expect="dock tab-bar group AXTitle 'Remote'->'DB Schema'->'Plot'->'SQL Log'") def test_dock_tab_bar_selection_indicator(self, ax): fresh = selected_tab(ax, DOCK_TABS) assert fresh == "Remote", ( f"fresh dock tab-bar AXTitle should be 'Remote', got {fresh!r}") seq = [fresh] for name in ["DB Schema", "Plot", "SQL Log"]: assert switch_tab(ax, name), f"could not AXPress dock tab radio {name!r}" now = selected_tab(ax, DOCK_TABS) assert now == name, ( f"after pressing dock radio {name!r} the tab-bar AXTitle should be " f"{name!r}, got {now!r}") seq.append(now) assert seq == ["Remote", "DB Schema", "Plot", "SQL Log"], seq assert kit.rb_flip(seq[:-1], seq[1:]), "the dock selection indicator never changed" screenshot_assert( "states_test_dock_tab_selection", "The bottom-right dock of DB Browser for SQLite. Its tab strip reads " "SQL Log / Plot / DB Schema / Remote and SQL Log is now the highlighted " "(selected) tab, so the dock body shows the SQL log text pane with the " "'Show SQL submitted by' dropdown (Application) and a Clear button — the " "Remote panel is no longer displayed.", RESULTS_DIR) @pytest.mark.rb(depth=1, jump_kind="transition", expect="Remote panel sub tab-bar AXTitle 'DBHub.io'->'Local'" "->'Current Database'") def test_remote_sub_tab_bar_selection_indicator(self, ax): g = tabbar(ax, REMOTE_TABS) assert g is not None, "Remote sub tab bar (radios == REMOTE_TABS) not found" fresh = g.name assert fresh == "DBHub.io", ( f"fresh Remote sub tab-bar AXTitle should be 'DBHub.io', got {fresh!r}") seq = [fresh] for name in ["Local", "Current Database"]: bar = tabbar(ax, REMOTE_TABS) assert bar is not None, "Remote sub tab bar vanished" assert switch_tab(ax, name, root_id=bar.id), ( f"could not AXPress Remote sub-tab radio {name!r}") now = selected_tab(ax, REMOTE_TABS) assert now == name, ( f"after pressing Remote sub-tab {name!r} the sub tab-bar AXTitle should " f"be {name!r}, got {now!r}") seq.append(now) assert seq == ["DBHub.io", "Local", "Current Database"], seq assert kit.rb_flip(seq[:-1], seq[1:]), "the Remote sub-tab indicator never changed" # ═════════════════════════ VIEW MENU CHECK STATE (ST6) ═════════════════════════ class TestViewMenuCheckState: """AXMenuItemMarkChar on the 12 View toggles + two SAFE round trips.""" @pytest.mark.rb(depth=1, jump_kind="value", expect="all 12 View toggles have AXMenuItemMarkChar '✓' on a fresh app") def test_view_menu_all_twelve_toggles_checked_by_default(self, ax_with_reset): ax = ax_with_reset items = menu_item_map(ax, "View") assert items, "View menu exposed no named menu items" marks = [] for name in VIEW_TOGGLES: assert name in items, f"View menu item {name!r} missing (got {sorted(items)})" mark = mark_of(items, name) assert mark == "✓", ( f"View toggle {name!r} should carry AXMenuItemMarkChar '✓' on a " f"fresh app, got {mark!r}") marks.append(mark) assert len(marks) == 12 assert kit.rb_value(sorted(set(marks)), "✓") open_menu(ax, "View") screenshot_assert( "states_test_view_menu_checkmarks", "The View menu of DB Browser for SQLite is open in the macOS menu bar. It " "lists SQL Log, Plot, DB Schema, Edit Database Cell, Remote, DB Toolbar, " "Extra DB Toolbar, Project Toolbar, Database Structure, Browse Data, " "Edit Pragmas and Execute SQL — every one of those 12 entries shows a " "checkmark on its left — plus a 'Window Layout' submenu and " "'Enter Full Screen' with no checkmark.", RESULTS_DIR) _esc(2) @pytest.mark.rb(depth=1, jump_kind="transition", expect="View▸SQL Log mark '✓'->None and the dock's Clear button / " "'Show SQL submitted by' label / source combobox / 'SQL Log' radio " "disappear, then all return") def test_view_sql_log_toggle_round_trip(self, ax_with_reset): ax = ax_with_reset mark_before = mark_of(menu_item_map(ax, "View"), "SQL Log") assert mark_before == "✓", ( f"View▸SQL Log should start CHECKED, got {mark_before!r}") assert find_button(ax, "Clear") is not None, "SQL Log dock 'Clear' button missing" before = kit.rb_showing(ax) assert rb_reach_menu_item(ax, "View", "SQL Log"), "could not press View▸SQL Log" after = kit.rb_showing(ax) mark_off = mark_of(menu_item_map(ax, "View"), "SQL Log") assert mark_off is None, ( f"View▸SQL Log mark should be None once the dock is hidden, got {mark_off!r}") assert find_button(ax, "Clear") is None, "SQL Log dock 'Clear' button still present" assert combo_named(ax, ("Application",)) is None, ( "SQL log source combobox 'Application' still present") assert "SQL Log" not in radio_names(ax), "dock tab radio 'SQL Log' still present" assert "Show SQL submitted by" not in label_texts(ax), ( "label 'Show SQL submitted by' still present") assert kit.rb_flip(mark_before, mark_off), "the SQL Log checkmark never flipped" assert len(after) < len(before), ( "hiding the SQL Log dock should REMOVE nodes from the AX tree " f"(before={len(before)} after={len(after)})") assert rb_reach_menu_item(ax, "View", "SQL Log"), "could not re-press View▸SQL Log" mark_back = mark_of(menu_item_map(ax, "View"), "SQL Log") assert mark_back == "✓", ( f"View▸SQL Log mark should return to '✓', got {mark_back!r}") assert find_button(ax, "Clear") is not None, "'Clear' button did not come back" assert combo_named(ax, ("Application",)) is not None, ( "SQL log source combobox did not come back") assert "SQL Log" in radio_names(ax), "dock tab radio 'SQL Log' did not come back" assert "Show SQL submitted by" in label_texts(ax), ( "label 'Show SQL submitted by' did not come back") _esc(2) @pytest.mark.rb(depth=1, jump_kind="transition", expect="View▸Plot mark '✓'->None->'✓' and the 'Line type:' / " "'Point shape:' labels disappear and return") def test_view_plot_toggle_round_trip(self, ax_with_reset): ax = ax_with_reset mark_before = mark_of(menu_item_map(ax, "View"), "Plot") assert mark_before == "✓", ( f"View▸Plot should start CHECKED, got {mark_before!r}") texts = label_texts(ax) assert "Line type:" in texts and "Point shape:" in texts, ( "the Plot dock's 'Line type:' / 'Point shape:' labels are missing on a fresh app") assert rb_reach_menu_item(ax, "View", "Plot"), "could not press View▸Plot" mark_off = mark_of(menu_item_map(ax, "View"), "Plot") assert mark_off is None, ( f"View▸Plot mark should be None once the dock is hidden, got {mark_off!r}") gone = label_texts(ax) assert "Line type:" not in gone, "'Line type:' label still present" assert "Point shape:" not in gone, "'Point shape:' label still present" assert "Plot" not in radio_names(ax), "dock tab radio 'Plot' still present" assert kit.rb_flip(mark_before, mark_off), "the Plot checkmark never flipped" assert rb_reach_menu_item(ax, "View", "Plot"), "could not re-press View▸Plot" mark_back = mark_of(menu_item_map(ax, "View"), "Plot") assert mark_back == "✓", ( f"View▸Plot mark should return to '✓', got {mark_back!r}") back = label_texts(ax) assert "Line type:" in back and "Point shape:" in back, ( "the Plot dock labels did not come back") _esc(2) # ═══════════════════════════ PRAGMA STATE (ST7/ST8) ═══════════════════════════ class TestPragmaState: @pytest.mark.rb(depth=1, jump_kind="value", expect="all 8 pragma checkboxes AXValue 0 / AXEnabled False and the 4 " "incrementors AXValue '0' / disabled with no database open") def test_pragma_widgets_disabled_without_database(self, ax): assert switch_tab(ax, "Edit Pragmas"), "could not activate the Edit Pragmas tab" assert selected_tab(ax, MAIN_TABS) == "Edit Pragmas" cvals, ivals = pragma_value_maps(ax) assert cvals == {n: 0 for n in PRAGMA_CHECKBOXES}, cvals assert ivals == {n: "0" for n in PRAGMA_INCREMENTORS}, ivals en = pragma_enabled_list(ax) assert len(en) == 12 and all(v is False for v in en), ( f"every pragma widget must be DISABLED with no database open, got {en}") observed = (tuple(sorted(cvals.items())), tuple(sorted(ivals.items())), tuple(en)) expected = (tuple(sorted({n: 0 for n in PRAGMA_CHECKBOXES}.items())), tuple(sorted({n: "0" for n in PRAGMA_INCREMENTORS}.items())), tuple([False] * 12)) assert kit.rb_value(observed, expected) @pytest.mark.rb(depth=1, jump_kind="transition", expect="pragma checkboxes+incrementors AXEnabled False->True after " "File▸New In-Memory Database") def test_pragma_widgets_enable_with_database(self, ax_with_reset): ax = ax_with_reset assert switch_tab(ax, "Edit Pragmas"), "could not activate the Edit Pragmas tab" before = pragma_enabled_list(ax) assert len(before) == 12 and all(v is False for v in before), before assert rb_enter_inmemory_db(ax), "in-memory database was not opened cleanly" assert switch_tab(ax, "Database Structure") assert switch_tab(ax, "Edit Pragmas"), "could not re-activate the Edit Pragmas tab" after = pragma_enabled_list(ax) assert len(after) == 12 and all(v is True for v in after), ( f"every pragma widget must be ENABLED once a database is open, got {after}") assert kit.rb_flip(before, after), "the pragma ENABLED state never flipped" @pytest.mark.rb(depth=1, jump_kind="value", expect="Foreign Keys=1, Automatic Index=1, other 6 pragma checkboxes=0, " "WAL Auto Checkpoint='1000', Journal Size Limit='-1', " "Max Page Count='0', User Version='0'") def test_pragma_values_load_for_inmemory_database(self, ax_with_reset): ax = ax_with_reset # ORDERING MATTERS: open the DB while ANOTHER tab is active, then activate # Edit Pragmas — the pragma values only load on tab activation. assert rb_enter_inmemory_db(ax), "in-memory database was not opened cleanly" assert switch_tab(ax, "Edit Pragmas"), "could not activate the Edit Pragmas tab" cvals, ivals = pragma_value_maps(ax) expected_cb = {n: 0 for n in PRAGMA_CHECKBOXES} expected_cb["Foreign Keys"] = 1 expected_cb["Automatic Index"] = 1 expected_inc = {"WAL Auto Checkpoint": "1000", "Journal Size Limit": "-1", "Max Page Count": "0", "User Version": "0"} assert cvals == expected_cb, f"pragma checkbox values {cvals} != {expected_cb}" assert ivals == expected_inc, f"pragma spin values {ivals} != {expected_inc}" assert kit.rb_value((tuple(sorted(cvals.items())), tuple(sorted(ivals.items()))), (tuple(sorted(expected_cb.items())), tuple(sorted(expected_inc.items())))) screenshot_assert( "states_test_pragma_values_inmemory", "The Edit Pragmas tab of DB Browser for SQLite with the in-memory database " "open. The pragma form lists Auto Vacuum, Automatic Index, Case Sensitive " "Like, Checkpoint Full FSYNC, Foreign Keys, Full FSYNC, Ignore Check " "Constraints, Journal Mode, Journal Size Limit, Locking Mode, Max Page " "Count, Page Size, Recursive Triggers, Secure Delete, Synchronous, Temp " "Store, User Version and WAL Auto Checkpoint. Exactly two checkboxes are " "ticked — Foreign Keys and Automatic Index — every other pragma checkbox is " "unticked, and the WAL Auto Checkpoint spin box reads 1000 while Journal " "Size Limit reads -1. Save and Cancel buttons sit at the bottom.", RESULTS_DIR) @pytest.mark.rb(depth=1, jump_kind="transition", expect="Foreign Keys checkbox AXValue 1->0->1") def test_pragma_foreign_keys_checkbox_toggle_round_trip(self, ax_with_reset): ax = ax_with_reset assert rb_enter_inmemory_db(ax), "in-memory database was not opened cleanly" assert switch_tab(ax, "Edit Pragmas"), "could not activate the Edit Pragmas tab" cb = checkbox_containing(ax, "Foreign Keys") assert cb is not None, "pragma checkbox 'Foreign Keys' not found" assert enabled(ax, cb), "pragma checkbox 'Foreign Keys' should be ENABLED with a DB" v0 = _i(cb_value(ax, cb)) assert v0 == 1, f"Foreign Keys should start CHECKED (1) for a new DB, got {v0!r}" assert ax.action(cb.id, "AXPress"), "AXPress on the Foreign Keys checkbox failed" time.sleep(0.5) v1 = _i(cb_value(ax, cb)) assert v1 == 0, f"Foreign Keys should be UNCHECKED (0) after one press, got {v1!r}" assert kit.rb_flip(v0, v1), "the Foreign Keys checkbox value never flipped" assert ax.action(cb.id, "AXPress"), "second AXPress on Foreign Keys failed" time.sleep(0.5) v2 = _i(cb_value(ax, cb)) assert v2 == 1, f"Foreign Keys should be CHECKED (1) again, got {v2!r}" # ═════════════════════════ ENABLED FLIPS (ST8/ST9/ST10) ════════════════════════ class TestEnabledFlips: @pytest.mark.rb(depth=1, jump_kind="transition", expect="Write Changes / Revert Changes AXEnabled False->True after a " "CREATE TABLE executed in the Execute SQL tab") def test_write_changes_enabled_flip_after_ddl(self, ax_with_reset): ax = ax_with_reset assert rb_enter_inmemory_db(ax), "in-memory database was not opened cleanly" wanted = ("Write Changes", "Revert Changes") bm = buttons_by_name(ax, wanted) assert set(bm) == set(wanted), f"toolbar buttons missing: {sorted(bm)}" before = (enabled(ax, bm["Write Changes"]), enabled(ax, bm["Revert Changes"])) assert before == (False, False), ( f"Write/Revert Changes must be DISABLED before any DDL, got {before}") assert switch_tab(ax, "Execute SQL"), "could not activate the Execute SQL tab" assert type_sql(ax, "CREATE TABLE t1(a INTEGER, b TEXT);"), "SQL editor not found" assert exec_sql(ax), "could not press the 'Execute SQL' button" bm2 = buttons_by_name(ax, wanted) assert set(bm2) == set(wanted), f"toolbar buttons missing after DDL: {sorted(bm2)}" after = (enabled(ax, bm2["Write Changes"]), enabled(ax, bm2["Revert Changes"])) assert after == (True, True), ( f"Write/Revert Changes must be ENABLED after a CREATE TABLE, got {after}") assert kit.rb_flip(before, after), "the pending-changes ENABLED state never flipped" @pytest.mark.rb(depth=1, jump_kind="transition", expect="Tools items and Edit▸Create Table.../Create Index... AXEnabled " "False->True after opening the in-memory database") def test_tools_and_edit_menu_enabled_flip_with_database(self, ax_with_reset): ax = ax_with_reset tools_before = menu_enabled_map(menu_item_map(ax, "Tools"), TOOLS_ITEMS) edit_before = menu_enabled_map(menu_item_map(ax, "Edit"), EDIT_DDL_ITEMS) assert tools_before == {n: False for n in TOOLS_ITEMS}, tools_before assert edit_before == {n: False for n in EDIT_DDL_ITEMS}, edit_before assert rb_enter_inmemory_db(ax), "in-memory database was not opened cleanly" tools_after = menu_enabled_map(menu_item_map(ax, "Tools"), TOOLS_ITEMS) edit_after = menu_enabled_map(menu_item_map(ax, "Edit"), EDIT_DDL_ITEMS) assert tools_after == {n: True for n in TOOLS_ITEMS}, ( f"every Tools item must be ENABLED with a database open, got {tools_after}") assert edit_after == {"Create Table...": True, "Create Index...": True, "Modify Table...": False, "Delete Table...": False}, edit_after before = (tuple(sorted(tools_before.items())), tuple(sorted(edit_before.items()))) after = (tuple(sorted(tools_after.items())), tuple(sorted(edit_after.items()))) assert kit.rb_flip(before, after), "no menu-item ENABLED state flipped" @pytest.mark.rb(depth=1, jump_kind="transition", expect="Clear Filters AXEnabled False->True when a filter is typed and " "back to False after pressing it") def test_clear_filters_enabled_round_trip(self, ax_with_reset): ax = ax_with_reset assert rb_enter_inmemory_db(ax), "in-memory database was not opened cleanly" assert switch_tab(ax, "Execute SQL"), "could not activate the Execute SQL tab" assert type_sql(ax, "CREATE TABLE nums(n INTEGER, label TEXT); " "INSERT INTO nums VALUES(10,'ten'),(20,'twenty'),(30,'thirty');") assert exec_sql(ax), "could not press the 'Execute SQL' button" assert switch_tab(ax, "Browse Data"), "could not activate the Browse Data tab" btn = find_button(ax, "Clear Filters") assert btn is not None, "button 'Clear Filters' not found on the Browse Data tab" before = enabled(ax, btn) assert before is False, "'Clear Filters' must be DISABLED with no filter typed" flt = ax.find(role="text_field", name="Filter in any column", max_results=1) assert flt, "text_field 'Filter in any column' not found" assert ax.set_value(flt[0].id, "twenty"), "could not set the filter text" time.sleep(1.7) after = enabled(ax, find_button(ax, "Clear Filters")) assert after is True, "'Clear Filters' must be ENABLED once a filter is typed" assert kit.rb_flip(before, after), "the Clear Filters ENABLED state never flipped" btn2 = find_button(ax, "Clear Filters") assert btn2 is not None assert ax.action(btn2.id, "AXPress"), "AXPress on 'Clear Filters' failed" time.sleep(1.7) assert enabled(ax, find_button(ax, "Clear Filters")) is False, ( "'Clear Filters' must be DISABLED again after clearing") flt2 = ax.find(role="text_field", name="Filter in any column", max_results=1) assert flt2, "the filter field disappeared" assert (ax.get(flt2[0].id, ["AXValue"]).get("AXValue") or "") == "", ( "the filter field should be emptied by 'Clear Filters'") # ═══════════════════════ MODE COMBOBOX + FOCUS (ST13/ST11) ═══════════════════════ class TestModeAndFocusState: @pytest.mark.rb(depth=0, jump_kind="transition", expect="SQL log source combobox AXTitle 'Application'->'User' via popup " "+ Up + Return") def test_sql_log_source_combobox_mode_flip(self, ax): combo = combo_named(ax, ("Application",)) assert combo is not None, "SQL log source combobox 'Application' not found" assert enabled(ax, combo), "the SQL log source combobox should be ENABLED" opts = option_texts(ax, combo) assert opts == ["User", "Application", "Error Log"], ( f"SQL log source options should be User/Application/Error Log, got {opts}") before = ax.get(combo.id, ["AXTitle"]).get("AXTitle") assert before == "Application", ( f"the fresh SQL log source should be 'Application', got {before!r}") combo_change(ax, combo, 126) after = ax.get(combo.id, ["AXTitle"]).get("AXTitle") assert after == "User", ( f"after popup + Up + Return the source should read 'User', got {after!r}") assert kit.rb_flip(before, after), "the SQL log source mode never changed" # ═════════════════════ DIALOG (ST4) + PREFERENCES (ST5) STATE ═════════════════════ class TestDialogAndPrefsState: @pytest.mark.rb(depth=2, jump_kind="transition", expect="Preferences tab-bar AXTitle 'General'->'Extensions' and the " "Extensions-tab extension checkboxes/buttons appear") def test_preferences_tab_bar_selection_indicator(self, ax_with_reset): ax = ax_with_reset prefs = rb_reach_preferences(ax) assert prefs is not None, "the Preferences/Settings window did not open" tab_before = selected_tab(ax, PREFS_TABS, root_id=prefs.id) assert tab_before == "General", ( f"the Preferences tab bar should open on 'General', got {tab_before!r}") ext_before = ext_widget_counts(ax, prefs.id) assert ext_before == (0, 0), ( f"no extension checkbox/button should be showing on the General page, " f"got {ext_before}") bar = tabbar(ax, PREFS_TABS, root_id=prefs.id) assert bar is not None, "the Preferences tab bar was not found" assert switch_tab(ax, "Extensions", root_id=bar.id), ( "could not AXPress the Preferences 'Extensions' tab") tab_after = selected_tab(ax, PREFS_TABS, root_id=prefs.id) assert tab_after == "Extensions", ( f"the Preferences tab-bar AXTitle should be 'Extensions', got {tab_after!r}") ext_after = ext_widget_counts(ax, prefs.id) assert ext_after[0] >= 2, ( f"the Extensions page should expose at least 2 extension checkboxes " f"(e.g. 'Disable Regular Expression extension', 'Allow loading extensions " f"from SQL code'), got {ext_after[0]}") assert ext_after[1] >= 2, ( f"the Extensions page should expose add/remove extension buttons, " f"got {ext_after[1]}") assert kit.rb_flip((tab_before, ext_before), (tab_after, ext_after)), ( "the Preferences tab selection never changed") screenshot_assert( "states_test_preferences_extensions_tab", "A separate Preferences window of DB Browser for SQLite, in front of the " "main window. Its tab strip reads General, Database, Data Browser, SQL, " "Extensions, Remote and 'Extensions' is now the selected tab, so the page " "shows the SQLite extension list with Add/Remove extension buttons and the " "checkboxes for disabling the Regular Expression extension and allowing " "extension loading from SQL code. Save, Cancel and Restore Defaults buttons " "are at the bottom.", RESULTS_DIR) assert close_scoped(ax, prefs, "Cancel"), ( "could not close the Preferences window with its own Cancel button")