macos/sqlitebrowser-sqlitebrowser/tests/test_ax_structure.py

"""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


# --------------------------------------------------------------------------- #
# recon-derived expectations (## AX_TREE, ## STRUCTURE, ## TEXT, ## BUTTONS)
# --------------------------------------------------------------------------- #

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"]

# ## TEXT T3 — column header sets that exist on a FRESH app (no DB)
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"}

# ## AX_TREE / T1 — one signature label per dock panel (read via AXValue)
DOCK_LABEL_TEXTS = ["Mode:", "Show SQL submitted by", "Line type:", "Point shape:", "Identity"]

# ## STRUCTURE S1 — Execute SQL tab page
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"}
# ## STRUCTURE S2 — Browse Data tab page
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"]
# ## STRUCTURE S3 / T6 — the 8 pragma checkboxes (AXTitle is literal HTML -> substring match)
PRAGMA_CHECKBOX_NAMES = ["Automatic Index", "Case Sensitive Like", "Checkpoint Full FSYNC",
                         "Foreign Keys", "Full FSYNC", "Ignore Check Constraints",
                         "Recursive Triggers", "Secure Delete"]
# ## STRUCTURE S6 / ST4 — Edit table definition dialog
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"}
# ## STRUCTURE S7 / ST5 — Preferences window
PREFS_TABS = {"General", "Database", "Data Browser", "SQL", "Extensions", "Remote"}
PREFS_BUTTONS = {"Save", "Cancel", "Restore Defaults", "Import Settings", "Export Settings"}

# role census on a fresh app (## AX_TREE "Role census")
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*$")


# --------------------------------------------------------------------------- #
# small, framework-tolerant locator helpers (recon-only, no live exploration)
# --------------------------------------------------------------------------- #

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))


# --------------------------------------------------------------------------- #
# A) EXISTENCE GATE  (depth=0, jump_kind="none")
# --------------------------------------------------------------------------- #

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)}"



# --------------------------------------------------------------------------- #
# B) SHAPE DELTAS  (reach / transition, depth >= 1)
# --------------------------------------------------------------------------- #

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"))