//! State-machine tests for the TUI: synthetic key events drive `input::handle_key`

//! directly (no terminal needed).

use std::path::PathBuf;

use cielago::app::{App, EditTarget, EditorTab, Focus, Mode, Popup, SidebarRow};

use cielago::input::handle_key;

use cielago::model::{Collection, KeyValueRow, LabelMode, Method, SavedRequest};

use cielago::store::AppConfig;

use crossterm::event::{KeyCode, KeyEvent, KeyModifiers};

fn key(code: KeyCode) -> KeyEvent {

    KeyEvent::new(code, KeyModifiers::NONE)

}

fn char_key(c: char) -> KeyEvent {

    key(KeyCode::Char(c))

}

fn type_str(app: &mut App, s: &str) {

    for c in s.chars() {

        handle_key(app, char_key(c));

    }

}

fn test_collection() -> Collection {

    let mut c = Collection::new("test");

    c.servers = vec![

        "https://one.example.com".into(),

        "https://two.example.com".into(),

    ];

    let mut list = SavedRequest::blank("listPets");

    list.method = Method::Get;

    list.path = "/pets".into();

    list.tags = vec!["pets".into()];

    list.query.push(KeyValueRow::new("limit", "20", false));

    list.query.push(KeyValueRow::new("filter", "", false));

    let mut create = SavedRequest::blank("createPet");

    create.method = Method::Post;

    create.path = "/pets".into();

    create.tags = vec!["pets".into()];

    create.body = Some("{\n  \"name\": \"Fido\"\n}".into());

    let mut order = SavedRequest::blank("placeOrder");

    order.method = Method::Post;

    order.path = "/orders".into();

    order.tags = vec!["store".into()];

    c.requests = vec![list, create, order];

    c

}

fn test_app() -> App {

    App::new(

        test_collection(),

        PathBuf::from("/tmp/cielago-test.json"),

        AppConfig::default(),

    )

}

#[test]

fn startup_state() {

    let app = test_app();

    assert_eq!(app.mode, Mode::Normal);

    // sidebar: group header + 2 pets requests + group + 1 store request

    assert_eq!(app.sidebar_rows.len(), 5);

    // first request auto-selected, but focus starts on the sidebar

    assert_eq!(app.selected, Some(0));

    assert_eq!(app.focus, Focus::Sidebar);

}

#[test]

fn startup_restores_the_last_open_request() {

    let mut c = test_collection();

    c.last_request = Some(c.requests[2].id);

    let app = App::new(

        c,

        PathBuf::from("/tmp/cielago-test.json"),

        AppConfig::default(),

    );

    assert_eq!(app.selected, Some(2));

    // the sidebar cursor lands on it too, not back at the top

    assert_eq!(app.sidebar_rows[app.sidebar_sel], SidebarRow::Request(2));

    assert_eq!(app.focus, Focus::Sidebar);

}

#[test]

fn startup_expands_the_restored_request_group() {

    let mut c = test_collection();

    c.groups_collapsed = true;

    c.last_request = Some(c.requests[2].id);

    let app = App::new(

        c,

        PathBuf::from("/tmp/cielago-test.json"),

        AppConfig::default(),

    );

    // "store" is expanded so the restored row is visible; "pets" stays collapsed

    assert_eq!(app.selected, Some(2));

    assert_eq!(app.sidebar_rows[app.sidebar_sel], SidebarRow::Request(2));

    assert_eq!(app.sidebar_rows.len(), 3);

}

#[test]

fn startup_restores_the_focused_pane_and_tab() {

    let mut c = test_collection();

    c.last_request = Some(c.requests[1].id);

    c.last_focus = Some(Focus::Editor);

    c.last_tab = Some(EditorTab::Body);

    let app = App::new(

        c,

        PathBuf::from("/tmp/cielago-test.json"),

        AppConfig::default(),

    );

    assert_eq!(app.selected, Some(1));

    assert_eq!(app.focus, Focus::Editor);

    assert_eq!(app.tab, EditorTab::Body);

}

#[test]

