macos/codeeditapp-codeedit/tests/test_ax_buttons.py

#!/usr/bin/env python3
"""AX BUTTON tests for CodeEdit — generated from recon.md ``## BUTTONS``.

Every test drives a real push / toggle button and asserts the CONSEQUENCE recon
recorded for it (a surface appeared, a state flipped, a value changed) — never a bare
"it exists / it did not crash".

The only controls asserted by NAME + enabled-state (never pressed) are the ones recon
marks unsafe: Settings ▸ General ``Install`` / ``Check Now`` /
``Reset "Don't Ask Me" Warnings`` and the 4 Settings ▸ Locations path buttons (they open
Finder).  ``Contributors`` in the About window is network-backed and is never touched.

Interaction rules honoured (recon ▸ ENVIRONMENT CONSTRAINTS):
  * ``AXPress``             → menu items, push buttons, sheet buttons, window close buttons
  * ``ax.click_element_cg`` → Settings sidebar panes, workspace toolbar / tab buttons
  * ``ax.set_value``        → text fields (the clone-URL field)
  * panels & sheets are dismissed with their own Cancel button (Escape is a no-op here)
  * ``AXPress`` on ``Create New File...`` returns **False** while the modal Save panel comes
    up — the return value is ignored and the resulting surface is asserted instead.

Widgets are located by visible label (``AXTitle``/``AXDescription``) + ``AXRole`` scoped to
the owning window — never by child index or tree path — so a recreation that nests the
hierarchy differently still matches.
"""

# ── PRIMITIVES (copied VERBATIM from recon.md) ──────────────────────────────
import json
import os
import shutil
import subprocess
import time

import pytest

import rb_testgen_kit as kit
import verifier_helpers as helpers

RESULTS_DIR = os.environ.get("RESULTS_DIR", os.path.join(os.path.dirname(__file__), "results"))
FIXTURES_DIR = os.environ.get("FIXTURES_DIR") or os.path.join(os.path.dirname(__file__), "fixtures")


def screenshot_assert(test_name, description, results_dir=None):
    results_dir = results_dir or 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
    af = os.path.join(ss_dir, "assertions.json")
    data = {}
    if os.path.exists(af):
        try:
            with open(af) as f:
                data = json.load(f)
        except Exception:
            data = {}
    data[f"{test_name}.png"] = description
    with open(af, "w") as f:
        json.dump(data, f, indent=2)


def win_id(ax, w):
    return ax.get(w.id, ["AXIdentifier"]).get("AXIdentifier")


def all_windows(ax):
    return ax.find(role="window", max_depth=1, max_results=20)


def find_window(ax, ident=None, title=None, timeout=8.0):
    end = time.time() + timeout
    while True:
        for w in all_windows(ax):
            if ident is not None and win_id(ax, w) == ident:
                return w
            if title is not None and (w.name or "") == title:
                return w
        if time.time() >= end:
            return None
        time.sleep(0.25)


def close_window(ax, w):
    if w is None:
        return False
    for b in ax.find(role="button", root_id=w.id, max_results=200, max_depth=3):
        if ax.get(b.id, ["AXSubrole"]).get("AXSubrole") == "AXCloseButton":
            ax.action(b.id, "AXPress")
            time.sleep(0.8)
            return True
    return False


def values_in(ax, root_id, max_results=400, max_depth=18):
    """Every non-empty AXValue string under root (labels, fields, popups)."""
    out = []
    for e in ax.find(root_id=root_id, max_results=max_results, max_depth=max_depth):
        v = ax.get(e.id, ["AXValue"]).get("AXValue")
        if isinstance(v, str) and v.strip():
            out.append(v)
    return out


def names_in(ax, root_id, role=None, max_results=400, max_depth=18):
    return [e.name for e in ax.find(role=role, root_id=root_id,
                                    max_results=max_results, max_depth=max_depth) if e.name]


def buttons_named(ax, root_id, name):
    return [b for b in ax.find(role="button", root_id=root_id, max_results=300, max_depth=16)
            if (b.name or "") == name]


def menu_item(ax, *path):
    mbi = [m for m in ax.find(role="menu_bar_item", max_results=20, max_depth=3)
           if (m.name or "") == path[0]]
    if not mbi:
        return None
    cur = mbi[0].id
    for label in path[1:]:
        items = ax.find(role="menu_item", root_id=cur, max_results=300, max_depth=2)
        hit = [i for i in items if (i.name or "") == label]
        if not hit:
            return None
        cur = hit[0].id
    return cur


def menu_items(ax, *path):
    """Item NAMES directly under a menu-bar item (or a submenu item)."""
    root = menu_item(ax, *path) if len(path) > 1 else None
    if root is None:
        mbi = [m for m in ax.find(role="menu_bar_item", max_results=20, max_depth=3)
               if (m.name or "") == path[0]]
        if not mbi:
            return []
        menus = ax.find(role="menu", root_id=mbi[0].id, max_results=2, max_depth=1)
        if not menus:
            return []
        root = menus[0].id
    else:
        menus = ax.find(role="menu", root_id=root, max_results=2, max_depth=1)
        if not menus:
            return []
        root = menus[0].id
    return [i.name for i in ax.find(role="menu_item", root_id=root, max_results=100, max_depth=1)
            if (i.name or "")]


def rb_enter_menu_item(ax, *path, wait=1.6):
    mid = menu_item(ax, *path)
    if mid is None:
        return False
    ax.action(mid, "AXPress")
    time.sleep(wait)
    return True


def rb_enter_welcome(ax):
    w = find_window(ax, ident="welcome", timeout=3)
    if w is None:
        rb_enter_menu_item(ax, "Window", "Welcome to CodeEdit")
        w = find_window(ax, ident="welcome", timeout=6)
    return w


