| """COMPUTATION lane — DB Browser for SQLite (Qt5). |
| |
| The app's CORE: input -> output. Two surfaces are driven for real and their |
| computed results read back and asserted against the sample.db ground truth: |
| |
| * Execute SQL — type a query, press F5, read the result grid + status text |
| (count / sum / max / group-by / where / view / expression / error). |
| * Browse Data — select a table in the combo, read the "1 - N of N" row-count |
| label and the grid cells (selection -> observed value change). |
| |
| Every value is READ OFF THE RUNNING APP, never from source/constants. A dead |
| shell that never runs the query (empty grid / no status) fails every test. |
| """ |
|
|
| import re |
| import time |
|
|
| import pytest, pytest_check as check |
| import rb_atspi |
|
|
| from gi.repository import Atspi |
|
|
| DB = "/workspace/output/fixtures/sample.db" |
|
|
|
|
| |
| |
| |
| @pytest.fixture(scope="module", autouse=True) |
| def _load_db(app): |
| rb_atspi.focus_app_window(app) |
| frame = rb_atspi.get_main_frame(app) |
| for _ in range(4): |
| rb_atspi.press_escape(); time.sleep(0.15) |
| if "sample.db" not in (frame.get_name() or ""): |
| fm = rb_atspi.find_first(frame, role="menu item", name="File") |
| if fm: |
| rb_atspi.click_node(fm); time.sleep(0.4) |
| op = rb_atspi.find_first(frame, role="menu item", name="Open Database...") |
| if op: |
| rb_atspi.open_modal(op); time.sleep(1.2) |
| rb_atspi.type_text(DB); time.sleep(0.4) |
| rb_atspi.key("Return"); time.sleep(1.5) |
| yield |
|
|
|
|
| |
| |
| |
| def _extents(n): |
| try: |
| return n.get_extents(Atspi.CoordType.SCREEN) |
| except Exception: |
| return None |
|
|
|
|
| def _forigin(frame): |
| """Frame's top-left in SCREEN coords. Locators are computed RELATIVE to this |
| so they work regardless of where the window manager places the window (a cold |
| relaunch does NOT put it at the same absolute x/y the warm testgen instance had).""" |
| e = _extents(frame) |
| return (e.x, e.y) if e else (0, 0) |
|
|
|
|
| def _exec_tab(frame): |
| rb_atspi.focus_app_window(rb_atspi.get_app()) |
| t = rb_atspi.find_first(frame, role="page tab", name="Execute SQL") |
| if t: |
| if not rb_atspi.do_action(t, "Press"): |
| rb_atspi.click_node(t) |
| time.sleep(0.7) |
| return t |
|
|
|
|
| def _browse_tab(frame): |
| rb_atspi.focus_app_window(rb_atspi.get_app()) |
| t = rb_atspi.find_first(frame, role="page tab", name="Browse Data") |
| if t: |
| if not rb_atspi.do_action(t, "Press"): |
| rb_atspi.click_node(t) |
| time.sleep(1.0) |
| return t |
|
|
|
|
| def _sql_editor(frame): |
| """The Scintilla SQL editor: the showing role=text at the TOP-LEFT of the |
| Execute SQL tab (frame-relative x<400, tall, smallest y).""" |
| fx, fy = _forigin(frame) |
| best = None |
| for t in rb_atspi.find_all(frame, role="text"): |
| if not rb_atspi.is_showing(t): |
| continue |
| e = _extents(t) |
| if e is None: |
| continue |
| rx, ry = e.x - fx, e.y - fy |
| if rx < 400 and e.height > 80 and e.width > 200 and ry < 420: |
| if best is None or e.y < best[1]: |
| best = (t, e.y) |
| return best[0] if best else None |
|
|
|
|
| def _status_text(frame): |
| """editErrors QTextEdit: the showing role=text at the BOTTOM-LEFT (largest y) |
| of the Execute SQL tab (frame-relative). Returns its plain text.""" |
| fx, fy = _forigin(frame) |
| cand = None |
| for t in rb_atspi.find_all(frame, role="text"): |
| if not rb_atspi.is_showing(t): |
| continue |
| e = _extents(t) |
| if e is None: |
| continue |
| rx, ry = e.x - fx, e.y - fy |
| if rx < 400 and e.width > 200 and ry > 420: |
| if cand is None or e.y > cand[1]: |
| cand = (t, e.y) |
| return rb_atspi.get_text(cand[0]) if cand else "" |
|
|
|
|
| def _result_table(frame): |
| """The Execute SQL result grid: showing role=table with real extents at the |
| left (frame-relative x<400) below the editor (ry>250). The Browse grid persists |
| in the tree with (0,0,0,0) extents while this tab is active, so extent-filtering |
| picks the right one.""" |
| fx, fy = _forigin(frame) |
| best = None |
| for tb in rb_atspi.find_all(frame, role="table"): |
| if not rb_atspi.is_showing(tb): |
| continue |
| e = _extents(tb) |
| if e is None or e.width <= 0: |
| continue |
| rx, ry = e.x - fx, e.y - fy |
| if rx < 400 and ry > 250: |
| if best is None or e.y < best[1]: |
| best = (tb, e.y) |
| return best[0] if best else None |
|
|
|
|
| def run_sql(frame, sql): |
| """Clear the SQL editor, type `sql`, press F5, and read back |
| (cells, headers, status_text). Polls for the grid to populate.""" |
| _exec_tab(frame) |
| ed = _sql_editor(frame) |
| assert ed is not None, "SQL editor not found on Execute SQL tab" |
| rb_atspi.click_node(ed); time.sleep(0.25) |
| rb_atspi.key("ctrl+a"); rb_atspi.key("Delete"); time.sleep(0.15) |
| rb_atspi.type_text(sql); time.sleep(0.3) |
| rb_atspi.key("F5") |
|
|
| |
| def _done(): |
| return "Execution finished" in _status_text(frame) |
| rb_atspi.wait_for(_done, timeout=6.0, interval=0.25) |
| time.sleep(0.3) |
|
|
| tb = _result_table(frame) |
| cells = [c.get_name() or "" for c in rb_atspi.find_all(tb, role="table cell")] if tb else [] |
| hdrs = [h.get_name() or "" for h in rb_atspi.find_all(tb, role="table column header")] if tb else [] |
| return cells, hdrs, _status_text(frame) |
|
|
|
|
| def _rowcount_label(frame): |
| for l in rb_atspi.find_all(frame, role="label"): |
| n = l.get_name() or "" |
| if re.match(r"^\s*\d+\s*-\s*\d+\s*of\s*\d+", n): |
| return n.strip() |
| return None |
|
|
|
|
| def _browse_combo(frame): |
| """Table selector combo near top-left of Browse Data (frame-relative x<400, ry~90).""" |
| fx, fy = _forigin(frame) |
| for c in rb_atspi.find_all(frame, role="combo box"): |
| if not rb_atspi.is_showing(c): |
| continue |
| e = _extents(c) |
| if e is None: |
| continue |
| rx, ry = e.x - fx, e.y - fy |
| if 0 < rx < 400 and 60 < ry < 240 and 80 < e.width < 400: |
| return c |
| return None |
|
|
|
|
| def _browse_grid(frame): |
| fx, fy = _forigin(frame) |
| for tb in rb_atspi.find_all(frame, role="table"): |
| if not rb_atspi.is_showing(tb): |
| continue |
| e = _extents(tb) |
| if e is None or e.width <= 0: |
| continue |
| rx, ry = e.x - fx, e.y - fy |
| if rx < 400 and ry < 260: |
| return tb |
| return None |
|
|
|
|
| def _select_browse_table(frame, target): |
| """Select `target` in the Browse-Data table combo. The Qt combo popup exposes |
| list items with bogus (0,0)-based extents, so a center-click on an item misses. |
| Instead we open the popup with a real click and use Qt type-ahead: typing the |
| table name jumps the highlight to it, Return commits. Returns True when the |
| combo's live name becomes `target`.""" |
| combo = _browse_combo(frame) |
| if combo is None: |
| return False |
| if (combo.get_name() or "") == target: |
| return True |
| e = _extents(combo) |
| if e is None: |
| return False |
| rb_atspi.xdo("mousemove", e.x + e.width // 2, e.y + e.height // 2, "click", "1") |
| time.sleep(0.5) |
| rb_atspi.type_text(target); time.sleep(0.4) |
| rb_atspi.key("Return"); time.sleep(1.0) |
| c2 = _browse_combo(frame) |
| if bool(c2) and (c2.get_name() or "") == target: |
| return True |
| |
| rb_atspi.press_escape(); time.sleep(0.2) |
| c3 = _browse_combo(frame) |
| if c3 is None: |
| return False |
| e3 = _extents(c3) |
| rb_atspi.xdo("mousemove", e3.x + e3.width // 2, e3.y + e3.height // 2, "click", "1") |
| time.sleep(0.5) |
| rb_atspi.type_text(target); time.sleep(0.4) |
| rb_atspi.key("Return"); time.sleep(1.0) |
| c4 = _browse_combo(frame) |
| return bool(c4) and (c4.get_name() or "") == target |
|
|
|
|
| |
| |
| |
| @pytest.mark.rb(jump_kind="value", expect="single cell 8") |
| def test_sql_count_employees(app, frame, rb): |
| rb.enter("execute") |
| cells, hdrs, status = run_sql(frame, "SELECT count(*) FROM employees;") |
| check.is_in("8", cells, f"count(*) employees expected 8, got cells={cells}") |
| check.equal([c for c in cells if c][0] if cells else None, "8", |
| f"first result cell should be '8', cells={cells}") |
| check.is_in("without errors", status, f"status did not report success: {status!r}") |
|
|
|
|
| @pytest.mark.rb(jump_kind="value", expect="single cell 3") |
| def test_sql_count_departments(app, frame, rb): |
| rb.enter("execute") |
| cells, hdrs, status = run_sql(frame, "SELECT count(*) FROM departments;") |
| check.is_in("3", cells, f"count(*) departments expected 3, got cells={cells}") |
| check.is_in("without errors", status, f"status not success: {status!r}") |
|
|
|
|
| @pytest.mark.rb(jump_kind="value", expect="single cell 538000 (SUM salary)") |
| def test_sql_sum_salary(app, frame, rb): |
| rb.enter("execute") |
| cells, hdrs, status = run_sql(frame, "SELECT SUM(salary) FROM employees;") |
| check.is_in("538000", cells, f"SUM(salary) expected 538000, got cells={cells}") |
| check.is_in("without errors", status, f"status not success: {status!r}") |
|
|
|
|
| @pytest.mark.rb(jump_kind="value", expect="single cell 94000 (MAX salary)") |
| def test_sql_max_salary(app, frame, rb): |
| rb.enter("execute") |
| cells, hdrs, status = run_sql(frame, "SELECT MAX(salary) FROM employees;") |
| check.is_in("94000", cells, f"MAX(salary) expected 94000, got cells={cells}") |
| check.is_in("without errors", status, f"status not success: {status!r}") |
|
|
|
|
| @pytest.mark.rb( |
| jump_kind="value", |
| expect="grid: Engineering,3,251000 / Marketing,2,115000 / Sales,3,172000", |
| ) |
| def test_sql_group_by_department(app, frame, rb, results_dir): |
| rb.enter("execute") |
| cells, hdrs, status = run_sql( |
| frame, |
| "SELECT department, COUNT(*), SUM(salary) FROM employees " |
| "GROUP BY department ORDER BY department;", |
| ) |
| |
| check.is_in("without errors", status, f"status not success: {status!r}") |
| check.equal(len(cells), 9, f"expected 9 cells (3 rows x 3 cols), got {cells}") |
| if len(cells) == 9: |
| check.equal(cells[0], "Engineering", f"cell[0] {cells[0]!r}") |
| check.equal(cells[1], "3", f"cell[1] Engineering count {cells[1]!r}") |
| check.equal(cells[2], "251000", f"cell[2] Engineering sum {cells[2]!r}") |
| check.equal(cells[3], "Marketing", f"cell[3] {cells[3]!r}") |
| check.equal(cells[4], "2", f"cell[4] Marketing count {cells[4]!r}") |
| check.equal(cells[5], "115000", f"cell[5] Marketing sum {cells[5]!r}") |
| check.equal(cells[6], "Sales", f"cell[6] {cells[6]!r}") |
| check.equal(cells[7], "3", f"cell[7] Sales count {cells[7]!r}") |
| check.equal(cells[8], "172000", f"cell[8] Sales sum {cells[8]!r}") |
| else: |
| for want in ("Engineering", "Marketing", "Sales", "251000", "115000", "172000"): |
| check.is_in(want, cells, f"missing {want} in group-by result") |
|
|
| rb_atspi.screenshot_assert( |
| "test_sql_group_by_department", |
| "Execute SQL result grid shows three department rows: Engineering with " |
| "count 3 and salary sum 251000, Marketing with count 2 and 115000, and " |
| "Sales with count 3 and 172000.", |
| results_dir, window=frame, |
| ) |
|
|
|
|
| @pytest.mark.rb(jump_kind="value", expect="two rows: Alice and Grace") |
| def test_sql_where_filter(app, frame, rb): |
| rb.enter("execute") |
| cells, hdrs, status = run_sql( |
| frame, "SELECT name FROM employees WHERE salary>80000 ORDER BY name;" |
| ) |
| names = [c for c in cells if c] |
| check.equal(names, ["Alice", "Grace"], |
| f"WHERE salary>80000 ORDER BY name expected [Alice, Grace], got {names}") |
| check.is_in("without errors", status, f"status not success: {status!r}") |
|
|
|
|
| @pytest.mark.rb(jump_kind="value", expect="single cell 5 (high_earners view count)") |
| def test_sql_view_high_earners_count(app, frame, rb): |
| rb.enter("execute") |
| cells, hdrs, status = run_sql(frame, "SELECT count(*) FROM high_earners;") |
| check.is_in("5", cells, f"count(*) high_earners expected 5, got cells={cells}") |
| check.is_in("without errors", status, f"status not success: {status!r}") |
|
|
|
|
| @pytest.mark.rb(jump_kind="value", expect="single cell 42 (6*7 expression)") |
| def test_sql_expression_eval(app, frame, rb): |
| rb.enter("execute") |
| cells, hdrs, status = run_sql(frame, "SELECT 6*7 AS x;") |
| check.is_in("42", cells, f"6*7 expected 42, got cells={cells}") |
| check.is_in("without errors", status, f"status not success: {status!r}") |
|
|
|
|
| @pytest.mark.rb(jump_kind="value", expect="error message: no such table") |
| def test_sql_error_reporting(app, frame, rb): |
| rb.enter("execute") |
| cells, hdrs, status = run_sql(frame, "SELECT * FROM no_such_table;") |
| check.is_in("with errors", status, |
| f"invalid query should report errors, status={status!r}") |
| check.is_in("no such table", status, |
| f"error status should mention 'no such table', got {status!r}") |
|
|
|
|
| |
| |
| |
| @pytest.mark.rb(jump_kind="value", expect="row-count label '1 - 3 of 3' (departments)") |
| def test_browse_default_table_rowcount(app, frame, rb, results_dir): |
| rb.enter("browse") |
| _browse_tab(frame) |
| _select_browse_table(frame, "departments") |
| time.sleep(0.5) |
| label = _rowcount_label(frame) |
| check.equal(label, "1 - 3 of 3", |
| f"departments row-count label expected '1 - 3 of 3', got {label!r}") |
|
|
| rb_atspi.screenshot_assert( |
| "test_browse_default_table_rowcount", |
| "Browse Data tab showing the departments table: a grid with 3 rows " |
| "(Engineering, Sales, Marketing) and a '1 - 3 of 3' row-count label.", |
| results_dir, window=frame, |
| ) |
|
|
|
|
| @pytest.mark.rb( |
| jump_kind="value", |
| expect="after selecting employees: '1 - 8 of 8' and grid shows Alice", |
| ) |
| def test_browse_select_employees_changes_grid(app, frame, rb, results_dir): |
| rb.enter("browse") |
| _browse_tab(frame) |
| |
| _select_browse_table(frame, "departments"); time.sleep(0.4) |
| before = _rowcount_label(frame) |
|
|
| ok = _select_browse_table(frame, "employees") |
| check.is_true(ok, "combo did not switch to 'employees'") |
| time.sleep(0.4) |
| after = _rowcount_label(frame) |
|
|
| check.equal(after, "1 - 8 of 8", |
| f"employees row-count expected '1 - 8 of 8', got {after!r}") |
| check.not_equal(before, after, "row-count label did not change on table switch") |
|
|
| grid = _browse_grid(frame) |
| cells = [c.get_name() or "" for c in rb_atspi.find_all(grid, role="table cell")] if grid else [] |
| hdrs = [h.get_name() or "" for h in rb_atspi.find_all(grid, role="table column header")] if grid else [] |
| check.is_in("Alice", cells, f"employees grid should contain 'Alice', cells={cells[:12]}") |
| check.is_in("name", hdrs, f"employees grid headers should include 'name', got {hdrs}") |
|
|
| rb_atspi.screenshot_assert( |
| "test_browse_select_employees_changes_grid", |
| "Browse Data tab showing the employees table: an 8-row grid with columns " |
| "id/name/department/salary/hired (Alice/Engineering/85000 in the first " |
| "row) and a '1 - 8 of 8' row-count label.", |
| results_dir, window=frame, |
| ) |
| |
| _select_browse_table(frame, "departments"); time.sleep(0.3) |
|
|
|
|
| @pytest.mark.rb( |
| jump_kind="value", |
| expect="employees grid contains Alice and her salary 85000", |
| ) |
| def test_browse_cell_value_alice_salary(app, frame, rb): |
| rb.enter("browse") |
| _browse_tab(frame) |
| ok = _select_browse_table(frame, "employees") |
| check.is_true(ok, "combo did not switch to 'employees'") |
| time.sleep(0.4) |
| grid = _browse_grid(frame) |
| cells = [c.get_name() or "" for c in rb_atspi.find_all(grid, role="table cell")] if grid else [] |
| check.is_in("Alice", cells, f"grid should contain 'Alice', cells={cells[:12]}") |
| check.is_in("85000", cells, f"grid should contain Alice's salary 85000, cells={cells[:12]}") |
| _select_browse_table(frame, "departments"); time.sleep(0.3) |
|
|