fn startup_skips_a_saved_response_pane_with_no_response() {

    let mut c = test_collection();

    c.last_focus = Some(Focus::Response);

    c.last_tab = Some(EditorTab::Docs);

    let app = App::new(

        c,

        PathBuf::from("/tmp/cielago-test.json"),

        AppConfig::default(),

    );

    // responses aren't persisted, so pane 3 would be empty

    assert_eq!(app.focus, Focus::Editor);

    assert_eq!(app.tab, EditorTab::Docs);

}

// `record_view` rather than `save`: saving writes into the real

// `~/.config/cielago/collections`, which a test has no business touching.

#[test]

fn record_view_captures_request_pane_and_tab() {

    let mut app = test_app();

    handle_key(&mut app, char_key('j')); // onto the first request row

    handle_key(&mut app, char_key('j')); // onto the second

    handle_key(&mut app, key(KeyCode::Enter)); // open it

    handle_key(&mut app, char_key(']')); // Params -> Headers

    handle_key(&mut app, char_key(']')); // Headers -> Body

    handle_key(&mut app, char_key('3')); // response pane

    app.record_view();

    let id = app.collection.requests[1].id;

    assert_eq!(app.collection.last_request, Some(id));

    assert_eq!(app.collection.last_focus, Some(Focus::Response));

    assert_eq!(app.collection.last_tab, Some(EditorTab::Body));

}

#[test]

fn startup_ignores_a_stale_last_request() {

    let mut c = test_collection();

    c.last_request = Some(uuid::Uuid::new_v4());

    let app = App::new(

        c,

        PathBuf::from("/tmp/cielago-test.json"),

        AppConfig::default(),

    );

    // request is gone (re-imported spec, deleted operation): fall back to first

    assert_eq!(app.selected, Some(0));

}

#[test]

fn help_popup_opens_and_closes() {

    let mut app = test_app();

    handle_key(&mut app, char_key('?'));

    assert_eq!(app.popup, Popup::Help);

    handle_key(&mut app, key(KeyCode::Esc));

    assert_eq!(app.popup, Popup::None);

}

#[test]

fn z_toggles_pane_zoom_without_touching_focus() {

    let mut app = test_app();

    handle_key(&mut app, char_key('2'));

    handle_key(&mut app, char_key('z'));

    assert!(app.zoom);

    assert_eq!(app.focus, Focus::Editor);

    // Focus still moves while zoomed — it just picks the maximized pane.

    handle_key(&mut app, key(KeyCode::Tab));

    assert!(app.zoom);

    assert_eq!(app.focus, Focus::Response);

    handle_key(&mut app, char_key('z'));

    assert!(!app.zoom);

}

#[test]

fn sidebar_navigation_and_selection() {

    let mut app = test_app();

    handle_key(&mut app, char_key('1'));

    assert_eq!(app.focus, Focus::Sidebar);

    handle_key(&mut app, char_key('j'));

    assert_eq!(app.sidebar_sel, 1);

    handle_key(&mut app, char_key('j'));

    handle_key(&mut app, key(KeyCode::Enter));

    assert_eq!(app.selected, Some(1)); // createPet

    assert_eq!(app.focus, Focus::Editor);

    // body loaded into the body view

    assert!(app.body_text.contains("Fido"));

}

#[test]

fn sidebar_group_collapse() {

    let mut app = test_app();

    handle_key(&mut app, char_key('1'));

    // row 0 is the "pets" group

    handle_key(&mut app, key(KeyCode::Enter));

    assert!(app.collapsed.contains("pets"));

    assert_eq!(app.sidebar_rows.len(), 3); // pets group collapsed

    handle_key(&mut app, key(KeyCode::Enter));

    assert!(!app.collapsed.contains("pets"));

    assert_eq!(app.sidebar_rows.len(), 5);

}

#[test]

fn quit_guards_unsaved_changes() {

    let mut app = test_app();

    assert!(!app.dirty);

    handle_key(&mut app, char_key('q'));

    assert!(app.should_quit);

    let mut app = test_app();

    app.dirty = true;

    handle_key(&mut app, char_key('q'));

    assert!(!app.should_quit);

    assert!(app.status.contains("Unsaved"));

    // :q! forces

    handle_key(&mut app, char_key(':'));

    type_str(&mut app, "q!");

    handle_key(&mut app, key(KeyCode::Enter));

    assert!(app.should_quit);

}

#[test]