def rb_enter_settings_window(ax):
    w = find_window(ax, ident="settings", timeout=1)
    if w is None:
        rb_enter_menu_item(ax, "CodeEdit", "Settings...", wait=2.0)
        w = find_window(ax, ident="settings", timeout=8)
    return w


def rb_reach_settings_pane(ax, pane):
    """Select a Settings sidebar pane. MUST be a CG click (AXPress does NOT select)."""
    w = rb_enter_settings_window(ax)
    if w is None:
        return None
    bs = buttons_named(ax, w.id, pane)
    if not bs:
        return None
    ax.click_element_cg(bs[-1].id)
    time.sleep(1.0)
    return find_window(ax, ident="settings", timeout=3)


def rb_enter_about_window(ax):
    rb_enter_menu_item(ax, "CodeEdit", "About CodeEdit", wait=2.0)
    return find_window(ax, ident="about", timeout=6)


def rb_enter_extensions_window(ax):
    rb_enter_menu_item(ax, "Extensions", "Open Extensions Window", wait=2.0)
    return find_window(ax, ident="extensions", timeout=6)


def rb_enter_clone_sheet(ax):
    w = rb_enter_welcome(ax)
    bs = buttons_named(ax, w.id, "Clone Git Repository...")
    if not bs:
        return None
    ax.action(bs[0].id, "AXPress")
    end = time.time() + 6
    while time.time() < end:
        s = ax.find(role="sheet", max_results=3, max_depth=6)
        if s:
            return s[0]
        time.sleep(0.25)
    return None


def rb_enter_save_panel(ax):
    w = rb_enter_welcome(ax)
    bs = buttons_named(ax, w.id, "Create New File...")
    if bs:
        ax.action(bs[0].id, "AXPress")
    return find_window(ax, title="Save", timeout=8)


def rb_enter_open_panel(ax):
    w = rb_enter_welcome(ax)
    bs = buttons_named(ax, w.id, "Open File or Folder...")
    if bs:
        ax.action(bs[0].id, "AXPress")
    return find_window(ax, title="Open Workspace or File", timeout=8)


def dismiss_panel_or_sheet(ax):
    """Escape does not work here — press the panel/sheet's own Cancel button."""
    for b in ax.find(role="button", max_results=120, max_depth=10):
        if (b.name or "") == "Cancel":
            ax.action(b.id, "AXPress")
            time.sleep(1.0)
            return True
    return False


def rb_enter_workspace(ax, folder_name="sample_project", timeout=20.0):
    """Open the fixture folder as a workspace the way Finder does: hand the folder to the
    RUNNING app's own bundle (discovered from its pid at runtime — portable)."""
    from AppKit import NSWorkspace, NSRunningApplication, NSWorkspaceOpenConfiguration
    from Foundation import NSURL
    src = os.path.join(FIXTURES_DIR, folder_name)
    base = os.path.join("/tmp", "rb_codeedit_ws")
    dst = os.path.join(base, folder_name)
    if os.path.isdir(base):
        shutil.rmtree(base, ignore_errors=True)
    os.makedirs(base, exist_ok=True)
    shutil.copytree(src, dst)
    ra = NSRunningApplication.runningApplicationWithProcessIdentifier_(int(ax._pid))
    cfg = NSWorkspaceOpenConfiguration.configuration()
    cfg.setActivates_(True)
    NSWorkspace.sharedWorkspace().openURLs_withApplicationAtURL_configuration_completionHandler_(
        [NSURL.fileURLWithPath_(dst)], ra.bundleURL(), cfg, None)
    return find_window(ax, ident="workspace", timeout=timeout)


def project_navigator(ax, ws):
    for o in ax.find(role="outline", root_id=ws.id, max_results=10, max_depth=14):
        if (o.name or "") == "Project Navigator":
            return o
    return None


def navigator_rows(ax, ws):
    nav = project_navigator(ax, ws)
    if nav is None:
        return []
    return [ax.get(t.id, ["AXValue"]).get("AXValue")
            for t in ax.find(role="text_field", root_id=nav.id, max_results=60, max_depth=8)]


def rb_reach_editor(ax, ws, filename):
    """Click a file row in the Project Navigator; returns the editor AXTextArea (or None)."""
    nav = project_navigator(ax, ws)
    if nav is None:
        return None
    rows = ax.find(role="text_field", root_id=nav.id, max_results=60, max_depth=8)
    tgt = [t for t in rows if ax.get(t.id, ["AXValue"]).get("AXValue") == filename]
    if not tgt:
        return None
    ax.click_element_cg(tgt[0].id)
    end = time.time() + 8
    while time.time() < end:
        ta = ax.find(role="text_area", root_id=ws.id, max_results=5, max_depth=18)
        if ta:
            return ta[0]
        time.sleep(0.3)
    return None


def rb_enter_command_palette(ax, ws):
    """Command Palette / Open Quickly only exist while a WORKSPACE window is open."""
    ax.action(ws.id, "AXRaise")
    time.sleep(0.5)
    rb_enter_menu_item(ax, "View", "Show Command Palette", wait=1.6)
    return _overlay_window(ax)


def rb_enter_open_quickly(ax, ws):
    ax.action(ws.id, "AXRaise")
    time.sleep(0.5)
    rb_enter_menu_item(ax, "File", "Open Quickly", wait=1.6)
    return _overlay_window(ax)


def _overlay_window(ax):
    """The palette/quick-open overlay is a borderless AXWindow: no title, no AXIdentifier."""
    for w in all_windows(ax):
        if win_id(ax, w) is None and not (w.name or ""):
            return w
    return None


