quick_search/crates/quicksearch-gui/src/manage_tab/tests.rs

use super::*;

use std::cell::RefCell;
use std::sync::Arc;

use quicksearch_core::coordinator::RootCount;
use quicksearch_core::db::repo::RootCounts;

// Widgets under test report themselves here for cross-frame identity checks.
thread_local! {
    static WIDGETS: RefCell<Vec<(&'static str, egui::Id, egui::Rect)>> =
        const { RefCell::new(Vec::new()) };
}

pub(super) fn record_widget(tag: &'static str, response: &egui::Response) {
    WIDGETS.with(|w| w.borrow_mut().push((tag, response.id, response.rect)));
}

fn widget(tag: &str) -> (egui::Id, egui::Rect) {
    WIDGETS.with(|w| {
        w.borrow()
            .iter()
            .find(|(t, _, _)| *t == tag)
            .map(|(_, id, rect)| (*id, *rect))
            .unwrap_or_else(|| panic!("{} widget was not drawn", tag))
    })
}

fn idle_state() -> IndexerState {
    IndexerState {
        mode: IndexMode::Auto,
        activity: IndexingStatus::Idle,
        last_full_index: Some(0),
        files: Some(0),
        queued_events: 0,
        watcher: WatcherStatus::Active { dirs: 10 },
        reconcile: None,
        root_counts: Arc::new(Vec::new()),
    }
}

/// Idle, carrying figures for `/data` — the root `cfg_with_root` configures.
fn counted_state(files: i64, fts: i64) -> IndexerState {
    IndexerState {
        root_counts: Arc::new(vec![RootCount {
            root: "/data".into(),
            counts: RootCounts { files, fts },
        }]),
        ..idle_state()
    }
}

/// A run in progress; `current_file` and the root count are the parts that
/// come and go from frame to frame.
fn running_state(roots: &[&str], current_file: Option<&str>) -> IndexerState {
    state_with(
        roots
            .iter()
            .map(|root| RootProgress {
                root: (*root).to_string(),
                phase: RootPhase::Walking,
                walked: 100,
                walk_total: Some(1000),
                extracted: 0,
                extract_total: None,
                current_file: current_file.map(str::to_string),
                active_workers: 4,
                total_workers: 4,
            })
            .collect(),
    )
}

fn state_with(roots: Vec<RootProgress>) -> IndexerState {
    maintaining_state(roots, None)
}

fn maintaining_state(roots: Vec<RootProgress>, step: Option<MaintenanceStep>) -> IndexerState {
    IndexerState {
        activity: IndexingStatus::Running {
            start_time: std::time::Instant::now(),
            roots,
            maintenance: step,
        },
        ..idle_state()
    }
}

fn preparing_state(step: PrepStep) -> IndexerState {
    IndexerState {
        activity: IndexingStatus::Preparing {
            start_time: std::time::Instant::now(),
            step,
        },
        ..idle_state()
    }
}

use crate::test_ui::{click_at, painted_text};

fn raw_input(events: Vec<egui::Event>) -> egui::RawInput {
    crate::test_ui::raw_input(egui::vec2(1000.0, 900.0), events)
}

fn frame(
    ctx: &egui::Context,
    tab: &mut ManageTab,
    cfg: &Config,
    state: &IndexerState,
    events: Vec<egui::Event>,
) -> ManageActions {
    WIDGETS.with(|w| w.borrow_mut().clear());
    let mut actions = ManageActions::default();
    let out = ctx.run(raw_input(events), |ctx| {
        egui::CentralPanel::default().show(ctx, |ui| {
            actions = tab.ui(ui, state, cfg);
        });
    });
    crate::test_ui::assert_no_tofu(ctx, &out);
    actions
}

fn frame_text(ctx: &egui::Context, tab: &mut ManageTab, state: &IndexerState) -> Vec<String> {
    frame_text_with(ctx, tab, &cfg_with_root(), state)
}

fn frame_text_with(
    ctx: &egui::Context,
    tab: &mut ManageTab,
    cfg: &Config,
    state: &IndexerState,
) -> Vec<String> {
    WIDGETS.with(|w| w.borrow_mut().clear());
    let out = ctx.run(raw_input(vec![]), |ctx| {
        egui::CentralPanel::default().show(ctx, |ui| {
            tab.ui(ui, state, cfg);
        });
    });
    painted_text(&out)
}

fn pointer(pos: egui::Pos2, pressed: bool) -> egui::Event {
    egui::Event::PointerButton {
        pos,
        button: egui::PointerButton::Primary,
        pressed,
        modifiers: egui::Modifiers::NONE,
    }
}

fn cfg_with_root() -> Config {
    let mut cfg = Config::default();
    cfg.paths.indexing_paths = vec!["/data".into()];
    cfg
}

fn staged_workers(tab: &ManageTab) -> Option<usize> {
    tab.draft
        .as_ref()
        .unwrap()
        .indexing
        .root_workers
        .get("/data")
        .copied()
}

/// egui hangs focus and in-progress text off the widget id, so a field
/// renamed mid-run silently drops the edit.
#[test]
fn the_worker_field_keeps_its_identity_as_the_status_changes() {
    let ctx = crate::test_ui::ctx();
    let mut tab = ManageTab::new();
    let cfg = cfg_with_root();

    frame(
        &ctx,
        &mut tab,
        &cfg,
        &running_state(&["/data"], None),
        vec![],
    );
    let (baseline, _) = widget("workers");

    for state in [
        running_state(&["/data"], Some("/data/file")),
        running_state(&["/data", "/other"], None),
        idle_state(),
        // The per-root figures share the field's row — the case a
        // conditionally-drawn label would break.
        counted_state(1_234_567, 456_789),
        IndexerState {
            watcher: WatcherStatus::Off,
            ..idle_state()
        },
        IndexerState {
            activity: IndexingStatus::Error("boom".into()),
            ..idle_state()
        },
    ] {
        frame(&ctx, &mut tab, &cfg, &state, vec![]);
        assert_eq!(
            widget("workers").0,
            baseline,
            "status change moved the worker field"
        );
    }
}

/// Type a count and apply it — while a run reports progress the whole time.
#[test]
fn a_typed_worker_count_reaches_the_applied_config() {
    let ctx = crate::test_ui::ctx();
    let mut tab = ManageTab::new();
    let cfg = cfg_with_root();

    frame(
        &ctx,
        &mut tab,
        &cfg,
        &running_state(&["/data"], None),
        vec![],
    );
    let field = widget("workers").1.center();
    frame(
        &ctx,
        &mut tab,
        &cfg,
        &running_state(&["/data"], None),
        click_at(field),
    );
    // The run starts reporting a file: one more label above the field.
    let busy = running_state(&["/data"], Some("/data/file"));
    frame(&ctx, &mut tab, &cfg, &busy, vec![]);
    frame(
        &ctx,
        &mut tab,
        &cfg,
        &busy,
        vec![egui::Event::Text("8".into())],
    );
    assert_eq!(staged_workers(&tab), Some(8), "typed count was not staged");

    let apply = widget("apply").1.center();
    let mut actions = frame(&ctx, &mut tab, &cfg, &busy, click_at(apply));
    if actions.apply_config.is_none() {
        // egui fires a click on release; give it the follow-up frame.
        actions = frame(&ctx, &mut tab, &cfg, &busy, vec![]);
    }
    let applied = actions
        .apply_config
        .expect("Apply & Save produced a config");
    assert_eq!(applied.indexing.root_workers.get("/data"), Some(&8));
}

#[test]
fn a_dragged_worker_count_is_staged() {
    let ctx = crate::test_ui::ctx();
    let mut tab = ManageTab::new();
    let cfg = cfg_with_root();
    let busy = running_state(&["/data"], None);

    frame(&ctx, &mut tab, &cfg, &busy, vec![]);
    let field = widget("workers").1.center();
    frame(
        &ctx,
        &mut tab,
        &cfg,
        &busy,
        vec![egui::Event::PointerMoved(field), pointer(field, true)],
    );
    // Drag right across frames, with the status changing underneath.
    let mut pos = field;
    for state in [
        running_state(&["/data"], Some("/data/a")),
        running_state(&["/data"], None),
        running_state(&["/data"], Some("/data/b")),
    ] {
        pos.x += 4.0;
        frame(
            &ctx,
            &mut tab,
            &cfg,
            &state,
            vec![egui::Event::PointerMoved(pos)],
        );
    }
    frame(&ctx, &mut tab, &cfg, &busy, vec![pointer(pos, false)]);
    assert!(
        staged_workers(&tab).is_some_and(|w| w > 0),
        "dragging staged nothing: {:?}",
        staged_workers(&tab)
    );
}

fn root_progress(phase: RootPhase, walked: usize, walk_total: Option<usize>) -> RootProgress {
    RootProgress {
        root: "/data".to_string(),
        phase,
        walked,
        walk_total,
        extracted: 0,
        extract_total: None,
        current_file: None,
        active_workers: 4,
        total_workers: 4,
    }
}

/// The walk-total estimate counts *tree entries* and runs far ahead of the
/// files a walk emits.
#[test]
fn a_finished_root_reports_its_exact_count_not_the_estimate() {
    let ctx = crate::test_ui::ctx();
    let mut tab = ManageTab::new();
    let mut done = root_progress(RootPhase::Done, 261_088, Some(6_677_062));
    done.extracted = 238_929;
    done.active_workers = 0;
    done.total_workers = 0;

    let text = frame_text(&ctx, &mut tab, &state_with(vec![done])).join(" | ");
    assert!(
        text.contains("indexed 261,088, extracted 238,929"),
        "finished row: {}",
        text
    );
    assert!(
        !text.contains("6,677,062"),
        "the stale estimate is still on screen: {}",
        text
    );
}

#[test]
fn a_configured_root_shows_what_the_last_run_counted() {
    let ctx = crate::test_ui::ctx();
    let mut tab = ManageTab::new();

    let text = frame_text(&ctx, &mut tab, &counted_state(1_234_567, 456_789)).join(" | ");
    assert!(
        text.contains("indexed 1,234,567 · extracted 456,789"),
        "folder row: {}",
        text
    );
}

/// Zero would claim the folder is empty; the truth is nothing counted it yet.
#[test]
fn a_root_the_index_has_never_counted_says_so() {
    let ctx = crate::test_ui::ctx();
    let mut tab = ManageTab::new();

    let text = frame_text(&ctx, &mut tab, &idle_state()).join(" | ");
    assert!(text.contains("not yet indexed"), "folder row: {}", text);
    assert!(
        !text.contains("indexed 0 · extracted 0"),
        "an uncounted root must not read as an empty one: {}",
        text
    );
}

#[test]
fn figures_belong_to_the_root_they_were_counted_for() {
    let ctx = crate::test_ui::ctx();
    let mut tab = ManageTab::new();
    let state = IndexerState {
        root_counts: Arc::new(vec![RootCount {
            root: "/somewhere-else".into(),
            counts: RootCounts { files: 99, fts: 9 },
        }]),
        ..idle_state()
    };

    let text = frame_text(&ctx, &mut tab, &state).join(" | ");
    assert!(text.contains("not yet indexed"), "folder row: {}", text);
    assert!(
        !text.contains("99"),
        "borrowed another root's count: {}",
        text
    );
}

/// Never below what has already been walked, or the row reads as a hang at 100%.
#[test]
fn a_walking_root_shows_the_estimate_raised_to_what_it_has_walked() {
    let ctx = crate::test_ui::ctx();
    let mut tab = ManageTab::new();

    let honest = frame_text(
        &ctx,
        &mut tab,
        &state_with(vec![root_progress(RootPhase::Walking, 100, Some(1000))]),
    )
    .join(" | ");
    assert!(honest.contains("100 / 1,000 (10%)"), "{}", honest);

    let overtaken = frame_text(
        &ctx,
        &mut tab,
        &state_with(vec![root_progress(RootPhase::Walking, 1500, Some(1000))]),
    )
    .join(" | ");
    assert!(
        overtaken.contains("1,500 / 1,500 (100%)"),
        "an overtaken estimate must be raised, not shown: {}",
        overtaken
    );
}

fn frame_spans(
    ctx: &egui::Context,
    tab: &mut ManageTab,
    state: &IndexerState,
) -> Vec<(String, egui::Color32)> {
    WIDGETS.with(|w| w.borrow_mut().clear());
    let cfg = cfg_with_root();
    let out = ctx.run(raw_input(vec![]), |ctx| {
        egui::CentralPanel::default().show(ctx, |ui| {
            tab.ui(ui, state, &cfg);
        });
    });
    crate::test_ui::painted_spans(&out)
}

#[test]
fn every_phase_word_is_painted_in_its_hint_color() {
    for theme in [egui::Theme::Dark, egui::Theme::Light] {
        let ctx = crate::test_ui::ctx();
        ctx.set_theme(theme);
        let mut tab = ManageTab::new();
        let colors = crate::color::palette(theme == egui::Theme::Dark);

        for (phase, word, want) in [
            (RootPhase::Walking, "indexing", colors.yellow),
            (RootPhase::Extracting, "extracting text", colors.green),
            (RootPhase::Done, "done", colors.blue),
        ] {
            let state = state_with(vec![root_progress(phase, 100, Some(1000))]);
            let spans = frame_spans(&ctx, &mut tab, &state);
            let hint = spans.iter().find(|(text, _)| text == word).map(|(_, c)| *c);
            assert_eq!(hint, Some(want), "{:?}: {:?} in {:?}", theme, word, spans);

            // Upkeep blocks the writer whatever the root was doing, so it
            // replaces the phase word rather than sitting beside it.
            let state = maintaining_state(
                vec![root_progress(phase, 100, Some(1000))],
                Some(MaintenanceStep::Checkpoint),
            );
            let spans = frame_spans(&ctx, &mut tab, &state);
            let painted = |want: &str| spans.iter().find(|(t, _)| t == want).map(|(_, c)| *c);
            assert_eq!(
                painted("maintenance"),
                Some(colors.orange),
                "{:?}: {:?}",
                theme,
                spans
            );
            assert_eq!(
                painted(word),
                None,
                "{:?}: {:?} survived: {:?}",
                theme,
                word,
                spans
            );
        }
    }
}

/// Run-wide state: said once, however many roots are on screen. And said
/// *alongside* the per-root file hints rather than instead of them.
///
/// The hint count is the assertion that matters. A checkpoint fires every few
/// seconds on a large index, so a line that disappears per root and comes back
/// reflowed the whole block on a loop. Keeping it costs a moment of staleness
/// (it names the last file written, not one in flight) and buys a row that
/// holds its height.
#[test]
fn an_upkeep_step_names_itself_once_and_keeps_the_file_hints() {
    let ctx = crate::test_ui::ctx();
    let mut tab = ManageTab::new();

    let with_file = |root: &str| RootProgress {
        root: root.to_string(),
        current_file: Some("/data/a-file-that-already-landed.txt".to_string()),
        ..root_progress(RootPhase::Extracting, 100, Some(1000))
    };
    let roots = vec![with_file("/data"), with_file("/media")];
    let hints = |drawn: &[String]| {
        drawn
            .iter()
            .filter(|t| t.contains("a-file-that-already-landed.txt"))
            .count()
    };

    let running = frame_text(&ctx, &mut tab, &state_with(roots.clone()));
    assert_eq!(
        hints(&running),
        2,
        "the per-root file hint is drawn while files are moving: {:?}",
        running
    );

    let text = frame_text(
        &ctx,
        &mut tab,
        &maintaining_state(roots, Some(MaintenanceStep::RemovingStale)),
    );
    assert_eq!(
        text.iter()
            .filter(|t| t.contains("Removing entries for deleted files"))
            .count(),
        1,
        "the step is run-wide, not per-root: {:?}",
        text
    );
    assert_eq!(
        hints(&text),
        2,
        "every root keeps its file hint through the step: {:?}",
        text
    );
}

#[test]
fn a_walking_root_without_a_count_shows_no_denominator() {
    let ctx = crate::test_ui::ctx();
    let mut tab = ManageTab::new();
    let text = frame_text(
        &ctx,
        &mut tab,
        &state_with(vec![root_progress(RootPhase::Walking, 100, None)]),
    )
    .join(" | ");
    assert!(text.contains("100 files"), "{}", text);
    assert!(!text.contains(" / "), "invented a denominator: {}", text);
}

#[test]
fn each_prologue_step_says_what_it_is_waiting_on() {
    let ctx = crate::test_ui::ctx();
    let mut tab = ManageTab::new();

    for (step, expected) in [
        (PrepStep::PreviousRun, "Finishing the previous run…"),
        (PrepStep::OpeningIndex, "Opening the index…"),
        (PrepStep::Starting, "Getting the index ready…"),
    ] {
        let text = frame_text(&ctx, &mut tab, &preparing_state(step)).join(" | ");
        assert!(text.contains(expected), "{}", text);
        assert!(text.contains("0:00"), "no elapsed time shown: {}", text);
    }
}

#[test]
fn a_reconcile_reports_how_far_through_the_index_it_is() {
    let ctx = crate::test_ui::ctx();
    let mut tab = ManageTab::new();
    let text = frame_text(
        &ctx,
        &mut tab,
        &preparing_state(PrepStep::Reconciling(ReconcileProgress {
            examined: 2_500_000,
            total: Some(8_000_000),
            deleted: 1_204,
            recontented: 0,
        })),
    )
    .join(" | ");

    assert!(text.contains("Applying configuration change"), "{}", text);
    assert!(
        text.contains("2,500,000 / 8,000,000 (31%) entries checked"),
        "{}",
        text
    );
    assert!(text.contains("1,204 entries removed"), "{}", text);
}

/// Whole-range deletions read no rows; the display must not invent a denominator.
#[test]
fn a_reconcile_without_a_row_count_shows_no_denominator() {
    let ctx = crate::test_ui::ctx();
    let mut tab = ManageTab::new();
    let text = frame_text(
        &ctx,
        &mut tab,
        &preparing_state(PrepStep::Reconciling(ReconcileProgress::default())),
    )
    .join(" | ");
    assert!(text.contains("0 entries checked"), "{}", text);
    assert!(!text.contains(" / "), "invented a denominator: {}", text);
}

/// The activity really is `Idle` while a between-runs prune scans every row.
#[test]
fn a_prune_between_runs_is_reported_instead_of_idle() {
    let ctx = crate::test_ui::ctx();
    let mut tab = ManageTab::new();
    let state = IndexerState {
        reconcile: Some(ReconcileState::Running(ReconcileProgress {
            examined: 40_000,
            total: Some(80_000),
            deleted: 0,
            recontented: 0,
        })),
        ..idle_state()
    };

    let text = frame_text(&ctx, &mut tab, &state).join(" | ");
    assert!(
        text.contains("Applying configuration change"),
        "the scan is invisible: {}",
        text
    );
    assert!(text.contains("40,000 / 80,000 (50%)"), "{}", text);
    assert!(
        !text.contains("Idle; last full index"),
        "reported idle while scanning: {}",
        text
    );
}

/// The lingering summary is the only evidence a fast pass happened.
#[test]
fn a_finished_prune_reports_what_it_did() {
    let ctx = crate::test_ui::ctx();
    let mut tab = ManageTab::new();
    let state = IndexerState {
        reconcile: Some(ReconcileState::Finished(ReconcileProgress {
            examined: 80_000,
            total: Some(80_000),
            deleted: 1_204,
            recontented: 7,
        })),
        ..idle_state()
    };

    let text = frame_text(&ctx, &mut tab, &state).join(" | ");
    assert!(
        text.contains("Configuration change applied"),
        "the finished pass left no trace: {}",
        text
    );
    assert!(text.contains("1,204 entries removed"), "{}", text);
    assert!(text.contains("7 entries re-examined"), "{}", text);
    assert!(
        !text.contains("Idle; last full index"),
        "the summary was replaced by the idle line: {}",
        text
    );
}

#[test]
fn the_starting_placeholder_is_gone() {
    let ctx = crate::test_ui::ctx();
    let mut tab = ManageTab::new();
    for state in [
        preparing_state(PrepStep::PreviousRun),
        preparing_state(PrepStep::OpeningIndex),
        preparing_state(PrepStep::Reconciling(ReconcileProgress::default())),
        idle_state(),
    ] {
        let text = frame_text(&ctx, &mut tab, &state).join(" | ");
        assert!(!text.contains("Starting"), "{}", text);
    }
}

use quicksearch_core::testutil::scratch_dir;

fn write_bytes(path: &Path, len: usize) {
    std::fs::write(path, vec![b'x'; len]).expect("write");
}

fn cfg_with_db(path: &Path) -> Config {
    let mut cfg = cfg_with_root();
    cfg.paths.database_path = path.to_string_lossy().into_owned();
    cfg
}

#[test]
fn db_size_counts_the_database_and_both_sidecars() {
    let dir = scratch_dir("parts");
    let db = dir.join("index.sqlite");
    write_bytes(&db, 4096);
    assert_eq!(measure_db_size(&db), 4096, "the database itself");
    write_bytes(&dir.join("index.sqlite-wal"), 1024);
    assert_eq!(measure_db_size(&db), 5120, "-wal was not added");
    write_bytes(&dir.join("index.sqlite-shm"), 32);
    assert_eq!(measure_db_size(&db), 5152, "-shm was not added");

    // Decoys: a rollback journal and an unrelated neighbour.
    write_bytes(&dir.join("index.sqlite-journal"), 999);
    write_bytes(&dir.join("index.sqlite.bak"), 777);
    assert_eq!(measure_db_size(&db), 5152, "a decoy was counted");
    let _ = std::fs::remove_dir_all(&dir);
}

#[test]
fn a_missing_database_measures_zero() {
    let dir = scratch_dir("missing");
    let db = dir.join("index.sqlite");
    assert_eq!(measure_db_size(&db), 0);
    assert_eq!(measure_db_size(&dir), 0, "a directory");

    write_bytes(&db, 100);
    assert_eq!(measure_db_size(&db), 100, "sidecars are optional");
    let _ = std::fs::remove_dir_all(&dir);
}

#[test]
fn the_probe_caches_until_the_refresh_interval_is_up() {
    let dir = scratch_dir("cache");
    let db = dir.join("index.sqlite");
    write_bytes(&db, 100);
    let cfg = cfg_with_db(&db);
    let mut probe = DbSizeProbe::default();
    let t0 = Instant::now();

    assert_eq!(probe.size(&cfg, t0), 100);
    write_bytes(&db, 5000);
    assert_eq!(
        probe.size(&cfg, t0 + DB_SIZE_REFRESH / 2),
        100,
        "restatted before the interval was up"
    );
    assert_eq!(
        probe.size(&cfg, t0 + DB_SIZE_REFRESH),
        5000,
        "the refresh never happened"
    );
    let _ = std::fs::remove_dir_all(&dir);
}

#[test]
fn the_probe_follows_a_changed_database_path() {
    let dir = scratch_dir("moved");
    let first = dir.join("index.sqlite");
    let second = dir.join("other.sqlite");
    write_bytes(&first, 100);
    write_bytes(&second, 7000);
    let mut probe = DbSizeProbe::default();
    let t0 = Instant::now();

    assert_eq!(probe.size(&cfg_with_db(&first), t0), 100);
    assert_eq!(
        probe.size(&cfg_with_db(&second), t0),
        7000,
        "a new path must restat at once, not wait out the interval"
    );
    let _ = std::fs::remove_dir_all(&dir);
}

#[test]
fn the_status_row_shows_the_total_index_size() {
    let dir = scratch_dir("render");
    let db = dir.join("index.sqlite");
    write_bytes(&db, 3_000_000);
    write_bytes(&dir.join("index.sqlite-wal"), 200_000);
    write_bytes(&dir.join("index.sqlite-shm"), 32_768);

    let ctx = crate::test_ui::ctx();
    let mut tab = ManageTab::new();
    let text = frame_text_with(&ctx, &mut tab, &cfg_with_db(&db), &idle_state()).join(" | ");
    assert!(
        text.contains("Index size: 3.2 MB"),
        "the size is not on screen: {}",
        text
    );
    let _ = std::fs::remove_dir_all(&dir);
}

/// The tooltip's levers each have to keep matching a control that exists.
#[test]
fn hovering_the_size_explains_how_to_shrink_the_index() {
    let dir = scratch_dir("hover");
    let db = dir.join("index.sqlite");
    write_bytes(&db, 2048);

    let ctx = crate::test_ui::ctx();
    ctx.style_mut(|s| s.interaction.tooltip_delay = 0.0);
    let mut tab = ManageTab::new();
    let cfg = cfg_with_db(&db);

    frame_text_with(&ctx, &mut tab, &cfg, &idle_state());
    let at = widget("db-size").1.center();
    frame(
        &ctx,
        &mut tab,
        &cfg,
        &idle_state(),
        vec![egui::Event::PointerMoved(at)],
    );
    // The tooltip is painted in the frame after the pointer lands.
    let text = frame_text_with(&ctx, &mut tab, &cfg, &idle_state()).join(" | ");

    assert!(
        text.contains("To reduce the index size"),
        "no tooltip: {}",
        text
    );
    for lever in [
        "ignore filters",
        "Indexed folders",
        "whitelist",
        "Store text for snippets",
        "Settings tab",
    ] {
        assert!(text.contains(lever), "tooltip never mentions {}", lever);
    }
    let _ = std::fs::remove_dir_all(&dir);
}

fn synced_tab(config: &Config) -> ManageTab {
    let mut tab = ManageTab::new();
    tab.sync_editors(config);
    tab
}

#[test]
fn identical_config_leaves_draft_untouched() {
    let cfg = Config::default();
    let mut tab = synced_tab(&cfg);
    tab.draft
        .as_mut()
        .unwrap()
        .indexing
        .ignore_patterns
        .push("*.log".into());
    tab.sync_editors(&cfg);
    assert!(tab
        .draft
        .as_ref()
        .unwrap()
        .indexing
        .ignore_patterns
        .contains(&"*.log".to_string()));
}

#[test]
fn clean_draft_adopts_external_changes_wholesale() {
    let cfg = Config::default();
    let mut tab = synced_tab(&cfg);
    let mut external = cfg.clone();
    external.indexing.ignore_patterns.push("*.log".into());
    external.search.fuzzy_default = !external.search.fuzzy_default;
    tab.sync_editors(&external);
    assert_eq!(tab.draft.as_ref().unwrap(), &external);
    assert_eq!(tab.baseline.as_ref().unwrap(), &external);
}

#[test]
fn staged_edits_survive_an_external_persist() {
    let cfg = Config::default();
    let mut tab = synced_tab(&cfg);
    // Stage a removal of the first default pattern.
    let removed = tab
        .draft
        .as_mut()
        .unwrap()
        .indexing
        .ignore_patterns
        .remove(0);
    // Meanwhile the Search tab persists a new filter.
    let mut external = cfg.clone();
    external.indexing.ignore_patterns.push("*.log".into());
    tab.sync_editors(&external);
    let draft = tab.draft.as_ref().unwrap();
    assert!(!draft.indexing.ignore_patterns.contains(&removed));
    assert!(draft
        .indexing
        .ignore_patterns
        .contains(&"*.log".to_string()));
    assert_eq!(tab.baseline.as_ref().unwrap(), &external);
}

#[test]
fn dirty_draft_adopts_sections_owned_elsewhere() {
    let cfg = Config::default();
    let mut tab = synced_tab(&cfg);
    tab.draft
        .as_mut()
        .unwrap()
        .indexing
        .ignore_patterns
        .push("*.bak".into());
    // The fuzzy toggle saves the config directly, outside this tab.
    let mut external = cfg.clone();
    external.search.fuzzy_default = !cfg.search.fuzzy_default;
    tab.sync_editors(&external);
    let draft = tab.draft.as_ref().unwrap();
    assert_eq!(draft.search.fuzzy_default, external.search.fuzzy_default);
    assert!(draft
        .indexing
        .ignore_patterns
        .contains(&"*.bak".to_string()));
}

#[test]
fn external_pattern_is_not_duplicated_into_a_draft_that_has_it() {
    let cfg = Config::default();
    let mut tab = synced_tab(&cfg);
    tab.draft
        .as_mut()
        .unwrap()
        .indexing
        .ignore_patterns
        .push("*.log".into());
    let mut external = cfg.clone();
    external.indexing.ignore_patterns.push("*.log".into());
    tab.sync_editors(&external);
    let count = tab
        .draft
        .as_ref()
        .unwrap()
        .indexing
        .ignore_patterns
        .iter()
        .filter(|p| p.as_str() == "*.log")
        .count();
    assert_eq!(count, 1);
}

#[test]
fn a_fresh_tab_is_not_dirty_before_or_after_its_first_sync() {
    let mut tab = ManageTab::new();
    assert!(!tab.is_dirty(), "no draft yet");
    tab.sync_editors(&cfg_with_root());
    assert!(!tab.is_dirty(), "a fresh sync stages nothing");
}

#[test]
fn a_staged_edit_reads_dirty_and_discard_reverts_it() {
    let cfg = cfg_with_root();
    let mut tab = synced_tab(&cfg);
    tab.draft
        .as_mut()
        .unwrap()
        .indexing
        .ignore_patterns
        .push("*.jpg".into());
    tab.new_ignore = "half-typ".into();
    tab.root_error = Some("bad".into());
    assert!(tab.is_dirty());

    tab.discard();
    assert!(!tab.is_dirty());
    assert!(tab.new_ignore.is_empty(), "scratch boxes are cleared too");
    assert!(tab.root_error.is_none());
    tab.sync_editors(&cfg);
    assert_eq!(tab.draft.as_ref(), Some(&cfg), "resynced from live");
    assert!(!tab.is_dirty());
}

#[test]
fn a_trailing_newline_in_the_extension_editor_is_not_dirty() {
    let mut cfg = cfg_with_root();
    cfg.indexing.content_extensions = vec!["txt".into(), "md".into()];
    let mut tab = synced_tab(&cfg);
    tab.ext_filter_text.push('\n');
    assert!(!tab.is_dirty(), "a blank line is not an edit");
    tab.ext_filter_text.push_str("pdf");
    assert!(tab.is_dirty(), "a real entry is");
}

/// A stale `auto_index` frozen into the draft must not read dirty or
/// revert the mode on apply.
#[test]
fn a_live_mode_flip_does_not_read_as_dirty() {
    let mut cfg = cfg_with_root();
    cfg.indexing.auto_index = true;
    let mut tab = synced_tab(&cfg);

    // Stop clicked, nothing staged: the tab resyncs and stays clean.
    let mut stopped = cfg.clone();
    stopped.indexing.auto_index = false;
    tab.sync_editors(&stopped);
    assert!(!tab.is_dirty());

    // Staged edit, then Return to Automatic: dirty from the edit only.
    tab.draft
        .as_mut()
        .unwrap()
        .indexing
        .ignore_patterns
        .push("*.jpg".into());
    let mut auto_again = stopped.clone();
    auto_again.indexing.auto_index = true;
    tab.sync_editors(&auto_again);
    assert!(tab.is_dirty(), "the staged pattern is still pending");
    let applied = tab.take_apply_config(&auto_again).expect("a config");
    assert!(
        applied.indexing.auto_index,
        "applying must not revert the live mode"
    );

    tab.draft.as_mut().unwrap().indexing.ignore_patterns.pop();
    assert!(!tab.is_dirty());
}

#[test]
fn a_rejected_apply_keeps_the_draft() {
    let cfg = cfg_with_root();
    let mut tab = synced_tab(&cfg);
    tab.draft
        .as_mut()
        .unwrap()
        .paths
        .indexing_paths
        .push("/data/nested".into());

    let staged = tab.take_apply_config(&cfg).expect("a config to apply");
    assert!(staged
        .paths
        .indexing_paths
        .contains(&"/data/nested".to_string()));
    assert!(tab.baseline.is_some(), "baseline survives the attempt");
    assert!(tab.is_dirty(), "the staged root is still pending");

    tab.mark_applied();
    assert!(tab.baseline.is_none(), "a landed apply forces a resync");
    assert!(!tab.is_dirty());
}

/// The label's coming and going must never rename the Apply button.
#[test]
fn the_unsaved_label_appears_without_renaming_the_apply_button() {
    let ctx = crate::test_ui::ctx();
    let mut tab = ManageTab::new();
    let cfg = cfg_with_root();

    let clean = frame_text_with(&ctx, &mut tab, &cfg, &idle_state());
    assert!(
        !clean.iter().any(|t| t.contains("Unsaved changes")),
        "a clean tab must not claim unsaved changes"
    );
    let (clean_id, _) = widget("apply");

    tab.draft
        .as_mut()
        .unwrap()
        .indexing
        .ignore_patterns
        .push("*.jpg".into());
    let dirty = frame_text_with(&ctx, &mut tab, &cfg, &idle_state());
    assert!(
        dirty.iter().any(|t| t.contains("Unsaved changes")),
        "painted: {:?}",
        dirty
    );
    assert_eq!(widget("apply").0, clean_id, "the label renamed the button");
}

/// The status area gains and loses rows as a prune runs; an editor whose
/// id changes mid-edit loses its buffer.
#[test]
fn the_prune_rows_come_and_go_without_renaming_anything_below() {
    let ctx = crate::test_ui::ctx();
    let mut tab = ManageTab::new();
    let cfg = cfg_with_root();
    let progress = ReconcileProgress {
        examined: 40_000,
        total: Some(80_000),
        deleted: 12,
        recontented: 0,
    };

    frame_text_with(&ctx, &mut tab, &cfg, &idle_state());
    let (apply, _) = widget("apply");
    let (workers, _) = widget("workers");

    for reconcile in [
        Some(ReconcileState::Running(progress)),
        Some(ReconcileState::Finished(progress)),
        None,
    ] {
        let state = IndexerState {
            reconcile,
            ..idle_state()
        };
        frame_text_with(&ctx, &mut tab, &cfg, &state);
        assert_eq!(widget("apply").0, apply, "renamed by {reconcile:?}");
        assert_eq!(widget("workers").0, workers, "renamed by {reconcile:?}");
    }
}

/// The cross-row adoption hazard: egui names widgets positionally, so after
/// a Remove the surviving rows inherit earlier rows' ids — an in-progress
/// DragValue edit must not carry over onto a different root.
#[test]
fn removing_a_root_does_not_leak_an_edit_onto_another_row() {
    fn rects(tag: &str) -> Vec<egui::Rect> {
        WIDGETS.with(|w| {
            w.borrow()
                .iter()
                .filter(|(t, _, _)| *t == tag)
                .map(|(_, _, rect)| *rect)
                .collect()
        })
    }

    let ctx = crate::test_ui::ctx();
    let mut cfg = Config::default();
    cfg.paths.indexing_paths = vec!["/aaa".into(), "/bbb".into(), "/ccc".into()];
    let mut tab = synced_tab(&cfg);
    let state = idle_state();
    let staged = |tab: &ManageTab, root: &str| -> Option<usize> {
        tab.draft
            .as_ref()
            .unwrap()
            .indexing
            .root_workers
            .get(root)
            .copied()
    };

    // Start editing row B's worker count.
    frame(&ctx, &mut tab, &cfg, &state, vec![]);
    let b_field = rects("workers")[1].center();
    frame(&ctx, &mut tab, &cfg, &state, click_at(b_field));
    frame(
        &ctx,
        &mut tab,
        &cfg,
        &state,
        vec![egui::Event::Text("7".into())],
    );
    assert_eq!(staged(&tab, "/bbb"), Some(7), "the edit reached row B");
    assert_eq!(staged(&tab, "/ccc"), None);

    // Remove row A while the edit is live, then keep typing.
    let a_remove = rects("remove")[0].center();
    frame(&ctx, &mut tab, &cfg, &state, click_at(a_remove));
    frame(&ctx, &mut tab, &cfg, &state, vec![]);
    frame(
        &ctx,
        &mut tab,
        &cfg,
        &state,
        vec![egui::Event::Text("9".into())],
    );

    let paths = &tab.draft.as_ref().unwrap().paths.indexing_paths;
    assert_eq!(paths, &["/bbb".to_string(), "/ccc".to_string()]);
    assert_eq!(
        staged(&tab, "/bbb"),
        Some(7),
        "row B keeps its committed edit"
    );
    assert_eq!(
        staged(&tab, "/ccc"),
        None,
        "the in-flight edit must not be adopted by row C"
    );
}

/// The tour's folders page tells the reader to add a folder "here", and
/// glows the row it means. All three ways in have to be inside that glow.
#[test]
fn the_tour_can_find_every_way_to_add_a_folder() {
    let ctx = crate::test_ui::ctx();
    let mut tab = ManageTab::new();
    let cfg = cfg_with_root();
    let state = idle_state();

    let mut marked = None;
    let out = ctx.run(raw_input(vec![]), |ctx| {
        crate::spotlight::set_active(ctx, true);
        egui::CentralPanel::default().show(ctx, |ui| {
            tab.ui(ui, &state, &cfg);
        });
        // Inside the pass: a mark is only live for the pass that wrote it.
        marked = crate::spotlight::rect(ctx, crate::spotlight::Spot::IndexedFolderAdd);
    });
    let marked = marked.expect("the add-a-folder row was never marked");

    let painted = crate::test_ui::painted(&out);
    for needle in ["Add folder…", "or type a path", "Add"] {
        let rect = painted
            .iter()
            .find(|(text, _)| text == needle)
            .map(|(_, rect)| *rect)
            .unwrap_or_else(|| panic!("nothing painted for {needle:?}"));
        assert!(
            marked.contains_rect(rect),
            "{needle:?} at {rect:?} is outside the glow at {marked:?}"
        );
    }
    // The row, not the whole folder list above it.
    assert!(
        marked.height() < 60.0,
        "the mark covers {marked:?}, which is more than one row"
    );
}