ubuntu/sqlitebrowser-sqlitebrowser/tests/test_atspi_text.py

"""TEXT lane — DB Browser for SQLite (Qt5).

CONTENT / OUTPUT text that an INTERACTION produces, read off the running
reference and asserted as a substring of the observed value (never read from
source / a version constant — a recreation cannot know those, so the expected
string is always something observed live). Surfaces owned here:

  * Window TITLE reflecting the opened DB (File>Open consequence).
  * Database-Structure tree SCHEMA text — the app-rendered CREATE TABLE / CREATE
    VIEW SQL + the category summary rows (Tables (2) / Indices (1) / Views (1)).
  * Execute-SQL editor content ROUND-TRIP (type -> read back == real text control).
  * Execute-SQL STATUS message text ("Execution finished without/with errors.").
  * About-dialog rendered VERSION text (programmatic label read + VLM screenshot).

LANE BOUNDARY (NOT asserted here, owned elsewhere):
  * The numeric query RESULT in the grid / the "1 - N of N" row counter as a
    computed value -> computation lane.
  * CHECKED toggles -> state lane.
  * Whether a menu/dialog merely opens -> menu lane (we read the TEXT it renders).

Every value test declares jump_kind="value" with the exact expected TEXT in
expect=, and calls rb.enter() on the tab/dialog crossing (measured depth 1).
Screenshots are ADDITIVE on tree-readable text and the SOLE assertion for the
About version (rendered) — one shot per DISTINCT rendered state.
"""

import time

import pytest, pytest_check as check
import rb_atspi

from gi.repository import Atspi

DB = "/workspace/output/fixtures/sample.db"


# --------------------------------------------------------------------------- #
# Module fixture — ensure sample.db is open (cold baseline starts with no 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


# --------------------------------------------------------------------------- #
# Locators / helpers (all verified live on the running reference).
# --------------------------------------------------------------------------- #
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 below are frame-RELATIVE so they
    hold wherever the WM places the window (a cold relaunch does not reuse the warm
    testgen instance's absolute position)."""
    e = _extents(frame)
    return (e.x, e.y) if e else (0, 0)


def _select_tab(frame, name, settle=0.8):
    """Switch a main page tab via its AT-SPI Press action (falls back to a real
    click). Verified: do_action(tab,'Press') activates the tab."""
    rb_atspi.focus_app_window(rb_atspi.get_app())
    t = rb_atspi.find_first(frame, role="page tab", name=name)
    if t is not None:
        if not rb_atspi.do_action(t, "Press"):
            rb_atspi.click_node(t)
        time.sleep(settle)
    return t


def _all_names(frame):
    """Every node's a11y name in the frame (any role). The structure-tree schema
    cells are role='tree item' whose NAME carries the full CREATE SQL; searching
    across roles keeps the match tolerant to the exact role the toolkit uses."""
    out = []
    rb_atspi.walk(frame, lambda n, _d: out.append(n.get_name() or ""))
    return out


def _find_name_containing(frame, needle):
    """First a11y name in the frame that contains `needle` (case-sensitive)."""
    for nm in _all_names(frame):
        if needle in nm:
            return nm
    return None


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, wide, 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,
    frame-relative x<400) of the Execute SQL tab. 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 _run_sql(frame, sql):
    """Clear the SQL editor, type `sql`, press F5, poll for completion, and return
    the editErrors STATUS text. (This lane reads the STATUS MESSAGE, not the grid
    numbers — those belong to the computation lane.)"""
    _select_tab(frame, "Execute SQL")
    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")
    rb_atspi.wait_for(
        lambda: "Execution finished" in _status_text(frame), timeout=6.0, interval=0.25
    )
    time.sleep(0.3)
    return _status_text(frame)


# =========================================================================== #
# 1. Window title reflects the opened DB (File>Open consequence).
# =========================================================================== #
@pytest.mark.rb(jump_kind="value", expect="title contains 'sample.db' and 'DB Browser for SQLite'")
def test_window_title_reflects_open_db(app, frame, rb, results_dir):
    # The title is app-authored output of the open action: a dead shell with a
    # fixed/blank title fails. Read it straight off the live frame.
    title = frame.get_name() or ""
    check.is_in("sample.db", title,
                f"window title should contain the opened DB filename 'sample.db', got {title!r}")
    check.is_in("DB Browser for SQLite", title,
                f"window title should name the app 'DB Browser for SQLite', got {title!r}")
    rb_atspi.screenshot_assert(
        "test_window_title_reflects_open_db",
        "The DB Browser for SQLite application window's title bar reads "
        "'DB Browser for SQLite - /workspace/output/fixtures/sample.db' "
        "(the app name followed by the full path to the opened sample.db file).",
        results_dir,
    )