def overlay_rows(ax, pal):
    return [v for v in (ax.get(t.id, ["AXValue"]).get("AXValue")
                        for t in ax.find(role="label", root_id=pal.id,
                                         max_results=60, max_depth=14)) if v]


def overlay_type(ax, pal, text):
    tf = ax.find(role="text_field", root_id=pal.id, max_results=5, max_depth=8)
    if not tf:
        return False
    ax.set_value(tf[0].id, text)
    time.sleep(1.3)
    return True


def switch_for_label(ax, root_id, label):
    """The AXCheckBox(AXSwitch) that follows the AXStaticText whose AXValue == label."""
    seq = ax.find(root_id=root_id, max_results=400, max_depth=18)
    idx = None
    for i, e in enumerate(seq):
        if e.role == "label" and ax.get(e.id, ["AXValue"]).get("AXValue") == label:
            idx = i
            break
    if idx is None:
        return None
    for e in seq[idx + 1:idx + 4]:
        if e.role == "checkbox":
            return e
    return None


def popup_for_label(ax, root_id, label):
    seq = ax.find(root_id=root_id, max_results=400, max_depth=18)
    idx = None
    for i, e in enumerate(seq):
        if e.role == "label" and ax.get(e.id, ["AXValue"]).get("AXValue") == label:
            idx = i
            break
    if idx is None:
        return None
    for e in seq[idx + 1:idx + 4]:
        if e.role == "popup":
            return e
    return None


def popup_options(ax, popup):
    ax.action(popup.id, "AXPress")
    time.sleep(0.8)
    menus = ax.find(role="menu", root_id=popup.id, max_results=3, max_depth=2)
    out = []
    if menus:
        for i in ax.find(role="menu_item", root_id=menus[0].id, max_results=40, max_depth=2):
            out.append(i.name or ax.get(i.id, ["AXValue"]).get("AXValue"))
        ax.action(menus[0].id, "AXCancel")
        time.sleep(0.4)
    return [o for o in out if o]


def popup_pick(ax, popup, option):
    ax.action(popup.id, "AXPress")
    time.sleep(0.8)
    menus = ax.find(role="menu", root_id=popup.id, max_results=3, max_depth=2)
    if not menus:
        return False
    for i in ax.find(role="menu_item", root_id=menus[0].id, max_results=40, max_depth=2):
        if (i.name or ax.get(i.id, ["AXValue"]).get("AXValue")) == option:
            ax.action(i.id, "AXPick")
            time.sleep(1.0)
            return True
    ax.action(menus[0].id, "AXCancel")
    return False


# ── module-local button helpers (semantic locators only) ────────────────────

CLONE_URL = "https://github.com/CodeEditApp/CodeEdit.git"

# The bundled dependency names recon observed in the Acknowledgements view.
ACK_DEPENDENCIES = [
    "AnyCodable", "ConcurrencyPlus", "FSEventsWrapper", "GRDB.swift", "GlobPattern",
    "JSONRPC", "LanguageClient", "LanguageServerProtocol", "LogStream", "ProcessEnv",
    "Queue", "Rearrange", "Semaphore", "Sparkle", "SwiftLintPlugin", "SwiftTerm",
    "SwiftTreeSitter", "SwiftUI-Introspect", "TextFormation", "TextStory",
    "collectionconcurrencykit", "swift-collections", "swift-snapshot-testing",
    "swift-syntax",
]

# Recon ▸ ENVIRONMENT CONSTRAINTS #6 — these must never be pressed.
FORBIDDEN_GENERAL_PANE_BUTTONS = {"Install", "Check Now", 'Reset "Don\'t Ask Me" Warnings'}
FORBIDDEN_TO_PRESS = FORBIDDEN_GENERAL_PANE_BUTTONS | {
    "Contributors", "Quit CodeEdit", "Close Workspace", "Discard All Changes...",
    "Check for updates...",
}


def norm_quotes(s):
    """Curly/straight quote-insensitive text (a recreation may render either form)."""
    if not isinstance(s, str):
        return ""
    return (s.replace("“", '"').replace("”", '"')
             .replace("‘", "'").replace("’", "'"))


def enabled_of(ax, el):
    return bool(ax.get(el.id, ["AXEnabled"]).get("AXEnabled"))


def control_named(ax, root_id, name, roles=("button", "radio", "tab", "checkbox")):
    """Locate a control by its VISIBLE LABEL (AXTitle/AXDescription) + AXRole, scoped to a
    window — never by child index / tree path / internal identifier. ONE tree walk (a role
    filter would not save any AX traffic), role preference honoured afterwards, so a
    recreation that renders a tab as an AXRadioButton still matches."""
    hits = {}
    for e in ax.find(root_id=root_id, max_results=900, max_depth=16):
        if (e.name or "") == name and e.role in roles:
            hits.setdefault(e.role, e)
    for role in roles:
        if role in hits:
            return hits[role]
    return None


def labelled(showing, text):
    """True iff any `role|name` key in a kit.rb_showing() snapshot ends with `|text`
    (role-agnostic: a recreation may host the same label under a different role)."""
    return any(k.endswith("|" + text) for k in showing)


def popup_labels_in(ax, root_id):
    """Title-or-value of every AXPopUpButton under root (popups label themselves either way)."""
    out = []
    for p in ax.find(role="popup", root_id=root_id, max_results=40, max_depth=16):
        out.append((p.name or "") or str(ax.get(p.id, ["AXValue"]).get("AXValue") or ""))
    return out


def rb_reach_acknowledgements(ax, about_win):
    """About window ▸ press `Acknowledgements` — a real second surface (the copyright view
    is replaced by the bundled-dependency list)."""
    bs = buttons_named(ax, about_win.id, "Acknowledgements")
    if not bs:
        return False
    ax.action(bs[0].id, "AXPress")
    time.sleep(1.6)
    return True