fn tab_cycling() {

    let mut app = test_app();

    assert_eq!(app.tab, EditorTab::Params);

    handle_key(&mut app, char_key(']'));

    assert_eq!(app.tab, EditorTab::Headers);

    handle_key(&mut app, char_key(']'));

    assert_eq!(app.tab, EditorTab::Body);

    handle_key(&mut app, char_key('['));

    assert_eq!(app.tab, EditorTab::Headers);

}

#[test]

fn tab_cycling_letter_aliases() {

    let mut app = test_app();

    assert_eq!(app.tab, EditorTab::Params);

    handle_key(&mut app, char_key('L'));

    assert_eq!(app.tab, EditorTab::Headers);

    handle_key(&mut app, char_key('L'));

    assert_eq!(app.tab, EditorTab::Body);

    handle_key(&mut app, char_key('H'));

    assert_eq!(app.tab, EditorTab::Headers);

    // wraps backwards past Params into Variables

    handle_key(&mut app, char_key('H'));

    handle_key(&mut app, char_key('H'));

    assert_eq!(app.tab, EditorTab::Variables);

}

#[test]

fn slash_filters_the_sidebar() {

    let mut app = test_app();

    handle_key(&mut app, char_key('/'));

    assert_eq!(app.mode, Mode::Search);

    assert_eq!(app.focus, Focus::Sidebar);

    type_str(&mut app, "order");

    // "store" group header + placeOrder only

    assert_eq!(app.sidebar_rows.len(), 2);

    // cursor parked on the match, not the group header

    assert_eq!(app.sidebar_rows[app.sidebar_sel], SidebarRow::Request(2));

    // Enter keeps the filter and returns to Normal.

    handle_key(&mut app, key(KeyCode::Enter));

    assert_eq!(app.mode, Mode::Normal);

    assert_eq!(app.filter, "order");

    handle_key(&mut app, key(KeyCode::Enter)); // open the match

    assert_eq!(app.selected, Some(2));

    // Esc in the sidebar clears the filter.

    handle_key(&mut app, char_key('1'));

    handle_key(&mut app, key(KeyCode::Esc));

    assert!(app.filter.is_empty());

    assert_eq!(app.sidebar_rows.len(), 5);

}

#[test]

fn search_matches_path_method_and_tag() {

    let mut app = test_app();

    handle_key(&mut app, char_key('/'));

    type_str(&mut app, "/pets");

    assert_eq!(app.sidebar_rows.len(), 3); // pets group + 2 requests

    handle_key(&mut app, key(KeyCode::Esc));

    assert!(app.filter.is_empty());

    handle_key(&mut app, char_key('/'));

    type_str(&mut app, "post");

    assert_eq!(app.sidebar_rows.len(), 4); // createPet + placeOrder, 2 groups

    handle_key(&mut app, key(KeyCode::Esc));

    handle_key(&mut app, char_key('/'));

    type_str(&mut app, "store");

    assert_eq!(app.sidebar_rows.len(), 2);

    // backspacing widens the match set again

    handle_key(&mut app, key(KeyCode::Backspace));

    handle_key(&mut app, key(KeyCode::Backspace));

    handle_key(&mut app, key(KeyCode::Backspace));

    handle_key(&mut app, key(KeyCode::Backspace));

    handle_key(&mut app, key(KeyCode::Backspace));

    assert_eq!(app.sidebar_rows.len(), 5);

}

#[test]

fn search_shows_matches_inside_collapsed_groups() {

    let mut app = test_app();

    app.collapsed.insert("pets".into());

    app.rebuild_sidebar();

    assert_eq!(app.sidebar_rows.len(), 3);

    handle_key(&mut app, char_key('/'));

    type_str(&mut app, "createPet");

    assert_eq!(app.sidebar_rows.len(), 2);

}

#[test]

fn label_mode_cycles_and_persists_on_the_collection() {

    let mut app = test_app();

    handle_key(&mut app, char_key('1'));

    assert_eq!(app.collection.label_mode, LabelMode::Name);

    handle_key(&mut app, char_key('t'));

    assert_eq!(app.collection.label_mode, LabelMode::Summary);

    handle_key(&mut app, char_key('t'));

    assert_eq!(app.collection.label_mode, LabelMode::Path);

    handle_key(&mut app, char_key('t'));

    assert_eq!(app.collection.label_mode, LabelMode::Name);

    assert!(app.dirty);

}