# =========================================================================== #
# 2. Structure tree renders the employees CREATE TABLE SQL.
# =========================================================================== #
@pytest.mark.rb(jump_kind="value",
                expect="employees CREATE TABLE SQL with 'name TEXT' and 'salary INTEGER'")
def test_structure_shows_create_table_employees(app, frame, rb, results_dir):
    rb.enter("structure")
    _select_tab(frame, "Database Structure")
    cell = _find_name_containing(frame, "CREATE TABLE employees")
    check.is_true(cell is not None,
                  "no structure cell renders 'CREATE TABLE employees'")
    if cell:
        # The app renders the actual column definitions (read from the DB schema).
        check.is_in("name TEXT", cell,
                    f"employees CREATE SQL should show 'name TEXT', got {cell!r}")
        check.is_in("salary INTEGER", cell,
                    f"employees CREATE SQL should show 'salary INTEGER', got {cell!r}")
    rb_atspi.screenshot_assert(
        "test_structure_shows_create_table_employees",
        "The Database Structure tab is active, showing a schema tree with a "
        "'Tables (2)' group listing 'departments' and 'employees', an 'Indices "
        "(1)' group with 'idx_emp_dept', a 'Views (1)' group with 'high_earners', "
        "and a 'Triggers (0)' group; the Schema column shows 'CREATE TABLE ...' "
        "text beside the departments and employees rows.",
        results_dir, window=frame,
    )


# =========================================================================== #
# 3. Structure tree renders the high_earners CREATE VIEW SQL (same tab state).
# =========================================================================== #
@pytest.mark.rb(jump_kind="value",
                expect="CREATE VIEW high_earners AS SELECT name, salary FROM employees WHERE salary > 60000")
def test_structure_shows_create_view(app, frame, rb):
    rb.enter("structure")
    _select_tab(frame, "Database Structure")
    cell = _find_name_containing(frame, "CREATE VIEW high_earners")
    check.is_true(cell is not None,
                  "no structure cell renders 'CREATE VIEW high_earners'")
    if cell:
        for frag in ("SELECT name, salary", "FROM employees", "WHERE salary > 60000"):
            check.is_in(frag, cell,
                        f"high_earners CREATE VIEW SQL missing {frag!r}, got {cell!r}")
    # No separate screenshot: identical tree state as test #2 (one shot per state).


# =========================================================================== #
# 4. Structure tree category summary rows (app-rendered object counts as text).
# =========================================================================== #
@pytest.mark.rb(jump_kind="value",
                expect="category rows 'Tables (2)', 'Indices (1)', 'Views (1)'")
def test_structure_category_labels(app, frame, rb):
    rb.enter("structure")
    _select_tab(frame, "Database Structure")
    names = _all_names(frame)
    for want in ("Tables (2)", "Indices (1)", "Views (1)"):
        check.is_true(any(want == n or want in n for n in names),
                      f"structure tree should show category row {want!r}")
    # No screenshot: same structure-tree state as test #2.


# =========================================================================== #
# 5. Execute-SQL editor stores typed content (round-trip == real text control).
# =========================================================================== #
@pytest.mark.rb(jump_kind="value", expect="editor content echoes 'hello_world'")
def test_sql_editor_text_roundtrip(app, frame, rb, results_dir):
    rb.enter("execute")
    _select_tab(frame, "Execute SQL")
    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)
    typed = "SELECT 'hello_world' AS greeting;"
    rb_atspi.type_text(typed); time.sleep(0.4)
    got = rb_atspi.get_text(ed)
    check.is_in("hello_world", got,
                f"editor should echo the typed 'hello_world', got {got!r}")
    check.is_in("greeting", got,
                f"editor should echo the typed alias 'greeting', got {got!r}")
    rb_atspi.screenshot_assert(
        "test_sql_editor_text_roundtrip",
        "The Execute SQL tab's SQL editor pane contains the typed query text "
        "\"SELECT 'hello_world' AS greeting;\".",
        results_dir, window=frame,
    )
    # Leave the editor clean for order-independence.
    rb_atspi.click_node(ed); time.sleep(0.15)
    rb_atspi.key("ctrl+a"); rb_atspi.key("Delete"); time.sleep(0.15)