def rb_reach_workspace_tab(ax, ws, tab_name, tab=None, wait=1.6):
    """Workspace ▸ switch navigator / utility-area tab. Recon: workspace tab buttons need a
    REAL CG click (AXPress is a no-op for them). `tab` may be pre-located to save a walk."""
    tab = tab if tab is not None else control_named(ax, ws.id, tab_name)
    if tab is None:
        return None
    ax.click_element_cg(tab.id)
    time.sleep(wait)
    return tab


def cg_click(ax, el, wait=1.4):
    ax.click_element_cg(el.id)
    time.sleep(wait)


# ───────────────────────── Welcome window buttons ─────────────────────────

class TestWelcomeWindowButtons:
    """The 4 buttons recon recorded on `AXWindow id='welcome'`."""

    @pytest.mark.rb(depth=1, jump_kind="reach",
                    expect="pressing 'Create New File...' brings up the modal Save panel — a "
                           "window titled 'Save' carrying Save and Cancel buttons")
    def test_create_new_file_opens_save_panel(self, ax):
        w = rb_enter_welcome(ax)
        assert w is not None, "welcome window not present at launch"
        btn = control_named(ax, w.id, "Create New File...")
        assert btn is not None, "no button labelled 'Create New File...' on the welcome window"
        assert btn.name == "Create New File...", "the button must expose its label via AX"
        assert btn.actions, f"'Create New File...' exposes no AX actions: {btn.actions}"
        assert "AXPress" in btn.actions, f"'Create New File...' has no AXPress: {btn.actions}"

        before = kit.rb_showing(ax)
        # AXPress returns False while the modal panel comes up — recon says IGNORE it and
        # assert the resulting surface instead.
        panel = rb_enter_save_panel(ax)
        after = kit.rb_showing(ax)

        assert panel is not None, "no 'Save' panel appeared after pressing 'Create New File...'"
        assert kit.rb_reach(before, after, target="window|Save"), (
            "the Save panel window did not appear in the AX tree")
        panel_buttons = names_in(ax, panel.id, role="button", max_results=200, max_depth=12)
        assert "Save" in panel_buttons, f"Save panel has no Save button: {panel_buttons[:12]}"
        assert "Cancel" in panel_buttons, f"Save panel has no Cancel button: {panel_buttons[:12]}"
        dismiss_panel_or_sheet(ax)

    @pytest.mark.rb(depth=1, jump_kind="value",
                    expect="the Save panel opened by 'Create New File...' pre-fills its "
                           "'Save As:' text field with exactly 'Untitled'")
    def test_create_new_file_save_panel_default_name(self, ax):
        panel = rb_enter_save_panel(ax)
        assert panel is not None, "'Create New File...' did not open the Save panel"
        fields = ax.find(role="text_field", root_id=panel.id, max_results=10, max_depth=12)
        values = [ax.get(t.id, ["AXValue"]).get("AXValue") for t in fields]
        assert kit.rb_value(values, "Untitled"), (
            f"the Save panel's default file name is not 'Untitled': {values}")
        labels = values_in(ax, panel.id, max_results=160, max_depth=12)
        assert any("Save As" in str(v) for v in labels), (
            f"the Save panel shows no 'Save As:' label: {labels[:14]}")
        dismiss_panel_or_sheet(ax)

    @pytest.mark.rb(depth=1, jump_kind="reach",
                    expect="pressing 'Clone Git Repository...' raises an AXSheet reading "
                           "'Clone a repository' with a URL field, Cancel, and a DISABLED Clone")
    def test_clone_git_repository_opens_sheet(self, ax):
        w = rb_enter_welcome(ax)
        assert w is not None, "welcome window not present at launch"
        btn = control_named(ax, w.id, "Clone Git Repository...")
        assert btn is not None, "no button labelled 'Clone Git Repository...'"
        assert "AXPress" in btn.actions, f"'Clone Git Repository...' has no AXPress: {btn.actions}"

        before = kit.rb_showing(ax)
        sheet = rb_enter_clone_sheet(ax)
        after = kit.rb_showing(ax)

        assert sheet is not None, "no AXSheet appeared after pressing 'Clone Git Repository...'"
        assert kit.rb_reach(before, after, target="Clone a repository"), (
            "the 'Clone a repository' sheet content did not appear")
        sheet_buttons = names_in(ax, sheet.id, role="button", max_results=60, max_depth=12)
        assert "Clone" in sheet_buttons, f"the clone sheet has no Clone button: {sheet_buttons}"
        assert "Cancel" in sheet_buttons, f"the clone sheet has no Cancel button: {sheet_buttons}"
        clone = control_named(ax, sheet.id, "Clone")
        assert clone is not None, "the clone sheet's 'Clone' button is not reachable via AX"
        assert not enabled_of(ax, clone), "Clone must start DISABLED while the URL field is empty"
        screenshot_assert(
            "button_test_clone_sheet",
            "CodeEdit welcome window (centred 740x460 panel, large app icon, 'CodeEdit' and "
            "'Version 0.3.1 (42)') with a modal sheet dropped over it: heading 'Clone a "
            "repository', the prompt 'Enter a git repository URL:', an empty single-line URL "
            "text field, and two buttons at the bottom right — 'Cancel' and a greyed-out "
            "(disabled) 'Clone'.")
        dismiss_panel_or_sheet(ax)

    @pytest.mark.rb(depth=1, jump_kind="reach",
                    expect="pressing 'Open File or Folder...' replaces the welcome window with "
                           "the modal 'Open Workspace or File' panel in the AX window list")
    def test_open_file_or_folder_opens_open_panel(self, ax):
        w = rb_enter_welcome(ax)
        assert w is not None, "welcome window not present at launch"
        btn = control_named(ax, w.id, "Open File or Folder...")
        assert btn is not None, "no button labelled 'Open File or Folder...'"
        assert "AXPress" in btn.actions, f"'Open File or Folder...' has no AXPress: {btn.actions}"

        before = kit.rb_showing(ax)
        panel = rb_enter_open_panel(ax)
        after = kit.rb_showing(ax)

        assert panel is not None, "no 'Open Workspace or File' panel appeared"
        assert kit.rb_reach(before, after,
                            target="window|Open Workspace or File",
                            source="window|Welcome To CodeEdit"), (
            "the open panel did not replace the welcome window in the AX window list")
        panel_buttons = names_in(ax, panel.id, role="button", max_results=200, max_depth=12)
        assert "Open" in panel_buttons, f"the open panel has no Open button: {panel_buttons[:14]}"
        assert "Cancel" in panel_buttons, f"the open panel has no Cancel button: {panel_buttons[:14]}"
        dismiss_panel_or_sheet(ax)

    @pytest.mark.rb(depth=0, jump_kind="transition",
                    expect="pressing the welcome window's 'Close' button removes "
                           "'Welcome To CodeEdit' from the app's AX window list")
    def test_welcome_close_button_removes_window(self, ax):
        w = rb_enter_welcome(ax)
        assert w is not None, "welcome window not present at launch"
        btn = control_named(ax, w.id, "Close")
        assert btn is not None, "the welcome window has no button labelled 'Close'"
        assert "AXPress" in btn.actions, f"'Close' has no AXPress action: {btn.actions}"

        before = sorted(x.name or "" for x in all_windows(ax))
        ax.action(btn.id, "AXPress")
        time.sleep(1.2)
        after = sorted(x.name or "" for x in all_windows(ax))

        assert kit.rb_flip(before, after, "welcome window closed"), (
            f"the window list did not change after pressing Close: {before}")
        assert "Welcome To CodeEdit" in before, f"welcome window missing before Close: {before}"
        assert "Welcome To CodeEdit" not in after, (
            f"the welcome window is still listed after pressing Close: {after}")


