| """AX STRUCTURE tests for `DB Browser for SQLite` (Qt6, net.sourceforge.sqlitebrowser). |
| |
| Every fact asserted here comes from the recon report's `## APP` / `## AX_TREE` / `## STRUCTURE` |
| sections (role census, tab-bar radio sets, toolbar button names, column headers, shape deltas). |
| Widgets are located by AXRole + visible AXTitle/AXValue (never by child index or tree path). |
| |
| Fresh-app starting state (per recon): main window on screen, NO DATABASE OPEN. |
| """ |
|
|
| import json |
| import os |
| import re |
| import subprocess |
| import time |
|
|
| import pytest |
| import rb_testgen_kit as kit |
|
|
| RESULTS_DIR = os.environ.get("RESULTS_DIR", os.path.dirname(os.path.abspath(__file__))) |
| 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"] |
|
|
|
|
| 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 open_menu(ax, top): |
| """Open a top-level app menu; returns its `menu` element or None.""" |
| 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 rb_reach_menu_item(ax, top, item_name): |
| """Open `top` and AXPress the menu item named exactly `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): |
| r = ax.find(role="radio", name=name, max_results=1) |
| if not r: |
| return False |
| ok = ax.action(r[0].id, "AXPress") |
| time.sleep(1.0) |
| return bool(ok) |
|
|
|
|
| def tabbar(ax, kids): |
| """The tab-bar `group` whose direct radio children == kids. Its AXTitle == selected tab.""" |
| for g in ax.find(role="group", max_results=250): |
| 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 names(els): |
| return [e.name for e in els if e.name] |
|
|
|
|
| def find_button(ax, name): |
| for b in ax.find(role="button", max_results=80): |
| if (b.name or "") == name: |
| return b |
| return None |
|
|
|
|
| |
| |
| |
|
|
| APP_MENU_TITLE = "DB Browser for SQLite" |
| MAIN_WINDOW_PREFIX = "db browser for sqlite" |
| TOP_MENUS = ["DB Browser for SQLite", "File", "Edit", "View", "Tools", "Help"] |
| STD_MENU_NAMES = {"apple", "file", "edit", "view", "tools", "help", "window"} |
|
|
| TOOLBAR_BUTTONS = ["New Database", "Open Database", "Write Changes", "Revert Changes", |
| "Undo", "Open Project", "Save Project", "Attach Database"] |
| STRUCTURE_TOOLBAR_BUTTONS = ["Create Table", "Create Index", "Modify Table"] |
|
|
| |
| STRUCTURE_COLUMNS = {"Name", "Object", "Type", "Schema", "Database"} |
| REMOTE_COLUMNS = {"Name", "Last modified", "Size", "Commit"} |
| PLOT_COLUMNS = {"Columns", "X", "Y1", "Y2", "Axis Type"} |
| TABLE_DIALOG_COLUMNS = {"Name", "Type", "NN", "PK", "AI", "U", |
| "Default", "Check", "Collation", "Foreign Key"} |
|
|
| |
| DOCK_LABEL_TEXTS = ["Mode:", "Show SQL submitted by", "Line type:", "Point shape:", "Identity"] |
|
|
| |
| EXEC_SQL_BUTTONS = {"Execute SQL", "Execute line", "Stop execution", "Open SQL file(s)", |
| "Save SQL file", "Save results", "New tab", "Find or replace", |
| "Un/comment block"} |
| |
| BROWSE_BUTTONS = {"New Record", "Save Table As", "New Data Browser", "Clear Filters", |
| "Clear Sorting", "Go to:"} |
| BROWSE_TEXT_FIELDS = ["Filter in any column", "Enter record number to browse"] |
| |
| PRAGMA_CHECKBOX_NAMES = ["Automatic Index", "Case Sensitive Like", "Checkpoint Full FSYNC", |
| "Foreign Keys", "Full FSYNC", "Ignore Check Constraints", |
| "Recursive Triggers", "Secure Delete"] |
| |
| TABLE_DIALOG_TABS = {"Fields", "Index Constraints", "Foreign Keys", "Check Constraints"} |
| TABLE_DIALOG_BUTTONS = {"Add", "Remove", "Move to top", "Move up", "Move down", |
| "Move to bottom", "OK", "Cancel"} |
| |
| PREFS_TABS = {"General", "Database", "Data Browser", "SQL", "Extensions", "Remote"} |
| PREFS_BUTTONS = {"Save", "Cancel", "Restore Defaults", "Import Settings", "Export Settings"} |
|
|
| |
| MIN_ROLE_COUNTS = [("button", 30), ("radio", 11), ("combobox", 5), ("checkbox", 4), |
| ("label", 40), ("text_area", 2), ("split_group", 1), ("menubutton", 1)] |
| ABSENT_ROLES = {"tabgroup", "toolbar", "outline"} |
| SQL_SUBTAB_RE = re.compile(r"^\s*SQL\s*\d+\s*$") |
|
|
|
|
| |
| |
| |
|
|
| def rb_ensure_ui(ax, tries=3): |
| """Best-effort reveal of the app's window before any window-dependent check. |
| |
| Recon REVEAL_STEPS: this is a regular windowed app whose main window is already on |
| screen at launch, so this normally returns immediately. `ensure_ui_visible` is used |
| when the helper exposes it (menu-bar/LSUIElement style recreations). |
| """ |
| wins = [] |
| for _ in range(tries): |
| wins = ax.find(role="window", max_results=10, max_depth=1) |
| if wins: |
| return wins |
| fn = getattr(ax, "ensure_ui_visible", None) |
| if callable(fn): |
| try: |
| fn() |
| except Exception: |
| pass |
| time.sleep(0.7) |
| return wins |
|
|
|
|
| def role_els(ax, role, root_id=None, limit=200, max_depth=None): |
| kw = {"role": role, "max_results": limit} |
| if root_id is not None: |
| kw["root_id"] = root_id |
| if max_depth is not None: |
| kw["max_depth"] = max_depth |
| try: |
| return list(ax.find(**kw) or []) |
| except Exception: |
| return [] |
|
|
|
|
| def role_name_set(ax, role, root_id=None, limit=200, max_depth=None): |
| return {(e.name or "").strip() for e in role_els(ax, role, root_id, limit, max_depth)} |
|
|
|
|
| def _norm_text(s): |
| s = (s or "").replace("…", "...") |
| s = re.sub(r"\s+", " ", s).strip().lower() |
| return s.rstrip(":").strip() |
|
|
|
|
| def _norm_role(r): |
| r = (r or "").strip().lower() |
| if r.startswith("ax"): |
| r = r[2:] |
| return r.replace("_", "").replace(" ", "").replace("-", "") |
|
|
|
|
| def el_value(ax, el): |
| try: |
| got = ax.get(el.id, ["AXValue"]) or {} |
| except Exception: |
| return "" |
| v = got.get("AXValue") if hasattr(got, "get") else got |
| return "" if v is None else str(v) |
|
|
|
|
| def label_texts(ax, limit=200): |
| """Normalised visible text of every `label`: AXTitle AND AXValue (either may carry it).""" |
| out = set() |
| for lb in role_els(ax, "label", limit=limit): |
| n = _norm_text(lb.name) |
| if n: |
| out.add(n) |
| v = _norm_text(el_value(ax, lb)) |
| if v: |
| out.add(v) |
| return out |
|
|
|
|
| def walk_tree_nodes(node, depth=1): |
| """Yield (level, role, name); the root element is level 1 (== number of levels).""" |
| if not isinstance(node, dict): |
| return |
| yield depth, (node.get("role") or ""), (node.get("name") or "") |
| for ch in (node.get("children") or []): |
| yield from walk_tree_nodes(ch, depth + 1) |
|
|
|
|
| def all_tab_bars(ax): |
| """Every `group` that owns direct `radio` children -> {tuple(radio names): group}.""" |
| out = {} |
| for g in role_els(ax, "group", limit=250): |
| ks = tuple((k.name or "").strip() |
| for k in role_els(ax, "radio", root_id=g.id, limit=12, max_depth=1)) |
| ks = tuple(k for k in ks if k) |
| if ks: |
| out[ks] = g |
| return out |
|
|
|
|
| def find_tab_bar(ax, kids): |
| """Tab-bar group whose direct radio children are exactly `kids` (order-tolerant).""" |
| g = tabbar(ax, list(kids)) |
| if g is not None: |
| return g |
| want = set(kids) |
| for ks, grp in all_tab_bars(ax).items(): |
| if set(ks) == want: |
| return grp |
| return None |
|
|
|
|
| def rb_press_button(ax, name, root_id=None, settle=1.2): |
| """AXPress the `button` whose AXTitle is exactly `name` (optionally scoped).""" |
| for b in role_els(ax, "button", root_id=root_id, limit=150): |
| if (b.name or "").strip() == name: |
| ok = ax.action(b.id, "AXPress") |
| time.sleep(settle) |
| return bool(ok) |
| return False |
|
|
|
|
| def rb_open_app_menu(ax): |
| """Open the application menu (title == app name; falls back to the non-standard menu).""" |
| m = open_menu(ax, APP_MENU_TITLE) |
| if m is not None: |
| return m |
| for mbi in role_els(ax, "menu_bar_item", limit=20): |
| n = (mbi.name or "").strip() |
| if not n or n.lower() in STD_MENU_NAMES: |
| continue |
| ax.action(mbi.id, "AXPress") |
| time.sleep(0.6) |
| got = ax.find(role="menu", root_id=mbi.id, max_results=1, max_depth=1) |
| if got: |
| return got[0] |
| _esc(1) |
| return None |
|
|
|
|
| def rb_open_preferences(ax): |
| """app menu -> Preferences.../Settings... (recon: that AXTitle is NOT stable -> keyword).""" |
| menu = rb_open_app_menu(ax) |
| if menu is None: |
| return False |
| for it in ax.find(role="menu_item", root_id=menu.id, max_results=60, max_depth=1): |
| low = (it.name or "").lower() |
| if not low or "services" in low: |
| continue |
| if "prefer" in low or "etting" in low: |
| ok = ax.action(it.id, "AXPress") |
| time.sleep(1.8) |
| return bool(ok) |
| _esc(2) |
| return False |
|
|
|
|
| def close_window_via_cancel(ax, win): |
| if win is None: |
| _esc(2) |
| return |
| c = ax.find(role="button", name="Cancel", root_id=win.id, max_results=3) |
| hit = [b for b in (c or []) if (b.name or "").strip() == "Cancel"] or list(c or []) |
| if hit: |
| ax.action(hit[0].id, "AXPress") |
| time.sleep(0.9) |
| else: |
| _esc(2) |
|
|
|
|
| def missing(expected, found): |
| return sorted(set(expected) - set(found)) |
|
|
|
|
| |
| |
| |
|
|
| class TestStructureGate: |
|
|
| @pytest.mark.rb(depth=0, jump_kind="none") |
| def test_gate_app_and_main_window(self, ax): |
| wins = rb_ensure_ui(ax) |
| root = ax.tree(max_depth=2) or {} |
| assert isinstance(root, dict) and root, "app is not reachable through the AX API" |
| assert _norm_role(root.get("role")) == "application", \ |
| f"AX root role is {root.get('role')!r}, expected an application element" |
| assert (root.get("children") or []), "application element exposes no AXChildren" |
|
|
| assert len(wins) == 1, \ |
| f"expected exactly 1 top-level window on a fresh app, got {len(wins)}: {names(wins)}" |
| title = (wins[0].name or "").strip() |
| assert title.lower().startswith(MAIN_WINDOW_PREFIX), \ |
| f"main window AXTitle {title!r} does not start with 'DB Browser for SQLite'" |
|
|
| screenshot_assert( |
| "structure_test_gate_app_and_main_window", |
| "Dark-themed application window titled 'DB Browser for SQLite'. Top toolbar row: New " |
| "Database, Open Database (with a dropdown chevron), Write Changes, Revert Changes, " |
| "Undo, Open Project, Save Project, Attach Database - the last six greyed out. Below " |
| "it a 4-tab bar: Database Structure (selected), Browse Data, Edit Pragmas, Execute " |
| "SQL. Left pane: an empty tree with Name / Type / Schema headers and Create Table, " |
| "Create Index, Modify Table buttons above it. Right side: an 'Edit Database Cell' " |
| "dock with a 'Mode:' dropdown showing Text, and a 'Remote' dock with an Identity " |
| "dropdown and DBHub.io / Local / Current Database tabs. Bottom-right dock tab strip: " |
| "SQL Log, Plot, DB Schema, Remote. Status bar bottom-right reads 'UTF-8'.", |
| RESULTS_DIR) |
|
|
| @pytest.mark.rb(depth=0, jump_kind="none") |
| def test_gate_menu_bar_items(self, ax): |
| rb_ensure_ui(ax) |
| bars = role_els(ax, "menu_bar", limit=5) |
| assert bars, "no menu_bar element exposed by the application" |
|
|
| found = role_name_set(ax, "menu_bar_item", root_id=bars[0].id, limit=30, max_depth=1) |
| if not any(n in found for n in TOP_MENUS): |
| found = role_name_set(ax, "menu_bar_item", limit=30) |
| assert not missing(TOP_MENUS, found), \ |
| f"menu bar is missing top-level menus {missing(TOP_MENUS, found)}; found {sorted(found)}" |
|
|
| @pytest.mark.rb(depth=0, jump_kind="none") |
| def test_gate_three_tab_bars(self, ax): |
| rb_ensure_ui(ax) |
| bars = all_tab_bars(ax) |
| sets = [set(k) for k in bars.keys()] |
| for expected, label in ((MAIN_TABS, "main view tab bar"), |
| (DOCK_TABS, "bottom dock tab bar"), |
| (REMOTE_TABS, "Remote sub-tab bar")): |
| assert set(expected) in sets, \ |
| f"{label} not found: no group owns exactly the radios {expected}; " \ |
| f"radio groups present: {sorted(tuple(sorted(s)) for s in sets)}" |
|
|
| main_bar = find_tab_bar(ax, MAIN_TABS) |
| assert main_bar is not None and (main_bar.name or "").strip() == "Database Structure", \ |
| f"fresh main tab bar should report AXTitle 'Database Structure', got " \ |
| f"{getattr(main_bar, 'name', None)!r}" |
|
|
| screenshot_assert( |
| "structure_test_gate_three_tab_bars", |
| "The DB Browser for SQLite window shows three tab strips at once: the main 4-tab bar " |
| "with Database Structure selected followed by Browse Data, Edit Pragmas, Execute SQL; " |
| "the bottom-right dock tab strip SQL Log / Plot / DB Schema / Remote with Remote " |
| "highlighted; and inside the Remote dock panel a sub-tab strip DBHub.io / Local / " |
| "Current Database with DBHub.io selected above an empty remote file list.", |
| RESULTS_DIR) |
|
|
| @pytest.mark.rb(depth=0, jump_kind="none") |
| def test_gate_toolbar_buttons(self, ax): |
| rb_ensure_ui(ax) |
| found = role_name_set(ax, "button", limit=150) |
| assert not missing(TOOLBAR_BUTTONS, found), \ |
| f"toolbar buttons missing: {missing(TOOLBAR_BUTTONS, found)}" |
| assert not missing(STRUCTURE_TOOLBAR_BUTTONS, found), \ |
| f"Database-Structure toolbar buttons missing: " \ |
| f"{missing(STRUCTURE_TOOLBAR_BUTTONS, found)}" |
|
|
| @pytest.mark.rb(depth=0, jump_kind="none") |
| def test_gate_dock_panel_widgets(self, ax): |
| rb_ensure_ui(ax) |
| texts = label_texts(ax) |
| want = [_norm_text(t) for t in DOCK_LABEL_TEXTS] |
| gone = [orig for orig, n in zip(DOCK_LABEL_TEXTS, want) if n not in texts] |
| assert not gone, f"dock panel signature labels missing: {gone}" |
|
|
| assert find_button(ax, "Clear") is not None, \ |
| "SQL Log dock button 'Clear' not found" |
|
|
| enc = [lb for lb in role_els(ax, "label", limit=200) |
| if _norm_text(lb.name) == "database encoding"] |
| assert enc, "status bar label 'Database encoding' not found" |
| blob = f"{enc[0].name or ''} {el_value(ax, enc[0])}" |
| assert "utf-8" in blob.lower(), \ |
| f"status bar encoding label should report UTF-8, got {blob!r}" |
|
|
| @pytest.mark.rb(depth=0, jump_kind="none") |
| def test_gate_table_column_headers(self, ax): |
| rb_ensure_ui(ax) |
| cols = role_name_set(ax, "column", limit=100) |
| for expected, label in ((STRUCTURE_COLUMNS, "Database Structure / DB Schema tree"), |
| (REMOTE_COLUMNS, "Remote file list"), |
| (PLOT_COLUMNS, "Plot column list")): |
| assert not missing(expected, cols), \ |
| f"{label} column headers missing {missing(expected, cols)}; " \ |
| f"columns present: {sorted(cols)}" |
|
|
|
|
|
|
| |
| |
| |
|
|
| class TestStructureShapeDeltas: |
|
|
| @pytest.mark.rb(depth=1, jump_kind="reach", |
| expect="Execute SQL tab page: 'Execute line' appears, 'Create Table' gone") |
| def test_shape_execute_sql_tab(self, ax): |
| rb_ensure_ui(ax) |
| before = kit.rb_showing(ax) |
| assert switch_tab(ax, "Execute SQL"), "could not AXPress the radio 'Execute SQL'" |
| after = kit.rb_showing(ax) |
|
|
| assert kit.rb_reach(before, after, |
| target="button|Execute line", |
| source="button|Create Table"), \ |
| "switching to Execute SQL did not surface 'Execute line' while retiring 'Create Table'" |
| assert len(after) > len(before), \ |
| f"Execute SQL page should ADD widgets: {len(before)} -> {len(after)} keys" |
|
|
| btns = role_name_set(ax, "button", limit=150) |
| assert not missing(EXEC_SQL_BUTTONS, btns), \ |
| f"Execute SQL toolbar buttons missing: {missing(EXEC_SQL_BUTTONS, btns)}" |
| checks = role_name_set(ax, "checkbox", limit=60) |
| assert "Find" in checks, f"Execute SQL 'Find' checkbox missing; checkboxes: {sorted(checks)}" |
|
|
| screenshot_assert( |
| "structure_test_shape_execute_sql_tab", |
| "The Execute SQL tab is now the selected tab in the main 4-tab bar (Database " |
| "Structure, Browse Data, Edit Pragmas, Execute SQL). The pane shows the SQL editor " |
| "toolbar with a green triangular Execute SQL button and Execute line (both greyed out " |
| "because no database is open) plus Stop execution, Open SQL file(s), Save SQL file, " |
| "New tab, Find or replace and Un/comment block; below it an empty SQL text editor and " |
| "an empty results area. The Create Table / Create Index / Modify Table tree toolbar of " |
| "the Database Structure page is no longer visible.", |
| RESULTS_DIR) |
|
|
| @pytest.mark.rb(depth=1, jump_kind="reach", |
| expect="Browse Data tab page: text_field 'Filter in any column' appears, " |
| "'Create Table' gone") |
| def test_shape_browse_data_tab(self, ax): |
| rb_ensure_ui(ax) |
| before = kit.rb_showing(ax) |
| assert switch_tab(ax, "Browse Data"), "could not AXPress the radio 'Browse Data'" |
| after = kit.rb_showing(ax) |
|
|
| assert kit.rb_reach(before, after, |
| target="text_field|Filter in any column", |
| source="button|Create Table"), \ |
| "Browse Data page did not expose the 'Filter in any column' field / still shows " \ |
| "'Create Table'" |
| assert len(after) > len(before), \ |
| f"Browse Data page should ADD widgets: {len(before)} -> {len(after)} keys" |
|
|
| fields = role_name_set(ax, "text_field", limit=60) |
| assert not missing(BROWSE_TEXT_FIELDS, fields), \ |
| f"Browse Data text fields missing: {missing(BROWSE_TEXT_FIELDS, fields)}; " \ |
| f"text fields: {sorted(fields)}" |
| btns = role_name_set(ax, "button", limit=150) |
| assert not missing(BROWSE_BUTTONS, btns), \ |
| f"Browse Data buttons missing: {missing(BROWSE_BUTTONS, btns)}" |
|
|
| @pytest.mark.rb(depth=1, jump_kind="reach", |
| expect="Edit Pragmas tab page: 'Secure Delete' pragma control appears, " |
| "'Create Table' gone, >= 30 new widgets") |
| def test_shape_edit_pragmas_tab(self, ax): |
| rb_ensure_ui(ax) |
| before = kit.rb_showing(ax) |
| assert switch_tab(ax, "Edit Pragmas"), "could not AXPress the radio 'Edit Pragmas'" |
| after = kit.rb_showing(ax) |
|
|
| assert kit.rb_reach(before, after, |
| target="Secure Delete", |
| source="button|Create Table"), \ |
| "Edit Pragmas page did not surface the 'Secure Delete' pragma control" |
| assert len(after) - len(before) >= 30, \ |
| f"Edit Pragmas page should add >= 30 widgets, got {len(after) - len(before)} " \ |
| f"({len(before)} -> {len(after)})" |
|
|
| boxes = [(c.name or "") for c in role_els(ax, "checkbox", limit=80)] |
| pragma_boxes = [n for n in boxes if any(p in n for p in PRAGMA_CHECKBOX_NAMES)] |
| assert len(pragma_boxes) >= 8, \ |
| f"expected >= 8 pragma checkboxes (HTML AXTitles matched by substring), " \ |
| f"found {len(pragma_boxes)}" |
|
|
| incs = role_els(ax, "incrementor", limit=40) |
| assert len(incs) >= 4, f"expected >= 4 pragma incrementors, found {len(incs)}" |
|
|
| btns = role_name_set(ax, "button", limit=150) |
| assert not missing(["Save", "Cancel"], btns), \ |
| f"Edit Pragmas Save/Cancel buttons missing: {missing(['Save', 'Cancel'], btns)}" |
|
|
| @pytest.mark.rb(depth=1, jump_kind="reach", |
| expect="dock tab Remote -> DB Schema: group|DB Schema appears, group|Remote " |
| "gone, dock tab bar AXTitle == 'DB Schema'") |
| def test_shape_dock_tab_db_schema(self, ax): |
| rb_ensure_ui(ax) |
| before = kit.rb_showing(ax) |
| assert switch_tab(ax, "DB Schema"), "could not AXPress the dock radio 'DB Schema'" |
| after = kit.rb_showing(ax) |
|
|
| assert kit.rb_reach(before, after, |
| target="group|DB Schema", |
| source="group|Remote"), \ |
| "dock tab bar did not move from Remote to DB Schema" |
|
|
| bar = find_tab_bar(ax, DOCK_TABS) |
| assert bar is not None, f"dock tab bar with radios {DOCK_TABS} disappeared" |
| assert (bar.name or "").strip() == "DB Schema", \ |
| f"dock tab bar AXTitle should be 'DB Schema', got {bar.name!r}" |
|
|
| screenshot_assert( |
| "structure_test_shape_dock_tab_db_schema", |
| "The bottom-right dock of the DB Browser for SQLite window now shows a schema tree " |
| "with the column headers Name / Object / Type / Schema / Database instead of the " |
| "Remote panel, and 'DB Schema' is the highlighted tab in the SQL Log / Plot / DB " |
| "Schema / Remote tab strip.", |
| RESULTS_DIR) |
|
|
| @pytest.mark.rb(depth=2, jump_kind="reach", |
| expect="dock tab bar walks Remote->DB Schema->Plot->SQL Log; group|SQL Log " |
| "appears, group|Plot gone") |
| def test_shape_dock_tab_plot_then_sql_log(self, ax): |
| rb_ensure_ui(ax) |
| assert switch_tab(ax, "DB Schema"), "could not AXPress the dock radio 'DB Schema'" |
|
|
| before1 = kit.rb_showing(ax) |
| assert switch_tab(ax, "Plot"), "could not AXPress the dock radio 'Plot'" |
| after1 = kit.rb_showing(ax) |
| assert kit.rb_reach(before1, after1, |
| target="group|Plot", |
| source="group|DB Schema"), \ |
| "dock tab bar did not move from DB Schema to Plot" |
|
|
| before2 = kit.rb_showing(ax) |
| assert switch_tab(ax, "SQL Log"), "could not AXPress the dock radio 'SQL Log'" |
| after2 = kit.rb_showing(ax) |
| assert kit.rb_reach(before2, after2, |
| target="group|SQL Log", |
| source="group|Plot"), \ |
| "dock tab bar did not move from Plot to SQL Log" |
|
|
| bar = find_tab_bar(ax, DOCK_TABS) |
| assert bar is not None, f"dock tab bar with radios {DOCK_TABS} disappeared" |
| assert (bar.name or "").strip() == "SQL Log", \ |
| f"dock tab bar AXTitle should be 'SQL Log' after the walk, got {bar.name!r}" |
|
|
| @pytest.mark.rb(depth=1, jump_kind="reach", |
| expect="File > New In-Memory Database: window|Edit table definition appears, " |
| "2 windows, main title gains '- In-Memory database'") |
| def test_shape_new_inmemory_db_opens_table_dialog(self, ax): |
| rb_ensure_ui(ax) |
| before = kit.rb_showing(ax) |
| try: |
| assert rb_reach_menu_item(ax, "File", "New In-Memory Database"), \ |
| "could not press the menu item File > New In-Memory Database" |
| after = kit.rb_showing(ax) |
|
|
| assert kit.rb_reach(before, after, target="window|Edit table definition"), \ |
| "'New In-Memory Database' did not open the 'Edit table definition' window" |
|
|
| wins = ax.find(role="window", max_results=10, max_depth=1) |
| assert len(wins) == 2, \ |
| f"expected 2 top-level windows (main + dialog), got {len(wins)}: {names(wins)}" |
|
|
| mains = [w for w in wins |
| if (w.name or "").strip().lower().startswith(MAIN_WINDOW_PREFIX)] |
| assert mains, f"main window vanished; windows: {names(wins)}" |
| main_title = (mains[0].name or "").strip().lower() |
| assert "in-memory database" in main_title, \ |
| f"main window title should become 'DB Browser for SQLite - In-Memory database', " \ |
| f"got {mains[0].name!r}" |
|
|
| dlg = find_window(ax, "Edit table definition") |
| assert dlg is not None, "no window titled 'Edit table definition'" |
|
|
| fields = role_name_set(ax, "text_field", root_id=dlg.id, limit=40) |
| assert "Table" in fields, \ |
| f"dialog is missing the 'Table' name field; text fields: {sorted(fields)}" |
| boxes = role_name_set(ax, "checkbox", root_id=dlg.id, limit=40) |
| assert "Advanced" in boxes, \ |
| f"dialog is missing the 'Advanced' checkbox; checkboxes: {sorted(boxes)}" |
|
|
| radios = role_name_set(ax, "radio", root_id=dlg.id, limit=20) |
| assert radios == TABLE_DIALOG_TABS, \ |
| f"dialog sub-tabs should be {sorted(TABLE_DIALOG_TABS)}, got {sorted(radios)}" |
|
|
| btns = role_name_set(ax, "button", root_id=dlg.id, limit=60) |
| assert not missing(TABLE_DIALOG_BUTTONS, btns), \ |
| f"dialog buttons missing: {missing(TABLE_DIALOG_BUTTONS, btns)}" |
|
|
| cols = role_name_set(ax, "column", root_id=dlg.id, limit=60) |
| assert not missing(TABLE_DIALOG_COLUMNS, cols), \ |
| f"dialog field-grid headers missing: {missing(TABLE_DIALOG_COLUMNS, cols)}; " \ |
| f"columns: {sorted(cols)}" |
|
|
| screenshot_assert( |
| "structure_test_shape_new_inmemory_db_opens_table_dialog", |
| "A modal window titled 'Edit table definition' is open in front of the DB Browser " |
| "for SQLite window: it has a 'Table' name field, an 'Advanced' checkbox, a field " |
| "grid whose headers read Name, Type, NN, PK, AI, U, Default, Check, Collation, " |
| "Foreign Key, Add / Remove / move-up / move-down buttons, a read-only SQL box " |
| "showing CREATE TABLE \"\" ( ); , the sub-tabs Fields / Index Constraints / " |
| "Foreign Keys / Check Constraints, and OK / Cancel buttons. The main window title " |
| "behind it now reads 'DB Browser for SQLite - In-Memory database'.", |
| RESULTS_DIR) |
| finally: |
| close_window_via_cancel(ax, find_window(ax, "Edit table definition")) |
|
|
| @pytest.mark.rb(depth=1, jump_kind="reach", |
| expect="SQL sub-tab 'SQL 1' created by the New tab button") |
| def test_shape_execute_sql_new_tab_creates_sql1(self, ax): |
| rb_ensure_ui(ax) |
| assert switch_tab(ax, "Execute SQL"), "could not AXPress the radio 'Execute SQL'" |
|
|
| pre = [n for n in role_name_set(ax, "radio", limit=60) if SQL_SUBTAB_RE.match(n or "")] |
| assert not pre, f"a SQL sub-tab already exists before pressing 'New tab': {sorted(pre)}" |
|
|
| before = kit.rb_showing(ax) |
| assert rb_press_button(ax, "New tab", settle=1.4), \ |
| "could not AXPress the Execute SQL button 'New tab'" |
| after = kit.rb_showing(ax) |
|
|
| assert kit.rb_reach(before, after, target="radio|SQL 1"), \ |
| "'New tab' did not create the SQL sub-tab 'SQL 1'" |
|
|
| bar = find_tab_bar(ax, ["SQL 1"]) |
| assert bar is not None, "no tab bar owning exactly the radio 'SQL 1' was created" |
| assert (bar.name or "").strip() == "SQL 1", \ |
| f"SQL sub-tab bar AXTitle should be 'SQL 1', got {bar.name!r}" |
|
|
| @pytest.mark.rb(depth=1, jump_kind="reach", |
| expect="app menu Preferences.../Settings... opens window|Preferences with the " |
| "6 tab radios General..Remote as a new top-level surface") |
| def test_shape_preferences_window_is_new_surface(self, ax): |
| rb_ensure_ui(ax) |
| before = kit.rb_showing(ax) |
| win = None |
| try: |
| assert rb_open_preferences(ax), \ |
| "could not press Preferences.../Settings... in the application menu" |
| after = kit.rb_showing(ax) |
|
|
| assert kit.rb_reach(before, after, target="window|Preferences"), \ |
| "no new 'Preferences' window appeared after the app-menu item was pressed" |
|
|
| win = find_window(ax, "Preferences") or find_window(ax, "Settings") |
| assert win is not None, "no top-level window titled Preferences / Settings" |
|
|
| radios = role_name_set(ax, "radio", root_id=win.id, limit=30) |
| assert radios == PREFS_TABS, \ |
| f"Preferences tab radios should be {sorted(PREFS_TABS)}, got {sorted(radios)}" |
|
|
| btns = role_name_set(ax, "button", root_id=win.id, limit=80) |
| assert not missing(PREFS_BUTTONS, btns), \ |
| f"Preferences buttons missing: {missing(PREFS_BUTTONS, btns)}" |
|
|
| screenshot_assert( |
| "structure_test_shape_preferences_window_is_new_surface", |
| "A separate 'Preferences' window is open with a tab strip reading General, " |
| "Database, Data Browser, SQL, Extensions, Remote (General selected). The General " |
| "page shows a Language dropdown reading 'English (United States) [System " |
| "Language]', Font size 13, Max Recent Files 5, several toolbar-style dropdowns, " |
| "and Save / Cancel / Restore Defaults buttons at the bottom.", |
| RESULTS_DIR) |
| finally: |
| close_window_via_cancel(ax, win or find_window(ax, "Preferences")) |
|
|