#[test]

fn label_command_sets_mode() {

    let mut app = test_app();

    handle_key(&mut app, char_key(':'));

    type_str(&mut app, "label path");

    handle_key(&mut app, key(KeyCode::Enter));

    assert_eq!(app.collection.label_mode, LabelMode::Path);

    handle_key(&mut app, char_key(':'));

    type_str(&mut app, "label nonsense");

    handle_key(&mut app, key(KeyCode::Enter));

    assert_eq!(app.collection.label_mode, LabelMode::Path);

    assert!(app.status.contains("Usage"));

}

#[test]

fn rename_all_rewrites_names_from_paths() {

    let mut app = test_app();

    handle_key(&mut app, char_key(':'));

    type_str(&mut app, "rename-all method-path");

    handle_key(&mut app, key(KeyCode::Enter));

    assert_eq!(app.collection.requests[0].name, "GET /pets");

    assert_eq!(app.collection.requests[1].name, "POST /pets");

    assert_eq!(app.collection.requests[2].name, "POST /orders");

    assert!(app.dirty);

}

#[test]

fn edit_query_value_inline() {

    let mut app = test_app();

    handle_key(&mut app, char_key('2'));

    assert_eq!(app.tab, EditorTab::Params);

    // row 0 = limit (value "20")

    handle_key(&mut app, char_key('i'));

    assert_eq!(app.mode, Mode::Insert);

    assert!(matches!(app.editing, Some(EditTarget::Cell { .. })));

    handle_key(&mut app, char_key('5'));

    handle_key(&mut app, key(KeyCode::Enter));

    assert_eq!(app.mode, Mode::Normal);

    assert_eq!(app.collection.requests[0].query[0].value, "205");

    assert!(app.dirty);

}

#[test]

fn space_toggles_row() {

    let mut app = test_app();

    handle_key(&mut app, char_key('2'));

    assert!(!app.collection.requests[0].query[0].enabled);

    handle_key(&mut app, char_key(' '));

    assert!(app.collection.requests[0].query[0].enabled);

}

#[test]

fn add_header_row_with_uuid_variable() {

    let mut app = test_app();

    handle_key(&mut app, char_key('2'));

    handle_key(&mut app, char_key(']')); // Headers tab

    assert_eq!(app.tab, EditorTab::Headers);

    handle_key(&mut app, char_key('a'));

    type_str(&mut app, "X-Request-Id");

    handle_key(&mut app, key(KeyCode::Enter)); // chains to value edit

    type_str(&mut app, "{{uuid}}");

    handle_key(&mut app, key(KeyCode::Enter));

    assert_eq!(app.mode, Mode::Normal);

    let headers = &app.collection.requests[0].headers;

    assert_eq!(headers.len(), 1);

    assert_eq!(headers[0].key, "X-Request-Id");

    assert_eq!(headers[0].value, "{{uuid}}");

    assert!(headers[0].enabled);

}

#[test]

fn body_has_no_inline_editor() {

    let mut app = test_app();

    // select createPet (has a body)

    app.select_request(1);

    handle_key(&mut app, char_key(']'));

    handle_key(&mut app, char_key(']')); // Body tab

    assert_eq!(app.tab, EditorTab::Body);

    // `i` no longer opens an in-app editor; the body is edited via `$EDITOR`.

    handle_key(&mut app, char_key('i'));

    assert_eq!(app.mode, Mode::Normal);

    // `e` queues an external edit instead.

    handle_key(&mut app, char_key('e'));

    assert_eq!(app.pending_external, Some(cielago::app::ExternalEdit::Body));

    assert!(

        app.collection.requests[1]

            .body

            .as_ref()

            .unwrap()

            .contains("Fido")

    );

}

#[test]