# ───────────────────────── Clone sheet buttons (depth 1) ─────────────────────────

class TestCloneSheetButtons:
    """Buttons on the AXSheet raised by the welcome `Clone Git Repository...` button."""

    @pytest.mark.rb(depth=1, jump_kind="transition",
                    expect="the clone sheet's 'Clone' button flips AXEnabled False -> True once "
                           "a git repository URL is entered in the sheet's text field")
    def test_clone_button_enables_once_url_entered(self, ax):
        sheet = rb_enter_clone_sheet(ax)
        assert sheet is not None, "'Clone Git Repository...' did not raise the clone sheet"
        clone = control_named(ax, sheet.id, "Clone")
        assert clone is not None, "the clone sheet has no button labelled 'Clone'"
        assert clone.actions, "'Clone' exposes no AX actions"
        before = enabled_of(ax, clone)

        fields = ax.find(role="text_field", root_id=sheet.id, max_results=5, max_depth=10)
        assert fields, "the clone sheet exposes no AXTextField for the git URL"
        ax.set_value(fields[0].id, CLONE_URL)
        time.sleep(1.2)

        clone_after = control_named(ax, sheet.id, "Clone")
        assert clone_after is not None, "the 'Clone' button vanished after entering the URL"
        after = enabled_of(ax, clone_after)

        assert kit.rb_flip(before, after, "Clone enabled-state"), (
            f"Clone's enabled-state did not change (before={before}, after={after})")
        assert before is False, "Clone must be DISABLED while the URL field is empty"
        assert after is True, "Clone must become ENABLED once a valid git URL is entered"
        dismiss_panel_or_sheet(ax)

    @pytest.mark.rb(depth=1, jump_kind="transition",
                    expect="pressing the clone sheet's 'Cancel' takes the AXSheet count 1 -> 0 "
                           "and the 'Clone a repository' text disappears")
    def test_clone_sheet_cancel_dismisses_sheet(self, ax):
        sheet = rb_enter_clone_sheet(ax)
        assert sheet is not None, "'Clone Git Repository...' did not raise the clone sheet"
        cancel = control_named(ax, sheet.id, "Cancel")
        assert cancel is not None, "the clone sheet has no button labelled 'Cancel'"
        assert "AXPress" in cancel.actions, f"'Cancel' has no AXPress action: {cancel.actions}"

        before = len(ax.find(role="sheet", max_results=5, max_depth=6))
        ax.action(cancel.id, "AXPress")
        time.sleep(1.2)
        after = len(ax.find(role="sheet", max_results=5, max_depth=6))

        assert kit.rb_flip(before, after, "sheet count"), (
            f"the sheet count did not change after Cancel (before={before}, after={after})")
        assert before == 1, f"expected exactly 1 sheet before Cancel, saw {before}"
        assert after == 0, f"the clone sheet is still up after Cancel ({after} sheets)"
        w = find_window(ax, ident="welcome", timeout=4)
        assert w is not None, "the welcome window did not come back after cancelling the sheet"
        assert not any("Clone a repository" in str(v)
                       for v in values_in(ax, w.id, max_results=160, max_depth=12)), (
            "'Clone a repository' text is still present after Cancel")


# ───────────────────────── About window buttons (depth 2) ─────────────────────────

