| """AX TEXT-CONTENT lane — DB Browser for SQLite (Qt6). |
| |
| Every string asserted here is taken verbatim from recon.md `## TEXT` (T1..T6), with window titles |
| from T2, column-header texts from T3 and interaction->text deltas from T4/T5. |
| |
| Ground rules honoured by this module: |
| * Visible text of this app lives in `label` elements whose AXTitle is EMPTY and whose AXValue |
| carries the string -> always read via `ax.get(el.id, ["AXValue"])`. |
| * Column headers are `column`-role elements read via `el.name`. |
| * A fresh app has NO DATABASE open; the deterministic, dialog-free way to get one is |
| `File > New In-Memory Database` + dismissing the auto-opened "Edit table definition" modal |
| with that window's OWN scoped Cancel button (recon REVEAL_STEPS). |
| * Build-specific text is NEVER asserted: the About version number |
| ("... Version 3.13.99 (Aug 11 2026) ... Last commit hash ...") and the `in Nms` / `Took 0ms` |
| timing digits are forbidden. Only the stable prefixes/sentences are asserted. |
| """ |
|
|
| 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__))) |
| COUNTER_RE = re.compile(r"^\s*\d+\s*-\s*\d+\s+of\s+\d+\s*$") |
|
|
|
|
| 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 _keystroke(text): |
| subprocess.run(["osascript", "-e", |
| 'tell application "System Events" to keystroke ' + json.dumps(text)], |
| capture_output=True) |
|
|
|
|
| def label_values(ax, root_id=None, limit=350): |
| """All non-empty AXValue strings of `label` elements.""" |
| out = [] |
| for l in ax.find(role="label", max_results=limit, root_id=root_id): |
| v = ax.get(l.id, ["AXValue"]).get("AXValue") |
| if isinstance(v, str) and v.strip(): |
| out.append(v) |
| return out |
|
|
|
|
| def label_with(ax, needle, root_id=None): |
| for v in label_values(ax, root_id=root_id): |
| if needle in v: |
| return v |
| return None |
|
|
|
|
| def column_names(ax, root_id=None): |
| return [c.name for c in ax.find(role="column", max_results=120, root_id=root_id) if c.name] |
|
|
|
|
| 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 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 main_window(ax): |
| wid = ax.get_main_window() |
| return None if wid is None else ax.get(wid, ["AXTitle"]).get("AXTitle") |
|
|
|
|
| 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 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 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 |
|
|
|
|
| def run_sql(ax, sql): |
| switch_tab(ax, "Execute SQL") |
| e = sql_editor(ax) |
| assert e is not None, "SQL editor not found" |
| ax.click_element_cg(e.id) |
| time.sleep(0.35) |
| subprocess.run(["osascript", "-e", |
| 'tell application "System Events" to keystroke "a" using command down'], |
| capture_output=True) |
| time.sleep(0.25) |
| _keystroke(sql) |
| time.sleep(0.5) |
| b = find_button(ax, "Execute SQL") |
| assert b is not None and enabled(ax, b), "Execute SQL button not enabled" |
| ax.action(b.id, "AXPress") |
| time.sleep(1.9) |
|
|
|
|
| def result_cells(ax): |
| cols, cells = [], [] |
| for t in ax.find(role="table", max_results=10): |
| if (t.name or "") == "search result": |
| continue |
| ch = (ax.tree(max_depth=3, root_id=t.id).get("children") or []) |
| c = [x.get("name") for x in ch if x.get("role") == "column"] |
| v = [x.get("name") for x in ch if x.get("role") == "label"] |
| if c or v: |
| cols, cells = c, v |
| return cols, cells |
|
|
|
|
| def exec_msg(ax): |
| for t in ax.find(role="text_area", max_results=15): |
| v = str(ax.get(t.id, ["AXValue"]).get("AXValue") or "") |
| if v.startswith("Execution finished"): |
| return v |
| return "" |
|
|
|
|
| def record_counter(ax): |
| """MUST use the regex — a plain ' of ' test also matches |
| 'Identification of the cell currently in the editor'.""" |
| for l in ax.find(role="label", max_results=350): |
| v = str(ax.get(l.id, ["AXValue"]).get("AXValue") or "") |
| if COUNTER_RE.match(v): |
| return v.strip() |
| return None |
|
|
|
|
| def grid_cell_named(ax, name): |
| for t in ax.find(role="table", max_results=10): |
| if (t.name or "") == "search result": |
| continue |
| for c in ax.find(role="label", root_id=t.id, max_results=40, max_depth=1): |
| if (c.name or "") == name: |
| return c |
| return None |
|
|
|
|
| |
| |
| |
|
|
| def ensure_ui(ax): |
| """Reveal the app's UI before any window/text inspection. |
| |
| recon REVEAL_STEPS: this is a REGULAR windowed app — the main window is already on screen at |
| launch (no status item / LSUIElement path). So the only reveal needed is to raise it; a |
| recreation that hides the window behind another surface still reports truthfully because the |
| assertions below run against whatever `get_main_window()` yields. |
| """ |
| wid = ax.get_main_window() |
| if wid is not None: |
| try: |
| ax.action(wid, "AXRaise") |
| except Exception: |
| pass |
| time.sleep(0.2) |
| return wid |
|
|
|
|
| def label_strings(ax, root_id=None, limit=350): |
| """AXValue *and* AXTitle strings of `label` elements. |
| |
| The reference puts dialog prose in AXValue; a differently-built recreation may legitimately |
| expose the same visible text as the label's AXTitle, so dialog scans consider both. |
| """ |
| out = [] |
| for l in ax.find(role="label", max_results=limit, root_id=root_id): |
| v = ax.get(l.id, ["AXValue"]).get("AXValue") |
| if isinstance(v, str) and v.strip(): |
| out.append(v) |
| if l.name and l.name.strip(): |
| out.append(l.name) |
| return out |
|
|
|
|
| def text_area_values(ax, root_id=None): |
| out = [] |
| for t in ax.find(role="text_area", max_results=15, root_id=root_id): |
| v = ax.get(t.id, ["AXValue"]).get("AXValue") |
| out.append(v if isinstance(v, str) else "") |
| return out |
|
|
|
|
| def text_area_containing(ax, needle): |
| for v in text_area_values(ax): |
| if needle in v: |
| return v |
| return "" |
|
|
|
|
| def press_menu_item_startswith(ax, top, prefix): |
| """Same scoping discipline as rb_reach_menu_item, but matches on a title PREFIX. |
| |
| Needed for the app menu's About item (recon MENUS: 'About DB Browser for SQLite').""" |
| 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 "").startswith(prefix): |
| ok = ax.action(it.id, "AXPress") |
| time.sleep(1.4) |
| return bool(ok) |
| _esc(2) |
| return False |
|
|
|
|
| def dialog_containing_text(ax, needle): |
| """Locate a secondary surface by its VISIBLE TEXT (never by index/path). |
| |
| Returns (window_element, matching_text) or (None, None).""" |
| for w in ax.find(role="window", max_results=10, max_depth=1): |
| if (w.name or "").startswith("DB Browser for SQLite"): |
| continue |
| for v in label_strings(ax, root_id=w.id, limit=80): |
| if needle in v: |
| return w, v |
| return None, None |
|
|
|
|
| def close_dialog(ax, win, button_name="Cancel"): |
| """Always dismiss with the dialog's OWN scoped button (recon: never a global Cancel).""" |
| if win is None: |
| return False |
| b = find_button(ax, button_name, root_id=win.id) |
| if b is None: |
| _esc(1) |
| return False |
| ok = ax.action(b.id, "AXPress") |
| time.sleep(1.0) |
| return bool(ok) |
|
|
|
|
| def table_grid(ax, want_col=None): |
| """result_cells() but able to prefer the grid that owns a given column header.""" |
| best = ([], []) |
| for t in ax.find(role="table", max_results=10): |
| if (t.name or "") == "search result": |
| continue |
| ch = (ax.tree(max_depth=3, root_id=t.id).get("children") or []) |
| c = [x.get("name") for x in ch if x.get("role") == "column"] |
| v = [x.get("name") for x in ch if x.get("role") == "label"] |
| if want_col is not None and want_col in c: |
| return c, v |
| if c or v: |
| best = (c, v) |
| return best |
|
|
|
|
| |
|
|
| T1_STATIC_LABELS = [ |
| "Mode:", |
| "Show SQL submitted by", |
| "Line type:", |
| "Point shape:", |
| "Identity", |
| "Identification of the cell currently in the editor", |
| "Type and size of data currently in table", |
| ] |
|
|
| STRUCTURE_HEADERS = ["Name", "Object", "Type", "Schema", "Database"] |
| REMOTE_HEADERS = ["Name", "Last modified", "Size", "Commit"] |
| PLOT_HEADERS = ["Columns", "X", "Y1", "Y2", "Axis Type"] |
| TABLE_DIALOG_HEADERS = ["Name", "Type", "NN", "PK", "AI", "U", |
| "Default", "Check", "Collation", "Foreign Key"] |
|
|
| INTEGRITY_TEXT = ("This action will open a new SQL tab for running:\n" |
| "PRAGMA integrity_check;\n" |
| "Press Help for opening the corresponding SQLite reference page.") |
|
|
| ABOUT_DESC = ("DB Browser for SQLite is an open source, freeware visual tool used to create, " |
| "design and edit SQLite") |
|
|
| RESULTS_HELP = "Results of the last executed statements." |
|
|
| SQL_LOG_HEAD = "PRAGMA foreign_keys = '1';" |
|
|
| PRAGMA_DISPLAY_LABELS = [ |
| "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", "WAL Auto Checkpoint", |
| ] |
|
|
| MAKE_NUMS = ("CREATE TABLE nums(n INTEGER, label TEXT); " |
| "INSERT INTO nums VALUES(10,'ten'),(20,'twenty'),(30,'thirty');") |
|
|
|
|
| class TestStaticText: |
| """T1/T3 — text that must be readable on a freshly launched app (NO database).""" |
|
|
| @pytest.mark.rb(depth=0, jump_kind="value", |
| expect="labels 'Mode:', 'Show SQL submitted by', 'Line type:', " |
| "'Point shape:', 'Identity', 'Identification of the cell currently in " |
| "the editor', 'Type and size of data currently in table' all present " |
| "with those exact AXValues") |
| def test_static_label_texts_on_fresh_app(self, ax): |
| ensure_ui(ax) |
| values = label_values(ax) |
|
|
| |
| assert values, "no `label` element on the fresh app exposes a non-empty AXValue" |
| assert all(v.strip() for v in values), "collected a blank label value" |
|
|
| found = set(values) |
| missing = [s for s in T1_STATIC_LABELS if s not in found] |
| assert not missing, f"missing exact label AXValues {missing}; observed={sorted(found)}" |
|
|
| |
| assert kit.rb_value(values, "Show SQL submitted by"), \ |
| f"'Show SQL submitted by' not among label values: {sorted(found)}" |
|
|
| |
| for s in T1_STATIC_LABELS: |
| actual = [v for v in values if v == s][0] |
| assert len(actual) == len(s), f"length mismatch for {s!r}: {len(actual)} != {len(s)}" |
|
|
| screenshot_assert( |
| "text_test_static_labels_fresh", |
| "Dark-themed window titled 'DB Browser for SQLite' on a fresh launch with no database. " |
| "The 'Edit Database Cell' dock on the right shows the caption 'Mode:' next to a " |
| "dropdown reading Text plus the two placeholder lines 'Identification of the cell " |
| "currently in the editor' and 'Type and size of data currently in table'. The SQL Log " |
| "dock shows 'Show SQL submitted by' with an 'Application' dropdown and a Clear button; " |
| "the Plot dock shows 'Line type:' and 'Point shape:'; the Remote dock shows 'Identity' " |
| "with a 'Select an identity to connect' dropdown and DBHub.io / Local / Current " |
| "Database tabs. Main tab bar reads Database Structure (selected), Browse Data, Edit " |
| "Pragmas, Execute SQL. Status bar bottom-right reads 'UTF-8'.", |
| RESULTS_DIR) |
|
|
| @pytest.mark.rb(depth=0, jump_kind="value", |
| expect="status-bar label named 'Database encoding' has AXValue 'UTF-8'") |
| def test_status_bar_database_encoding_utf8(self, ax): |
| ensure_ui(ax) |
| target = None |
| for l in ax.find(role="label", max_results=350): |
| if (l.name or "") == "Database encoding": |
| target = l |
| break |
| assert target is not None, "status-bar label named 'Database encoding' not found" |
|
|
| value = ax.get(target.id, ["AXValue"]).get("AXValue") |
| assert isinstance(value, str) and value.strip(), \ |
| f"status bar text is empty: {value!r}" |
| assert value == "UTF-8", f"expected status bar 'UTF-8', got {value!r}" |
| assert kit.rb_value(value, "UTF-8"), f"rb_value rejected status bar text {value!r}" |
|
|
| @pytest.mark.rb(depth=0, jump_kind="value", |
| expect="column headers include the structure-tree set " |
| "{Name,Object,Type,Schema,Database}, the remote set " |
| "{Name,Last modified,Size,Commit} and the plot set " |
| "{Columns,X,Y1,Y2,Axis Type}") |
| def test_column_header_texts_on_fresh_app(self, ax): |
| ensure_ui(ax) |
| headers = column_names(ax) |
| assert headers, "no `column` element exposes a header name" |
| got = set(headers) |
|
|
| assert set(STRUCTURE_HEADERS).issubset(got), \ |
| f"structure-tree headers missing {sorted(set(STRUCTURE_HEADERS) - got)}; got {sorted(got)}" |
| assert set(REMOTE_HEADERS).issubset(got), \ |
| f"remote-list headers missing {sorted(set(REMOTE_HEADERS) - got)}; got {sorted(got)}" |
| assert set(PLOT_HEADERS).issubset(got), \ |
| f"plot-list headers missing {sorted(set(PLOT_HEADERS) - got)}; got {sorted(got)}" |
|
|
| assert kit.rb_value(headers, "Axis Type"), \ |
| f"'Axis Type' header not observed; got {sorted(got)}" |
|
|
|
|
| class TestWindowTitleText: |
| """T2 — window-title text, fresh and after the in-memory database is created.""" |
|
|
| @pytest.mark.rb(depth=1, jump_kind="value", |
| expect="window title 'DB Browser for SQLite' -> " |
| "'DB Browser for SQLite - In-Memory database'") |
| def test_main_window_title_fresh_and_after_opening_database(self, ax): |
| ensure_ui(ax) |
| before = main_window(ax) |
| assert before == "DB Browser for SQLite", \ |
| f"fresh main window title should be 'DB Browser for SQLite', got {before!r}" |
| assert "DB Browser for SQLite" in (before or ""), "frame title lacks the app name" |
|
|
| assert rb_enter_inmemory_db(ax), "'Edit table definition' modal was not dismissed" |
|
|
| after = main_window(ax) |
| assert after != before, f"window title did not change after creating a database: {after!r}" |
| assert after == "DB Browser for SQLite - In-Memory database", \ |
| f"expected '<document> - <app>' title format, got {after!r}" |
| assert kit.rb_value(after, "DB Browser for SQLite - In-Memory database"), \ |
| f"rb_value rejected the title {after!r}" |
|
|
|
|
| class TestPanelText: |
| """T5 — long prose owned by docks / panels (needs a database).""" |
|
|
|
|
| @pytest.mark.rb(depth=1, jump_kind="value", |
| expect="SQL Log dock text_area AXValue starts with \"PRAGMA foreign_keys = " |
| "'1';\" and lists PRAGMA database_list and the sqlite_master query") |
| def test_sql_log_shows_startup_pragmas(self, ax): |
| ensure_ui(ax) |
| assert rb_enter_inmemory_db(ax), "could not create the in-memory database" |
| assert switch_tab(ax, "SQL Log"), "SQL Log dock tab radio not pressable" |
|
|
| log = text_area_containing(ax, "PRAGMA") |
| assert log, f"no text_area holds the SQL log; panes={text_area_values(ax)!r}" |
| assert log.startswith(SQL_LOG_HEAD), \ |
| f"SQL log should start with {SQL_LOG_HEAD!r}, got {log[:80]!r}" |
| assert "PRAGMA database_list;" in log, f"SQL log lacks PRAGMA database_list: {log!r}" |
| assert 'SELECT type,name,sql,tbl_name FROM "main".sqlite_master;' in log, \ |
| f"SQL log lacks the sqlite_master query: {log!r}" |
| assert kit.rb_value(log, "PRAGMA database_list;"), f"rb_value rejected the log {log[:80]!r}" |
|
|
| @pytest.mark.rb(depth=1, jump_kind="value", |
| expect="Edit Database Cell shows 'No cell active.' and " |
| "'Type: NULL; Size: 0 bytes' once a database is open") |
| def test_cell_editor_status_labels_with_database(self, ax): |
| ensure_ui(ax) |
| before = label_values(ax) |
| assert "Identification of the cell currently in the editor" in before, \ |
| ("fresh cell-editor panel should carry the placeholder " |
| f"'Identification of the cell currently in the editor'; got {sorted(set(before))}") |
|
|
| assert rb_enter_inmemory_db(ax), "could not create the in-memory database" |
| after = label_values(ax) |
|
|
| assert "No cell active." in after, \ |
| f"cell editor should read 'No cell active.' with a DB open; got {sorted(set(after))}" |
| assert "Type: NULL; Size: 0 bytes" in after, \ |
| f"cell editor should read 'Type: NULL; Size: 0 bytes'; got {sorted(set(after))}" |
| assert set(after) != set(before), "no cell-editor text changed after opening the database" |
| assert kit.rb_value(after, "Type: NULL; Size: 0 bytes"), \ |
| "rb_value rejected the cell-editor type/size line" |
|
|
|
|
| class TestDialogText: |
| """Text that only exists on a surface this test opened (depth >= 1).""" |
|
|
|
|
| @pytest.mark.rb(depth=1, jump_kind="value", |
| expect='About window shows "DB Browser for SQLite is an open source, freeware ' |
| 'visual tool used to create, design and edit SQLite" and a label ' |
| 'containing "DB Browser for SQLite Version"') |
| def test_about_dialog_description_text(self, ax): |
| ensure_ui(ax) |
| assert press_menu_item_startswith(ax, "DB Browser for SQLite", "About"), \ |
| "app menu > About ... could not be pressed" |
|
|
| win = find_window(ax, "About DB Browser for SQLite") |
| try: |
| assert win is not None, "no 'About DB Browser for SQLite' window appeared" |
| assert (win.name or "") == "About DB Browser for SQLite", \ |
| f"About window title should be 'About DB Browser for SQLite', got {win.name!r}" |
|
|
| texts = label_strings(ax, root_id=win.id, limit=60) |
| assert any(ABOUT_DESC in t for t in texts), \ |
| f"About window lacks the description sentence; observed={texts!r}" |
| |
| assert any("DB Browser for SQLite Version" in t for t in texts), \ |
| f"About window lacks a 'DB Browser for SQLite Version' line; observed={texts!r}" |
| assert kit.rb_value(texts, ABOUT_DESC), "rb_value rejected the About description" |
|
|
| screenshot_assert( |
| "text_test_about_dialog", |
| "A small window titled 'About DB Browser for SQLite' showing the app logo image, a " |
| "version line beginning 'DB Browser for SQLite Version', the sentence 'DB Browser " |
| "for SQLite is an open source, freeware visual tool used to create, design and " |
| "edit SQLite', and a Close button.", |
| RESULTS_DIR) |
| finally: |
| close_dialog(ax, win, "Close") |
|
|
| @pytest.mark.rb(depth=1, jump_kind="value", |
| expect="Edit table definition dialog exposes column headers Name,Type,NN,PK," |
| "AI,U,Default,Check,Collation,Foreign Key") |
| def test_dialog_column_header_texts(self, ax): |
| ensure_ui(ax) |
| |
| assert rb_reach_menu_item(ax, "File", "New In-Memory Database"), \ |
| "File > New In-Memory Database could not be pressed" |
|
|
| dialog = find_window(ax, "Edit table definition") |
| try: |
| assert dialog is not None, "'Edit table definition' dialog did not appear" |
| headers = column_names(ax, root_id=dialog.id) |
| assert headers, "the dialog's field grid exposes no column header text" |
| got = set(headers) |
| assert set(TABLE_DIALOG_HEADERS).issubset(got), \ |
| (f"dialog headers missing {sorted(set(TABLE_DIALOG_HEADERS) - got)}; " |
| f"got {headers!r}") |
| assert kit.rb_value(headers, "Collation"), \ |
| f"'Collation' header not observed; got {headers!r}" |
| finally: |
| close_dialog(ax, dialog, "Cancel") |
|
|
|
|
| class TestComputedText: |
| """T4/T5 — text PRODUCED by executing SQL (message pane + results grid).""" |
|
|
| @pytest.mark.rb(depth=1, jump_kind="value", |
| expect='message pane starts "Execution finished without errors." and contains ' |
| '"1 rows returned" and "SELECT 2+3 AS total;"') |
| def test_sql_execution_message_text_success(self, ax): |
| ensure_ui(ax) |
| assert rb_enter_inmemory_db(ax), "could not create the in-memory database" |
| run_sql(ax, "SELECT 2+3 AS total;") |
|
|
| msg = exec_msg(ax) |
| assert msg, f"message pane is empty; panes={text_area_values(ax)!r}" |
| assert msg.startswith("Execution finished without errors."), \ |
| f"unexpected message prefix: {msg!r}" |
| assert "1 rows returned" in msg, f"message lacks '1 rows returned': {msg!r}" |
| assert "At line 1:" in msg, f"message lacks 'At line 1:': {msg!r}" |
| assert "SELECT 2+3 AS total;" in msg, f"message does not echo the statement: {msg!r}" |
| assert kit.rb_value(msg, "Execution finished without errors."), \ |
| "rb_value rejected the success message" |
|
|
| cols, cells = result_cells(ax) |
| assert "total" in cols, f"results grid header should read 'total'; got {cols!r}" |
| assert kit.rb_value(cells, "5"), f"results grid should show '5'; got {cells!r}" |
|
|
| screenshot_assert( |
| "text_test_sql_message_success", |
| "Execute SQL tab active in the 'DB Browser for SQLite - In-Memory database' window. " |
| "The SQL editor holds the statement SELECT 2+3 AS total; a results grid below shows a " |
| "single column headed 'total' containing the value 5, and the message pane reads " |
| "'Execution finished without errors.' followed by 'Result: 1 rows returned in ...' and " |
| "'At line 1: SELECT 2+3 AS total;'.", |
| RESULTS_DIR) |
|
|
| @pytest.mark.rb(depth=1, jump_kind="value", |
| expect='message pane starts "Execution finished with errors." and contains ' |
| '"no such table: no_such_table_xyz"') |
| def test_sql_execution_message_text_error(self, ax): |
| ensure_ui(ax) |
| assert rb_enter_inmemory_db(ax), "could not create the in-memory database" |
| run_sql(ax, "SELECT * FROM no_such_table_xyz;") |
|
|
| msg = exec_msg(ax) |
| assert msg, f"message pane is empty; panes={text_area_values(ax)!r}" |
| assert msg.startswith("Execution finished with errors."), \ |
| f"unexpected message prefix: {msg!r}" |
| assert "no such table: no_such_table_xyz" in msg, \ |
| f"message lacks the sqlite error text: {msg!r}" |
| assert kit.rb_value(msg, "no such table: no_such_table_xyz"), \ |
| "rb_value rejected the error message" |
|
|
| cols, _cells = result_cells(ax) |
| assert cols == [], f"results grid should stay empty on error; got columns {cols!r}" |
|
|
|
|
| class TestGridText: |
| """T3/T4 — Browse Data grid text, record counter, and the cell-editor identification line.""" |
|
|
| @pytest.mark.rb(depth=1, jump_kind="value", |
| expect="grid columns ['_rowid_','n','label'], cell texts include " |
| "'ten'/'twenty'/'thirty' and counter '1 - 3 of 3'") |
| def test_browse_data_grid_text_and_counter(self, ax): |
| ensure_ui(ax) |
| assert rb_enter_inmemory_db(ax), "could not create the in-memory database" |
| run_sql(ax, MAKE_NUMS) |
| assert switch_tab(ax, "Browse Data"), "Browse Data tab radio not pressable" |
|
|
| cols, cells = table_grid(ax, want_col="_rowid_") |
| assert cols == ["_rowid_", "n", "label"], \ |
| f"expected columns ['_rowid_','n','label']; got {cols!r}" |
| for want in ["ten", "twenty", "thirty", "10", "20", "30"]: |
| assert want in cells, f"grid cell text {want!r} missing; cells={cells!r}" |
| assert kit.rb_value(cells, "twenty"), f"rb_value rejected the cells {cells!r}" |
|
|
| counter = record_counter(ax) |
| assert counter == "1 - 3 of 3", f"record counter should read '1 - 3 of 3'; got {counter!r}" |
|
|
| screenshot_assert( |
| "text_test_browse_data_grid", |
| "Browse Data tab active with a 'Table:' dropdown reading nums. The data grid shows " |
| "columns _rowid_, n and label with the rows 10/ten, 20/twenty and 30/thirty, a 'Filter " |
| "in any column' box under the headers, and the record counter reading '1 - 3 of 3'.", |
| RESULTS_DIR) |
|
|
| @pytest.mark.rb(depth=1, jump_kind="value", |
| expect="clicking grid cell 'twenty' changes the cell-editor labels to " |
| "'Editing row=2, column=2' and 'Type: Text / Numeric; Size: 6 " |
| "character(s)' with the editor holding 'twenty'") |
| def test_cell_click_updates_editor_identification_text(self, ax): |
| ensure_ui(ax) |
| assert rb_enter_inmemory_db(ax), "could not create the in-memory database" |
| run_sql(ax, MAKE_NUMS) |
| assert switch_tab(ax, "Browse Data"), "Browse Data tab radio not pressable" |
|
|
| before_vals = label_values(ax) |
| before = next((v for v in before_vals if "Editing row=" in v), None) |
|
|
| cell = grid_cell_named(ax, "twenty") |
| assert cell is not None, "grid cell with the text 'twenty' not found" |
| ax.click_element_cg(cell.id) |
| time.sleep(1.2) |
|
|
| after_vals = label_values(ax) |
| ident = next((v for v in after_vals if "Editing row=" in v), None) |
| assert ident is not None, \ |
| f"no cell-editor identification label after the click; labels={sorted(set(after_vals))}" |
| assert "Editing row=2" in ident, f"identification text should name row 2; got {ident!r}" |
| assert "column=" in ident, f"identification text should name a column; got {ident!r}" |
| if before is not None: |
| assert ident != before, f"identification text did not change from {before!r}" |
|
|
| type_line = next((v for v in after_vals if v.startswith("Type: ")), None) |
| assert type_line is not None, \ |
| f"no 'Type: ...' size line after the click; labels={sorted(set(after_vals))}" |
| assert "character(s)" in type_line, \ |
| f"type/size line should report character(s) for a text cell; got {type_line!r}" |
|
|
| editor_value = next((v for v in text_area_values(ax) if v == "twenty"), None) |
| assert editor_value == "twenty", \ |
| f"cell editor should hold exactly 'twenty'; panes={text_area_values(ax)!r}" |
| assert kit.rb_value(editor_value, "twenty"), "rb_value rejected the cell editor text" |
|
|
|
|
| class TestPragmaText: |
| """T6 — pragma display labels (plain `label`s that end with the object-replacement glyph).""" |
|
|
| @pytest.mark.rb(depth=1, jump_kind="value", |
| expect="Edit Pragmas tab shows the 18 pragma display labels (Auto Vacuum, " |
| "Automatic Index, ..., WAL Auto Checkpoint)") |
| def test_pragma_display_labels_present(self, ax): |
| ensure_ui(ax) |
| assert switch_tab(ax, "Edit Pragmas"), "Edit Pragmas tab radio not pressable" |
|
|
| values = label_values(ax) |
| assert values, "Edit Pragmas page exposes no label text" |
|
|
| found, missing = [], [] |
| for name in PRAGMA_DISPLAY_LABELS: |
| |
| hit = next((v for v in values if v.startswith(name)), None) |
| (found if hit is not None else missing).append(name) |
| assert not missing, f"pragma display labels missing {missing}; got {sorted(set(values))}" |
|
|
| found_count = len(found) |
| assert found_count == 18, f"expected 18 pragma labels, found {found_count}" |
| assert kit.rb_value(found_count, 18), f"rb_value rejected the pragma label count {found_count}" |
|
|
| screenshot_assert( |
| "text_test_pragma_labels", |
| "Edit Pragmas tab active, showing a form of SQLite pragma controls whose visible " |
| "labels read 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, with Save and Cancel " |
| "buttons at the bottom of the page.", |
| RESULTS_DIR) |
|
|