fn body_tab_scrolls_the_read_only_view() {

    let mut app = test_app();

    app.select_request(1);

    app.set_body_text(&(1..=40).map(|i| format!("line {i}\n")).collect::<String>());

    app.tab = EditorTab::Body;

    // The read-only body view scrolls with a plain offset.

    handle_key(&mut app, char_key('j'));

    handle_key(&mut app, char_key('j'));

    assert_eq!(app.body_scroll, 2);

    handle_key(&mut app, char_key('k'));

    assert_eq!(app.body_scroll, 1);

    handle_key(&mut app, char_key('d'));

    assert_eq!(app.body_scroll, 16);

    handle_key(&mut app, char_key('u'));

    assert_eq!(app.body_scroll, 1);

    handle_key(&mut app, char_key('g'));

    assert_eq!(app.body_scroll, 0);

    // `d` scrolls here rather than deleting a row, but the other editor keys

    // still reach their handlers.

    assert_eq!(app.collection.requests[1].method, Method::Post);

    handle_key(&mut app, char_key('m'));

    assert_eq!(app.collection.requests[1].method, Method::Put);

    // `i` on the Body tab is a no-op, not an editor.

    handle_key(&mut app, char_key('i'));

    assert_eq!(app.mode, Mode::Normal);

}

#[test]

fn docs_tab_scrolls_and_stays_read_only() {

    let mut app = test_app();

    app.select_request(0); // moves focus to the editor

    app.tab = EditorTab::Docs;

    let params_before = app.collection.requests[0].query.len();

    handle_key(&mut app, char_key('j'));

    handle_key(&mut app, char_key('j'));

    assert_eq!(app.docs_scroll, 2);

    handle_key(&mut app, char_key('k'));

    assert_eq!(app.docs_scroll, 1);

    handle_key(&mut app, char_key('d'));

    assert_eq!(app.docs_scroll, 16);

    handle_key(&mut app, char_key('u'));

    assert_eq!(app.docs_scroll, 1);

    handle_key(&mut app, char_key('g'));

    assert_eq!(app.docs_scroll, 0);

    // `d` scrolled instead of deleting, and `i` doesn't open an editor here.

    assert_eq!(app.collection.requests[0].query.len(), params_before);

    handle_key(&mut app, char_key('i'));

    assert_eq!(app.mode, Mode::Normal);

    assert!(!app.dirty);

    // Opening another request resets the scroll.

    app.docs_scroll = 5;

    app.select_request(2);

    assert_eq!(app.docs_scroll, 0);

}

#[test]

fn help_popup_scrolls() {

    let mut app = test_app();

    handle_key(&mut app, char_key('?'));

    assert_eq!(app.help_scroll, 0);

    handle_key(&mut app, char_key('j'));

    handle_key(&mut app, char_key('j'));

    assert_eq!(app.help_scroll, 2);

    handle_key(&mut app, char_key('k'));

    assert_eq!(app.help_scroll, 1);

    handle_key(&mut app, char_key('g'));

    assert_eq!(app.help_scroll, 0);

    // Reopening starts back at the top.

    handle_key(&mut app, char_key('d'));

    assert!(app.help_scroll > 0);

    handle_key(&mut app, key(KeyCode::Esc));

    handle_key(&mut app, char_key('?'));

    assert_eq!(app.help_scroll, 0);

}

#[test]

fn env_popup_add_and_select_server() {

    let mut app = test_app();

    handle_key(&mut app, char_key('E'));

    assert_eq!(app.popup, Popup::Env);

    handle_key(&mut app, char_key('a'));

    type_str(&mut app, "http://localhost:8080");

    handle_key(&mut app, key(KeyCode::Enter));

    assert_eq!(app.collection.servers.len(), 3);

    assert_eq!(app.collection.active_server, 2);

    handle_key(&mut app, key(KeyCode::Esc));

    assert_eq!(app.popup, Popup::None);

}

#[test]