class TestAboutWindowButtons:
    """`Acknowledgements` swaps the About window's content. `Contributors` is network-backed
    (recon ▸ UNREACHED) and is never pressed."""

    @pytest.mark.rb(depth=2, jump_kind="reach",
                    expect="About ▸ 'Acknowledgements' swaps the copyright view for the bundled "
                           "dependency list: 'Sparkle' appears and 'Copyright ©' disappears")
    def test_acknowledgements_button_reveals_dependency_list(self, ax):
        w = rb_enter_about_window(ax)
        assert w is not None, "'CodeEdit > About CodeEdit' did not open the About window"
        btn = control_named(ax, w.id, "Acknowledgements")
        assert btn is not None, "the About window has no button labelled 'Acknowledgements'"
        assert "AXPress" in btn.actions, f"'Acknowledgements' has no AXPress: {btn.actions}"
        assert "Contributors" in names_in(ax, w.id, role="button", max_results=60, max_depth=12), (
            "the About window should also offer a 'Contributors' button (never pressed here)")

        before = kit.rb_showing(ax, max_depth=14)
        assert rb_reach_acknowledgements(ax, w), "pressing 'Acknowledgements' failed"
        after = kit.rb_showing(ax, max_depth=14)

        assert kit.rb_reach(before, after, target="Sparkle", source="Copyright ©"), (
            "the Acknowledgements view did not replace the copyright view")

    @pytest.mark.rb(depth=2, jump_kind="value",
                    expect="the Acknowledgements view lists the bundled dependencies AnyCodable, "
                           "Sparkle, SwiftTerm and swift-syntax (>=10 of the 24 recon recorded)")
    def test_acknowledgements_lists_bundled_dependencies(self, ax):
        w = rb_enter_about_window(ax)
        assert w is not None, "'CodeEdit > About CodeEdit' did not open the About window"
        assert rb_reach_acknowledgements(ax, w), "pressing 'Acknowledgements' failed"

        seen = (values_in(ax, w.id, max_results=400, max_depth=16)
                + names_in(ax, w.id, max_results=400, max_depth=16))
        for dep in ("AnyCodable", "Sparkle", "SwiftTerm", "swift-syntax"):
            assert kit.rb_value(seen, dep), (
                f"dependency {dep!r} is missing from the Acknowledgements view")
        found = [d for d in ACK_DEPENDENCIES if any(d == str(s) for s in seen)]
        assert len(found) >= 10, (
            f"only {len(found)} of the {len(ACK_DEPENDENCIES)} bundled dependencies are "
            f"listed: {found}")


# ───────────────────────── Extensions toolbar toggle button ─────────────────────────

class TestExtensionsToolbarButton:

    @pytest.mark.rb(depth=1, jump_kind="transition",
                    expect="the Extensions toolbar toggle renames 'Hide Sidebar' -> "
                           "'Show Sidebar' (splitter 140.0 -> -1.0) and pressing it again "
                           "restores 'Hide Sidebar'")
    def test_hide_sidebar_toolbar_button_toggles(self, ax):
        w = rb_enter_extensions_window(ax)
        assert w is not None, "'Extensions > Open Extensions Window' did not open the window"
        btn = control_named(ax, w.id, "Hide Sidebar")
        assert btn is not None, "the Extensions toolbar has no 'Hide Sidebar' button"
        assert btn.name, "toolbar buttons must carry a descriptive accessibility label"
        assert "AXPress" in btn.actions, f"'Hide Sidebar' has no AXPress action: {btn.actions}"

        def state():
            names = names_in(ax, w.id, role="button", max_results=80, max_depth=14)
            splits = [ax.get(s.id, ["AXValue"]).get("AXValue")
                      for s in ax.find(role="splitter", root_id=w.id,
                                       max_results=5, max_depth=14)]
            return ("Hide Sidebar" in names, "Show Sidebar" in names, splits)

        before = state()
        ax.action(btn.id, "AXPress")
        time.sleep(1.4)
        after = state()

        assert kit.rb_flip(before, after, "sidebar toolbar toggle"), (
            f"nothing changed after pressing 'Hide Sidebar' (state={before})")
        assert before[0] and not before[1], f"expected 'Hide Sidebar' initially: {before}"
        assert after[1], f"the toolbar button did not rename to 'Show Sidebar': {after}"
        assert not after[0], f"'Hide Sidebar' is still shown after collapsing: {after}"
        screenshot_assert(
            "button_test_extensions_hide_sidebar",
            "CodeEdit 'Extensions' window (split view) after its toolbar sidebar toggle was "
            "pressed: the empty left sidebar list is collapsed away, the toolbar button now "
            "reads 'Show Sidebar', and the right pane still shows the placeholder text "
            "'Select an extension'.")

        # toggle back off — recon: "Pressing again restores."
        back = control_named(ax, w.id, "Show Sidebar")
        assert back is not None, "'Show Sidebar' is not available to toggle the sidebar back"
        ax.action(back.id, "AXPress")
        time.sleep(1.4)
        restored = state()
        assert kit.rb_flip(after, restored, "sidebar toolbar toggle back"), (
            f"pressing 'Show Sidebar' changed nothing (state={after})")
        assert restored[0], f"'Hide Sidebar' did not come back after re-showing: {restored}"


# ───────────────────────── Settings window buttons ─────────────────────────