# =========================================================================== #
# 6. Execute-SQL STATUS message on a valid query.
# =========================================================================== #
@pytest.mark.rb(jump_kind="value",
                expect="status: 'Execution finished without errors.' + 'rows returned'")
def test_sql_status_message_success(app, frame, rb, results_dir):
    rb.enter("execute")
    status = _run_sql(frame, "SELECT 1;")
    check.is_in("Execution finished without errors.", status,
                f"valid query status should read success, got {status!r}")
    check.is_in("rows returned", status,
                f"valid query status should report 'rows returned', got {status!r}")
    rb_atspi.screenshot_assert(
        "test_sql_status_message_success",
        "The Execute SQL status panel (below the editor) reads "
        "'Execution finished without errors.' followed by 'Result: 1 rows "
        "returned in ...ms' for the query SELECT 1.",
        results_dir, window=frame,
    )


# =========================================================================== #
# 7. Execute-SQL STATUS message on an invalid query.
# =========================================================================== #
@pytest.mark.rb(jump_kind="value", expect="status: 'Execution finished with errors.'")
def test_sql_status_message_error(app, frame, rb, results_dir):
    rb.enter("execute")
    status = _run_sql(frame, "SELECT * FROM nonexistent_zzz;")
    # This lane asserts the generic STATUS-MESSAGE content (the error identity
    # 'no such table' is the computation lane's; the status line is text-content).
    check.is_in("Execution finished with errors.", status,
                f"invalid query status should read failure, got {status!r}")
    rb_atspi.screenshot_assert(
        "test_sql_status_message_error",
        "The Execute SQL status panel shows an error state reading 'Execution "
        "finished with errors.' (with a red-tinted background) after running a "
        "query against a table that does not exist.",
        results_dir, window=frame,
    )
    # Restore a clean, successful state so later ordering isn't left on an error.
    _run_sql(frame, "SELECT 1;")


# =========================================================================== #
# 8. Help > About renders the app version text (rendered/opaque -> VLM + label).
# =========================================================================== #
@pytest.mark.rb(jump_kind="value", expect="About dialog shows a 'Version' string for DB Browser for SQLite")
def test_about_version_text(app, frame, rb, results_dir):
    for _ in range(3):
        rb_atspi.press_escape(); time.sleep(0.15)
    # Help menu -> About (dialog-opener: open_modal so the modal loop can't hang).
    # Two real surface crossings: opening the menu (depth 1) then the dialog (depth 2).
    helpm = rb_atspi.find_first(frame, role="menu item", name="Help")
    assert helpm is not None, "Help menu not found"
    rb.enter("help_menu")
    rb_atspi.click_node(helpm); time.sleep(0.5)
    about = rb_atspi.find_first(frame, role="menu item", name="About")
    assert about is not None, "Help > About item not found"
    rb.enter("about_dialog")
    rb_atspi.open_modal(about)
    dlg = rb_atspi.wait_node(
        lambda: app, timeout=5.0, role="dialog", name="About DB Browser for SQLite"
    )
    check.is_true(dlg is not None and rb_atspi.is_showing(dlg),
                  "About dialog did not appear")
    # (a) programmatic: a label in the dialog renders the app name + a Version string.
    if dlg is not None:
        blob = " ".join(rb_atspi.get_text(l) for l in rb_atspi.find_all(dlg, role="label"))
        check.is_in("DB Browser for SQLite", blob,
                    f"About dialog should name the app, got {blob[:120]!r}")
        check.is_in("Version", blob,
                    f"About dialog should render a 'Version' string, got {blob[:120]!r}")
    # (b) VLM: the rendered version text (full screen — the dialog is its own window).
    rb_atspi.screenshot_assert(
        "test_about_version_text",
        "The 'About DB Browser for SQLite' dialog is open and shows a version "
        "line reading 'DB Browser for SQLite Version 3.13...' together with the "
        "program description ('an open source, freeware visual tool ...').",
        results_dir,
    )
    rb_atspi.press_escape(); time.sleep(0.3)
    rb_atspi.press_escape(); time.sleep(0.3)