fn auth_popup_edits_and_applies() {

    use cielago::model::AuthKind;

    let mut app = test_app();

    handle_key(&mut app, char_key('A'));

    assert_eq!(app.popup, Popup::Auth);

    // Field 0 is the kind toggle, defaulting to bearer for a fresh config.

    // Cycle it to oauth2 (bearer -> apikey -> oauth2).

    handle_key(&mut app, char_key(' '));

    handle_key(&mut app, char_key(' '));

    assert_eq!(app.auth_form.kind, AuthKind::Oauth2);

    // Now the oauth rows show: 1 = token url, 2 = client id, 5 = style.

    handle_key(&mut app, char_key('j'));

    handle_key(&mut app, char_key('i'));

    type_str(&mut app, "https://auth.example.com/token");

    handle_key(&mut app, key(KeyCode::Enter));

    handle_key(&mut app, char_key('j'));

    handle_key(&mut app, char_key('i'));

    type_str(&mut app, "my-client");

    handle_key(&mut app, key(KeyCode::Enter));

    // style toggle: field 5

    for _ in 0..3 {

        handle_key(&mut app, char_key('j'));

    }

    assert_eq!(app.auth_field, 5);

    handle_key(&mut app, char_key(' '));

    // close + apply

    handle_key(&mut app, key(KeyCode::Esc));

    assert_eq!(app.popup, Popup::None);

    let auth = app.collection.auth.as_ref().unwrap();

    assert_eq!(auth.kind, AuthKind::Oauth2);

    assert_eq!(auth.token_url, "https://auth.example.com/token");

    assert_eq!(auth.client_id, "my-client");

    assert_eq!(auth.auth_style, cielago::model::AuthStyle::Post);

    assert!(app.dirty);

}

#[test]

fn auth_popup_sets_bearer_token() {

    use cielago::model::AuthKind;

    let mut app = test_app();

    handle_key(&mut app, char_key('A'));

    // Defaults to bearer; field 1 is the token.

    assert_eq!(app.auth_form.kind, AuthKind::Bearer);

    handle_key(&mut app, char_key('j'));

    handle_key(&mut app, char_key('i'));

    type_str(&mut app, "sk-live-123");

    handle_key(&mut app, key(KeyCode::Enter));

    handle_key(&mut app, key(KeyCode::Esc));

    let auth = app.collection.auth.as_ref().unwrap();

    assert_eq!(auth.kind, AuthKind::Bearer);

    assert_eq!(auth.token, "sk-live-123");

}

#[test]

fn auth_popup_sets_api_key_header() {

    use cielago::model::AuthKind;

    let mut app = test_app();

    handle_key(&mut app, char_key('A'));

    // bearer -> apikey.

    handle_key(&mut app, char_key(' '));

    assert_eq!(app.auth_form.kind, AuthKind::ApiKey);

    // apikey rows: 1 = header name, 2 = value.

    handle_key(&mut app, char_key('j'));

    handle_key(&mut app, char_key('i'));

    type_str(&mut app, "X-Custom-Key");

    handle_key(&mut app, key(KeyCode::Enter));

    handle_key(&mut app, char_key('j'));

    handle_key(&mut app, char_key('i'));

    type_str(&mut app, "abc123");

    handle_key(&mut app, key(KeyCode::Enter));

    handle_key(&mut app, key(KeyCode::Esc));

    let auth = app.collection.auth.as_ref().unwrap();

    assert_eq!(auth.kind, AuthKind::ApiKey);

    assert_eq!(auth.header, "X-Custom-Key");

    assert_eq!(auth.token, "abc123");

    assert_eq!(auth.api_key_header(), "X-Custom-Key");

}

#[test]

fn new_request_flow() {

    let mut app = test_app();

    handle_key(&mut app, char_key('1'));

    handle_key(&mut app, char_key('n'));

    type_str(&mut app, "my custom request");

    handle_key(&mut app, key(KeyCode::Enter));

    assert_eq!(app.collection.requests.len(), 4);

    assert_eq!(app.selected, Some(3));

    assert_eq!(app.collection.requests[3].name, "my custom request");

}

#[test]

fn rename_and_delete_request() {

    let mut app = test_app();

    handle_key(&mut app, char_key('1'));

    handle_key(&mut app, char_key('j')); // first request row

    handle_key(&mut app, char_key('r'));

    // rename input prefilled with current name; replace

    handle_key(&mut app, key(KeyCode::Home));

    for _ in 0..20 {

        handle_key(&mut app, key(KeyCode::Delete));

    }

    type_str(&mut app, "renamed");

    handle_key(&mut app, key(KeyCode::Enter));

    assert_eq!(app.collection.requests[0].name, "renamed");

    // focus stays in the sidebar on the renamed row; delete it

    assert_eq!(app.focus, Focus::Sidebar);

    handle_key(&mut app, char_key('d'));

    assert_eq!(app.collection.requests.len(), 2);

    assert!(!app.collection.requests.iter().any(|r| r.name == "renamed"));

}