class TestSettingsPaneButtons:
    """Sidebar pane rows are selected with a REAL CG click (recon: AXPress does not select).
    The `Install` / `Check Now` / `Reset "Don't Ask Me" Warnings` buttons and the Locations
    path buttons are asserted by name + enabled-state ONLY — never pressed."""

    @pytest.mark.rb(depth=2, jump_kind="reach",
                    expect="the Accounts sidebar pane replaces the General pane and shows "
                           "'No accounts' next to an enabled 'Add Account...' button")
    def test_accounts_pane_add_account_button(self, ax):
        w = rb_enter_settings_window(ax)
        assert w is not None, "'CodeEdit > Settings...' did not open the Settings window"
        before = kit.rb_showing(ax, max_depth=16)
        pane = rb_reach_settings_pane(ax, "Accounts")
        after = kit.rb_showing(ax, max_depth=16)

        assert pane is not None, "could not select the 'Accounts' sidebar pane"
        assert kit.rb_reach(before, after, target="No accounts", source="File Icon Style"), (
            "the Accounts pane content did not replace the General pane content")
        add = control_named(ax, pane.id, "Add Account...")
        assert add is not None, "the Accounts pane has no 'Add Account...' button"
        assert add.actions, "'Add Account...' exposes no AX actions"
        assert enabled_of(ax, add), "'Add Account...' should be enabled"


    @pytest.mark.rb(depth=2, jump_kind="reach",
                    expect="the Search sidebar pane replaces the General pane and shows "
                           "'No excluded glob patterns' with its 'Add' and 'Remove' buttons")
    def test_search_pane_add_and_remove_buttons(self, ax):
        w = rb_enter_settings_window(ax)
        assert w is not None, "'CodeEdit > Settings...' did not open the Settings window"
        before = kit.rb_showing(ax, max_depth=16)
        pane = rb_reach_settings_pane(ax, "Search")
        after = kit.rb_showing(ax, max_depth=16)

        assert pane is not None, "could not select the 'Search' sidebar pane"
        assert kit.rb_reach(before, after,
                            target="No excluded glob patterns", source="File Icon Style"), (
            "the Search pane content did not replace the General pane content")
        add = control_named(ax, pane.id, "Add")
        rem = control_named(ax, pane.id, "Remove")
        assert add is not None, "the Search pane has no 'Add' button"
        assert rem is not None, "the Search pane has no 'Remove' button"
        assert add.actions and rem.actions, "the Add/Remove buttons expose no AX actions"
        assert enabled_of(ax, add), "'Add' should be enabled on the Search pane"


    @pytest.mark.rb(depth=1, jump_kind="value",
                    expect="the Locations pane's 4 path buttons are named "
                           "'<Application Support|Settings|Themes|Extensions>, <path>', are all "
                           "enabled, and every path points inside "
                           "Library/Application Support/CodeEdit "
                           "(recon: never press — they open Finder)")
    def test_locations_pane_path_button_names(self, ax):
        pane = rb_reach_settings_pane(ax, "Locations")
        assert pane is not None, "could not reach the Settings 'Locations' pane"
        buttons = [b for b in ax.find(role="button", root_id=pane.id,
                                      max_results=300, max_depth=16) if b.name]
        names = [b.name for b in buttons]
        for label in ("Application Support", "Settings", "Themes", "Extensions"):
            hit = [b for b in buttons if b.name.startswith(label + ", ")]
            assert hit, (
                f"the Locations pane has no '{label}, <path>' button; "
                f"saw {sorted(set(names))[:14]}")
            path = hit[0].name.replace("%20", " ")
            assert kit.rb_value(path, "Library/Application Support/CodeEdit"), (
                f"the '{label}' path button does not point inside the app-support folder: "
                f"{hit[0].name!r}")
            assert enabled_of(ax, hit[0]), f"the '{label}' path button should be enabled"


# ───────────────────── Workspace toolbar buttons (CG clicks) ─────────────────────

class TestWorkspaceToolbarButtons:

    @pytest.mark.rb(depth=1, jump_kind="transition",
                    expect="the workspace toolbar 'Navigator Sidebar' button collapses the "
                           "navigator: the Project Navigator outline and the Project / "
                           "Source Control / Search tab buttons all disappear")
    def test_navigator_sidebar_button_hides_navigator(self, ax):
        ws = rb_enter_workspace(ax)
        assert ws is not None, "the fixture folder did not open as a workspace window"
        btn = control_named(ax, ws.id, "Navigator Sidebar")
        assert btn is not None, "the workspace toolbar has no 'Navigator Sidebar' button"
        assert btn.name, "toolbar buttons must carry a descriptive accessibility label"
        assert btn.actions, "'Navigator Sidebar' exposes no AX actions"

        def state():
            return (project_navigator(ax, ws) is not None,
                    control_named(ax, ws.id, "Source Control") is not None)

        before = state()
        cg_click(ax, btn)
        after = state()

        assert kit.rb_flip(before, after, "navigator visibility"), (
            f"the navigator did not change after clicking 'Navigator Sidebar' ({before})")
        assert before == (True, True), f"the navigator should start visible: {before}"
        assert after == (False, False), (
            f"the navigator outline / tab buttons are still present after collapsing: {after}")



# ───────────────────── Workspace navigator tab buttons (CG clicks) ─────────────────────