#[test]

fn variables_tab_roundtrip() {

    let mut app = test_app();

    handle_key(&mut app, char_key('2'));

    handle_key(&mut app, char_key('[')); // Variables (prev of Params)

    assert_eq!(app.tab, EditorTab::Variables);

    handle_key(&mut app, char_key('a'));

    type_str(&mut app, "tenant");

    handle_key(&mut app, key(KeyCode::Enter));

    type_str(&mut app, "acme");

    handle_key(&mut app, key(KeyCode::Enter));

    assert_eq!(app.collection.variables.len(), 1);

    let map = cielago::model::variables_map(&app.collection.variables);

    assert_eq!(map.get("tenant").unwrap(), "acme");

}

// ----- ad-hoc requests and collections -----

/// Open the URL prompt on the selected request with a cleared buffer.

fn start_url_edit(app: &mut App) {

    handle_key(app, char_key('2'));

    handle_key(app, char_key('p'));

    assert_eq!(app.editing, Some(EditTarget::Url));

    handle_key(app, key(KeyCode::Home));

    for _ in 0..60 {

        handle_key(app, key(KeyCode::Delete));

    }

}

fn type_url(app: &mut App, url: &str) {

    start_url_edit(app);

    type_str(app, url);

    handle_key(app, key(KeyCode::Enter));

}

#[test]

fn edit_url_sets_path_and_syncs_path_params() {

    let mut app = test_app();

    type_url(&mut app, "/pets/{petId}/photos");

    let req = &app.collection.requests[0];

    assert_eq!(req.path, "/pets/{petId}/photos");

    assert_eq!(req.path_params.len(), 1);

    assert_eq!(req.path_params[0].key, "petId");

    assert!(app.dirty);

    // No `?` in the input, so the existing query rows are untouched.

    assert_eq!(req.query.len(), 2);

    // Removing the placeholder prunes the row again.

    type_url(&mut app, "/pets");

    assert!(app.collection.requests[0].path_params.is_empty());

}

#[test]

fn pasting_a_full_url_adds_and_activates_the_server() {

    let mut app = test_app();

    type_url(

        &mut app,

        "https://three.example.com/v2/pets?limit=5&sort=name",

    );

    assert_eq!(app.collection.servers.len(), 3);

    assert_eq!(app.collection.active_server, 2);

    assert_eq!(app.collection.base_url(), Some("https://three.example.com"));

    let req = &app.collection.requests[0];

    assert_eq!(req.path, "/v2/pets");

    let query: Vec<(&str, &str)> = req

        .query

        .iter()

        .map(|r| (r.key.as_str(), r.value.as_str()))

        .collect();

    assert_eq!(query, vec![("limit", "5"), ("sort", "name")]);

    assert!(req.query.iter().all(|r| r.enabled));

}

#[test]

fn pasting_a_known_origin_switches_to_it_without_duplicating() {

    let mut app = test_app();

    assert_eq!(app.collection.active_server, 0);

    type_url(&mut app, "https://two.example.com/pets");

    assert_eq!(app.collection.servers.len(), 2);

    assert_eq!(app.collection.active_server, 1);

    assert_eq!(app.collection.requests[0].path, "/pets");

}

#[test]

fn pasting_without_a_query_keeps_existing_params() {

    let mut app = test_app();

    type_url(&mut app, "https://one.example.com/pets/all");

    let req = &app.collection.requests[0];

    assert_eq!(req.path, "/pets/all");

    assert_eq!(req.query.len(), 2);

    // Disabled optional params from the fixture survive untouched.

    assert!(req.query.iter().all(|r| !r.enabled));

    assert_eq!(req.query[0].key, "limit");

}

#[test]

fn non_http_scheme_is_rejected() {

    let mut app = test_app();

    type_url(&mut app, "ftp://files.example.com/pets");

    assert_eq!(app.collection.requests[0].path, "/pets");

    assert_eq!(app.collection.servers.len(), 2);

    assert!(app.status.contains("http(s)"));

}

#[test]