class TestWorkspaceNavigatorTabButtons:

    @pytest.mark.rb(depth=2, jump_kind="reach",
                    expect="the navigator 'Source Control' tab button replaces the Project "
                           "Navigator with 'No Repository', 'This project is not a git "
                           "repository.' and an 'Initialize' button")
    def test_source_control_tab_button(self, ax):
        ws = rb_enter_workspace(ax)
        assert ws is not None, "the fixture folder did not open as a workspace window"
        tab = control_named(ax, ws.id, "Source Control")
        assert tab is not None, "the navigator has no 'Source Control' tab button"
        assert tab.name, "navigator tab buttons must carry a descriptive label"
        assert tab.actions, "the 'Source Control' tab exposes no AX actions"

        before = kit.rb_showing(ax, max_depth=16)
        assert rb_reach_workspace_tab(ax, ws, "Source Control", tab=tab) is not None, (
            "could not click the 'Source Control' navigator tab")
        after = kit.rb_showing(ax, max_depth=16)

        assert kit.rb_reach(before, after,
                            target="No Repository", source="outline|Project Navigator"), (
            "the Source Control navigator did not replace the Project Navigator")
        seen = values_in(ax, ws.id, max_results=300, max_depth=16)
        assert any("not a git repository" in str(v) for v in seen), (
            "the Source Control navigator does not explain that this is not a git repository")
        assert control_named(ax, ws.id, "Initialize") is not None, (
            "the Source Control navigator has no 'Initialize' button")

    @pytest.mark.rb(depth=2, jump_kind="reach",
                    expect="the navigator 'Search' tab button reveals the find-scope popups "
                           "'Find', 'Text' and 'Containing'")
    def test_search_tab_button(self, ax):
        ws = rb_enter_workspace(ax)
        assert ws is not None, "the fixture folder did not open as a workspace window"
        tab = control_named(ax, ws.id, "Search")
        assert tab is not None, "the navigator has no 'Search' tab button"
        assert tab.name, "navigator tab buttons must carry a descriptive label"
        assert tab.actions, "the 'Search' tab exposes no AX actions"

        before = kit.rb_showing(ax, max_depth=16)
        assert rb_reach_workspace_tab(ax, ws, "Search", tab=tab) is not None, (
            "could not click the 'Search' navigator tab")
        after = kit.rb_showing(ax, max_depth=16)

        assert kit.rb_reach(before, after, target="Containing"), (
            "the search navigator's 'Containing' scope popup did not appear")
        labels = popup_labels_in(ax, ws.id)
        for expected in ("Find", "Text", "Containing"):
            assert any(expected in p for p in labels), (
                f"the search navigator popup {expected!r} is missing; saw {labels}")

    @pytest.mark.rb(depth=2, jump_kind="value",
                    expect="clicking the navigator 'Project' tab after 'Source Control' brings "
                           "the Project Navigator back listing sample_project, src, README.md, "
                           "hello.py and notes.txt")
    def test_project_tab_button_restores_file_rows(self, ax):
        ws = rb_enter_workspace(ax)
        assert ws is not None, "the fixture folder did not open as a workspace window"
        assert rb_reach_workspace_tab(ax, ws, "Source Control") is not None, (
            "could not click the 'Source Control' navigator tab")
        assert project_navigator(ax, ws) is None, (
            "the Project Navigator is still shown while on the Source Control tab")

        project = control_named(ax, ws.id, "Project")
        assert project is not None, "the navigator has no 'Project' tab button"
        assert project.actions, "the 'Project' tab exposes no AX actions"
        assert rb_reach_workspace_tab(ax, ws, "Project", tab=project) is not None, (
            "could not click the 'Project' navigator tab")

        assert project_navigator(ax, ws) is not None, (
            "the Project Navigator did not come back after clicking the 'Project' tab")
        rows = [r for r in navigator_rows(ax, ws) if r]
        for name in ("sample_project", "src", "README.md", "hello.py", "notes.txt"):
            assert kit.rb_value(rows, name), (
                f"the project-navigator row {name!r} is missing after returning to the "
                f"Project tab: {rows}")


# ───────────────────── Workspace utility-area tab buttons (CG clicks) ─────────────────────

class TestWorkspaceUtilityTabButtons:

    @pytest.mark.rb(depth=2, jump_kind="reach",
                    expect="the utility-area 'Debug Console' tab button replaces the terminal "
                           "with 'No Task Selected' / 'No Tasks are Running'")
    def test_debug_console_tab_button(self, ax):
        ws = rb_enter_workspace(ax)
        assert ws is not None, "the fixture folder did not open as a workspace window"
        tab = control_named(ax, ws.id, "Debug Console")
        assert tab is not None, "the utility area has no 'Debug Console' tab button"
        assert tab.name, "utility-area tab buttons must carry a descriptive label"
        assert tab.actions, "the 'Debug Console' tab exposes no AX actions"

        before = kit.rb_showing(ax, max_depth=16)
        assert rb_reach_workspace_tab(ax, ws, "Debug Console", tab=tab) is not None, (
            "could not click the 'Debug Console' utility tab")
        after = kit.rb_showing(ax, max_depth=16)

        assert kit.rb_reach(before, after, target="No Task Selected"), (
            "the Debug Console pane did not appear after clicking its tab")
        seen = values_in(ax, ws.id, max_results=300, max_depth=16)
        assert any("No Tasks are Running" in str(v) for v in seen), (
            "the Debug Console does not report 'No Tasks are Running'")

    @pytest.mark.rb(depth=2, jump_kind="value",
                    expect="the utility-area 'Output' tab button shows the empty output view: "
                           "the exact placeholder 'No output' plus an 'Output Source' popup")
    def test_output_tab_button(self, ax):
        ws = rb_enter_workspace(ax)
        assert ws is not None, "the fixture folder did not open as a workspace window"
        tab = control_named(ax, ws.id, "Output")
        assert tab is not None, "the utility area has no 'Output' tab button"
        assert tab.name, "utility-area tab buttons must carry a descriptive label"
        assert tab.actions, "the 'Output' tab exposes no AX actions"

        assert rb_reach_workspace_tab(ax, ws, "Output", tab=tab) is not None, (
            "could not click the 'Output' utility tab")

        seen = values_in(ax, ws.id, max_results=300, max_depth=16)
        assert kit.rb_value(seen, "No output"), (
            f"the Output pane does not show the 'No output' placeholder: {seen[:16]}")
        labels = popup_labels_in(ax, ws.id)
        assert kit.rb_value(labels, "Output Source"), (
            f"the Output pane has no 'Output Source' popup; saw {labels}")