fn duplicate_request_clones_directly_after_the_original() {

    let mut app = test_app();

    handle_key(&mut app, char_key('1'));

    handle_key(&mut app, char_key('j')); // first request row (listPets)

    handle_key(&mut app, char_key('y'));

    assert_eq!(app.collection.requests.len(), 4);

    assert_eq!(app.collection.requests[1].name, "listPets copy");

    assert_ne!(app.collection.requests[0].id, app.collection.requests[1].id);

    assert_eq!(app.collection.requests[1].path, "/pets");

    assert_eq!(app.collection.requests[1].query.len(), 2);

    // The original is still in place, and the clone is what's open.

    assert_eq!(app.collection.requests[0].name, "listPets");

    assert_eq!(app.selected, Some(1));

    assert_eq!(app.focus, Focus::Sidebar);

    assert_eq!(app.sidebar_rows[app.sidebar_sel], SidebarRow::Request(1));

    assert!(app.dirty);

}

#[test]

fn duplicate_twice_numbers_the_copies() {

    let mut app = test_app();

    handle_key(&mut app, char_key('1'));

    handle_key(&mut app, char_key('j'));

    handle_key(&mut app, char_key('y'));

    handle_key(&mut app, char_key('y'));

    assert_eq!(app.collection.requests.len(), 5);

    let names: Vec<&str> = app

        .collection

        .requests

        .iter()

        .map(|r| r.name.as_str())

        .collect();

    // The cursor followed the first clone, so the second `y` duplicates *it* —

    // and the ` copy` suffix is stripped first, giving `copy 2` not `copy copy`.

    assert_eq!(names[1], "listPets copy");

    assert_eq!(names[2], "listPets copy 2");

}

#[test]

fn new_request_chains_into_the_url_prompt() {

    let mut app = test_app();

    handle_key(&mut app, char_key('1'));

    handle_key(&mut app, char_key('n'));

    type_str(&mut app, "adhoc");

    handle_key(&mut app, key(KeyCode::Enter));

    // The name commit leaves you in the URL prompt rather than on `GET /`.

    assert_eq!(app.editing, Some(EditTarget::Url));

    assert_eq!(app.mode, Mode::Insert);

    type_str(&mut app, "https://four.example.com/ip");

    handle_key(&mut app, key(KeyCode::Enter));

    let req = app.collection.requests.last().unwrap();

    assert_eq!(req.name, "adhoc");

    assert_eq!(req.path, "/ip");

    assert_eq!(app.collection.base_url(), Some("https://four.example.com"));

}

#[test]

fn switch_collection_replaces_state() {

    let mut app = test_app();

    handle_key(&mut app, char_key('/'));

    type_str(&mut app, "orders");

    handle_key(&mut app, key(KeyCode::Enter));

    handle_key(&mut app, char_key('2'));

    handle_key(&mut app, char_key('m')); // dirty it

    let mut other = Collection::new("other");

    other.requests = vec![SavedRequest::blank("only")];

    app.switch_collection(other, PathBuf::from("/tmp/cielago-other.json"));

    assert_eq!(app.collection.name, "other");

    assert_eq!(app.collection.requests.len(), 1);

    assert_eq!(app.selected, Some(0));

    assert!(!app.dirty);

    assert!(app.filter.is_empty());

    assert!(app.response.is_none());

    assert!(app.status.contains("other"));

    // Tracked in memory only — `switch_collection` must not write to the real

    // `~/.config/cielago`, which is where `store::config_dir` always points.

    assert_eq!(app.config.last_collection.as_deref(), Some("other"));

}

#[test]

fn new_collection_command_refuses_when_dirty() {

    let mut app = test_app();

    handle_key(&mut app, char_key('2'));

    handle_key(&mut app, char_key('m')); // cycle method → dirty

    assert!(app.dirty);

    // The dirty guard runs before any filesystem access, so this touches nothing.

    handle_key(&mut app, char_key(':'));

    type_str(&mut app, "new Scratch");

    handle_key(&mut app, key(KeyCode::Enter));

    assert_eq!(app.collection.name, "test");

    assert!(app.status.contains("Unsaved changes"));

}

#[test]

fn new_collection_command_rejects_a_missing_name() {

    let mut app = test_app();

    handle_key(&mut app, char_key(':'));

    type_str(&mut app, "new  ");

    handle_key(&mut app, key(KeyCode::Enter));

    assert_eq!(app.collection.name, "test");

    assert!(app.status.starts_with("Usage: :new"));

}