link-assistant-router 1.2.1

//! Tests for the temporary launcher's directories, isolation and settings.
//!
//! Split from `with_command.rs` to keep that file within the repository's
//! 1000-line limit.

use super::*;
/// Gemini CLI resolves settings as `<home>/.gemini/settings.json`, where
/// `<home>` is `GEMINI_CLI_HOME` if set and `$HOME` otherwise. Pointing
/// `GEMINI_CLI_HOME` at the `.gemini` directory made it look one level too
/// deep, fall back to the user's personal settings, and refuse the run
/// (issue #227). Both variables must therefore name the root.
#[test]
fn the_gemini_client_is_pointed_at_the_isolated_home() {
    let root = tempfile::tempdir().expect("isolated root");
    let manager = ClientManager::isolated(root.path());
    let mut command = Command::new("gemini");
    configure_isolation(
        &mut command,
        &manager,
        root.path(),
        ClientKind::GeminiCli,
        true,
    )
    .expect("configure gemini isolation");

    let environment: std::collections::HashMap<_, _> = command
        .get_envs()
        .filter_map(|(key, value)| Some((key.to_string_lossy().into_owned(), value?)))
        .collect();

    for name in ["HOME", "GEMINI_CLI_HOME"] {
        assert_eq!(
            environment.get(name).map(|value| value.to_string_lossy()),
            Some(root.path().to_string_lossy()),
            "{name} must name the isolated root, not the .gemini directory \
             inside it — the CLI appends `.gemini` itself"
        );
    }
    // The file the CLI actually reads lives under that home.
    assert_eq!(
        manager.config_path(ClientKind::GeminiCli),
        root.path().join(".gemini/settings.json")
    );
    // The trusted-directory prompt cannot be answered non-interactively.
    assert_eq!(
        environment
            .get("GEMINI_CLI_TRUST_WORKSPACE")
            .map(|value| value.to_string_lossy()),
        Some(std::borrow::Cow::Borrowed("true"))
    );
}

/// End to end: after preparing the client, the file Gemini CLI actually
/// reads must exist and select the API-key flow. The router previously
/// wrote a correct file the CLI never opened (issue #227).
/// By default the client keeps its own configuration directory, so sessions
/// started outside the router remain visible and a conversation can be
/// resumed through it (issue #233), and an interactive user does not land in
/// first-run onboarding (issue #277).
#[test]
fn the_users_configuration_is_kept_by_default() {
    let models = [RouterModel {
        id: "test-model".to_string(),
        owned_by: "test".to_string(),
        ..RouterModel::default()
    }];
    let extended = TemporaryClient::prepare(&Preparation {
        client: ClientKind::ClaudeCode,
        base_url: "http://router.test",
        token: "task-token",
        model_override: None,
        models: &models,
        isolated_config: false,
        one_shot: true,
        profile_root: None,
        codex_reasoning_effort: None,
    })
    .expect("prepare with the default configuration handling");
    let names: Vec<String> = extended
        .command
        .get_envs()
        .map(|(name, _)| name.to_string_lossy().into_owned())
        .collect();
    assert!(
        !names.iter().any(|name| name == "CLAUDE_CONFIG_DIR"),
        "the user's configuration directory must not be repointed: {names:?}"
    );
    // The router's actual contribution is still applied.
    for required in ["ANTHROPIC_AUTH_TOKEN", "ANTHROPIC_BASE_URL"] {
        assert!(
            names.iter().any(|name| name == required),
            "{required} missing: {names:?}"
        );
    }
    let environment = extended
        .command
        .get_envs()
        .filter_map(|(name, value)| {
            Some((
                name.to_string_lossy().into_owned(),
                value?.to_string_lossy().into_owned(),
            ))
        })
        .collect::<std::collections::HashMap<_, _>>();
    assert_eq!(
        environment.get("ANTHROPIC_BASE_URL").map(String::as_str),
        Some("http://router.test/api/services/anthropic")
    );
    assert_eq!(
        environment
            .get("CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY")
            .map(String::as_str),
        Some("1")
    );
    assert_eq!(
        environment
            .get("CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC")
            .map(String::as_str),
        Some("0")
    );
    assert_eq!(
        environment.get("ANTHROPIC_API_KEY").map(String::as_str),
        Some("")
    );
    for untouched in [
        "ANTHROPIC_MODEL",
        "ANTHROPIC_DEFAULT_OPUS_MODEL",
        "ANTHROPIC_DEFAULT_SONNET_MODEL",
        "ANTHROPIC_DEFAULT_HAIKU_MODEL",
        "CLAUDE_CODE_SUBAGENT_MODEL",
    ] {
        assert!(!environment.contains_key(untouched), "{untouched}");
    }

    // Asking for isolation still repoints the directory.
    let isolated = TemporaryClient::prepare(&Preparation {
        client: ClientKind::ClaudeCode,
        base_url: "http://router.test",
        token: "task-token",
        model_override: None,
        models: &models,
        isolated_config: true,
        one_shot: true,
        profile_root: None,
        codex_reasoning_effort: None,
    })
    .expect("prepare isolated");
    assert!(
        isolated
            .command
            .get_envs()
            .any(|(name, _)| name == "CLAUDE_CONFIG_DIR"),
        "--isolated-config must still give the client its own directory"
    );
}

#[test]
fn zai_only_claude_launch_pins_only_main_and_subagent() {
    let models = [
        RouterModel {
            id: "future-first-2099".to_string(),
            owned_by: crate::clients::ZAI_MODEL_OWNER.to_string(),
            ..RouterModel::default()
        },
        RouterModel {
            id: "future-explicit-2099".to_string(),
            owned_by: crate::clients::ZAI_MODEL_OWNER.to_string(),
            ..RouterModel::default()
        },
    ];
    let resumed = TemporaryClient::prepare(&Preparation {
        client: ClientKind::ClaudeCode,
        base_url: "http://router.test",
        token: "task-token",
        model_override: None,
        models: &models,
        isolated_config: false,
        one_shot: false,
        profile_root: None,
        codex_reasoning_effort: None,
    })
    .expect("prepare a resumed z.ai-only Claude session");
    let resumed_env = resumed
        .command
        .get_envs()
        .filter_map(|(key, value)| {
            Some((
                key.to_string_lossy().into_owned(),
                value?.to_string_lossy().into_owned(),
            ))
        })
        .collect::<std::collections::HashMap<_, _>>();
    for key in crate::clients::CLAUDE_GATEWAY_TARGET_ENV {
        assert_eq!(
            resumed_env.get(key).map(String::as_str),
            Some("future-first-2099"),
            "{key}"
        );
    }
    for key in crate::clients::CLAUDE_MODEL_ENV {
        if !crate::clients::CLAUDE_GATEWAY_TARGET_ENV.contains(&key) {
            assert!(!resumed_env.contains_key(key), "{key}");
        }
    }

    let explicit = TemporaryClient::prepare(&Preparation {
        client: ClientKind::ClaudeCode,
        base_url: "http://router.test",
        token: "task-token",
        model_override: Some("future-explicit-2099"),
        models: &models,
        isolated_config: false,
        one_shot: true,
        profile_root: None,
        codex_reasoning_effort: None,
    })
    .expect("prepare an explicit z.ai Claude model");
    let explicit_env = explicit
        .command
        .get_envs()
        .filter_map(|(key, value)| {
            Some((
                key.to_string_lossy().into_owned(),
                value?.to_string_lossy().into_owned(),
            ))
        })
        .collect::<std::collections::HashMap<_, _>>();
    for key in crate::clients::CLAUDE_GATEWAY_TARGET_ENV {
        assert_eq!(
            explicit_env.get(key).map(String::as_str),
            Some("future-explicit-2099"),
            "explicit model must win for {key}"
        );
    }
    for key in crate::clients::CLAUDE_MODEL_ENV {
        if !crate::clients::CLAUDE_GATEWAY_TARGET_ENV.contains(&key) {
            assert!(!explicit_env.contains_key(key), "{key}");
        }
    }
}

/// Issue #379: Codex supports repeatable global `-c` overlays, so routing does
/// not require replacing `HOME` or `CODEX_HOME`. The overlay must precede the
/// user's subcommand and arguments; `launch` appends those after preparation.
#[test]
fn codex_overlays_routing_without_repointing_user_configuration() {
    let models = [RouterModel {
        id: "gpt-5.6-sol".to_string(),
        owned_by: "codex".to_string(),
        default_reasoning_level: Some("high".to_string()),
        supported_reasoning_levels: Some(vec![crate::clients::RouterReasoningLevel {
            effort: "high".to_string(),
            description: "Deep reasoning".to_string(),
        }]),
    }];
    assert!(
        extends_user_configuration(ClientKind::Codex, false),
        "ordinary Codex runs can layer routing through CLI configuration"
    );
    assert!(
        !extends_user_configuration(ClientKind::Codex, true),
        "explicit isolation must still replace the client configuration"
    );

    let prepared = TemporaryClient::prepare(&Preparation {
        client: ClientKind::Codex,
        base_url: "http://router.test/path?tenant=one",
        token: "task-token",
        model_override: None,
        models: &models,
        isolated_config: false,
        one_shot: true,
        profile_root: None,
        codex_reasoning_effort: None,
    })
    .expect("prepare Codex overlay");

    let environment = prepared
        .command
        .get_envs()
        .map(|(name, value)| (name.to_string_lossy().into_owned(), value))
        .collect::<std::collections::HashMap<_, _>>();
    assert!(!environment.contains_key("HOME"), "{environment:?}");
    assert!(!environment.contains_key("CODEX_HOME"), "{environment:?}");
    assert_eq!(
        environment
            .get("LINK_ASSISTANT_TOKEN")
            .and_then(|value| *value)
            .map(|value| value.to_string_lossy()),
        Some(std::borrow::Cow::Borrowed("task-token"))
    );

    let arguments = prepared
        .command
        .get_args()
        .map(|argument| argument.to_string_lossy().into_owned())
        .collect::<Vec<_>>();
    assert_eq!(
        arguments[0..3],
        ["-c", "model_provider=\"link-assistant\"", "-c"]
    );
    let catalog_path = arguments[3]
        .strip_prefix("model_catalog_json=")
        .and_then(|value| serde_json::from_str::<String>(value).ok())
        .expect("process-local model catalog argument");
    assert!(Path::new(&catalog_path).starts_with(prepared.directory.path()));
    let catalog: serde_json::Value = serde_json::from_slice(
        &std::fs::read(&catalog_path).expect("read process-local model catalog"),
    )
    .expect("parse process-local model catalog");
    assert_eq!(catalog["models"][0]["slug"], "gpt-5.6-sol");
    assert_eq!(catalog["models"][0]["default_reasoning_level"], "high");
    assert_eq!(
        catalog["models"][0]["supported_reasoning_levels"],
        json!([{"effort": "high", "description": "Deep reasoning"}])
    );
    assert_eq!(catalog["models"].as_array().unwrap().len(), 1);
    assert_eq!(
        arguments[4..],
        [
            "-c",
            "model_providers.link-assistant.name=\"Link.Assistant.Router\"",
            "-c",
            "model_providers.link-assistant.base_url=\"http://router.test/path?tenant=one/api/services/codex/v1\"",
            "-c",
            "model_providers.link-assistant.env_key=\"LINK_ASSISTANT_TOKEN\"",
            "-c",
            "model_providers.link-assistant.wire_api=\"responses\"",
        ]
    );

    let isolated = TemporaryClient::prepare(&Preparation {
        client: ClientKind::Codex,
        base_url: "http://router.test",
        token: "task-token",
        model_override: None,
        models: &models,
        isolated_config: true,
        one_shot: true,
        profile_root: None,
        codex_reasoning_effort: None,
    })
    .expect("prepare isolated Codex");
    let isolated_home = isolated
        .command
        .get_envs()
        .find_map(|(name, value)| (name == "HOME").then_some(value?))
        .expect("isolated Codex sets HOME");
    assert_eq!(Path::new(isolated_home), isolated.directory.path());
    assert!(
        isolated
            .command
            .get_envs()
            .any(|(name, value)| name == "CODEX_HOME" && value.is_none()),
        "isolation must prevent an inherited CODEX_HOME from escaping"
    );
    assert!(isolated.command.get_args().next().is_none());
    assert!(
        isolated
            .directory
            .path()
            .join(".codex/config.toml")
            .is_file()
    );
}

/// Issue #423: the disposable catalog is a projection of the live Codex
/// catalog, not a model capability table maintained by Router. Different live
/// entries must therefore keep their different defaults and supported levels.
#[test]
fn codex_catalog_preserves_per_model_live_reasoning_metadata() {
    let root = tempfile::tempdir().expect("temporary catalog directory");
    let models = [
        RouterModel {
            id: "future-reasoning-a".to_string(),
            owned_by: "openai".to_string(),
            default_reasoning_level: Some("medium".to_string()),
            supported_reasoning_levels: Some(vec![
                crate::clients::RouterReasoningLevel {
                    effort: "low".to_string(),
                    description: "Faster answers".to_string(),
                },
                crate::clients::RouterReasoningLevel {
                    effort: "medium".to_string(),
                    description: "Balanced reasoning".to_string(),
                },
                crate::clients::RouterReasoningLevel {
                    effort: "xhigh".to_string(),
                    description: "Deepest reasoning".to_string(),
                },
            ]),
        },
        RouterModel {
            id: "future-reasoning-b".to_string(),
            owned_by: "openai".to_string(),
            default_reasoning_level: Some("xhigh".to_string()),
            supported_reasoning_levels: Some(vec![crate::clients::RouterReasoningLevel {
                effort: "xhigh".to_string(),
                description: "Only supported level".to_string(),
            }]),
        },
    ];

    let path =
        write_codex_model_catalog(root.path(), &models, None, None).expect("write live catalog");
    let catalog: serde_json::Value =
        serde_json::from_slice(&std::fs::read(path).expect("read generated catalog"))
            .expect("parse generated catalog");

    assert_eq!(
        catalog["models"][0]["supported_reasoning_levels"],
        json!([
            {"effort": "low", "description": "Faster answers"},
            {"effort": "medium", "description": "Balanced reasoning"},
            {"effort": "xhigh", "description": "Deepest reasoning"}
        ])
    );
    assert_eq!(
        catalog["models"][1]["supported_reasoning_levels"],
        json!([{"effort": "xhigh", "description": "Only supported level"}])
    );
    assert_eq!(catalog["models"][0]["default_reasoning_level"], "medium");
    assert_eq!(catalog["models"][1]["default_reasoning_level"], "xhigh");
}

/// Missing capability metadata is different from an authoritative empty list:
/// launching with unknown metadata would make Codex silently discard an
/// explicit user effort after `/model`, so Router must stop with a useful error.
#[test]
fn codex_catalog_rejects_unknown_reasoning_metadata() {
    let root = tempfile::tempdir().expect("temporary catalog directory");
    let models = [RouterModel {
        id: "future-reasoning-unknown".to_string(),
        owned_by: "openai".to_string(),
        default_reasoning_level: None,
        supported_reasoning_levels: None,
    }];

    let error = write_codex_model_catalog(root.path(), &models, None, None)
        .expect_err("unknown reasoning metadata must not silently reset the user's setting")
        .to_string();
    assert!(error.contains("future-reasoning-unknown"), "{error}");
    assert!(error.contains("reasoning metadata"), "{error}");
}

#[test]
fn codex_catalog_never_offers_a_model_that_would_reset_an_explicit_effort() {
    let root = tempfile::tempdir().expect("temporary catalog directory");
    let models = [
        RouterModel {
            id: "future-supports-xhigh".to_string(),
            owned_by: "openai".to_string(),
            default_reasoning_level: Some("medium".to_string()),
            supported_reasoning_levels: Some(vec![
                crate::clients::RouterReasoningLevel {
                    effort: "medium".to_string(),
                    description: "Balanced reasoning".to_string(),
                },
                crate::clients::RouterReasoningLevel {
                    effort: "xhigh".to_string(),
                    description: "Deepest reasoning".to_string(),
                },
            ]),
        },
        RouterModel {
            id: "future-medium-only".to_string(),
            owned_by: "openai".to_string(),
            default_reasoning_level: Some("medium".to_string()),
            supported_reasoning_levels: Some(vec![crate::clients::RouterReasoningLevel {
                effort: "medium".to_string(),
                description: "Only supported level".to_string(),
            }]),
        },
    ];

    let path = write_codex_model_catalog(root.path(), &models, Some("xhigh"), None)
        .expect("write compatibility catalog");
    let catalog: serde_json::Value =
        serde_json::from_slice(&std::fs::read(path).expect("read generated catalog"))
            .expect("parse generated catalog");
    let slugs = catalog["models"]
        .as_array()
        .expect("models array")
        .iter()
        .filter_map(|model| model["slug"].as_str())
        .collect::<Vec<_>>();
    assert_eq!(slugs, ["future-supports-xhigh"]);

    let error = write_codex_model_catalog(
        root.path(),
        &models,
        Some("xhigh"),
        Some("future-medium-only"),
    )
    .expect_err("an explicit unsupported model must be rejected")
    .to_string();
    assert!(error.contains("future-medium-only"), "{error}");
    assert!(error.contains("xhigh"), "{error}");
}

/// A client configured through a file is isolated even though extending is
/// the default, because there is nothing to layer short of rewriting that
/// file.
///
/// A fallback rather than an error: the user did not ask for isolation, they
/// asked to run a client, and this is the only way it can be run. Refusing
/// was right while extending was opt-in — the flag could not be honoured —
/// but as a default it would make `with opencode` fail outright (issue
/// #277).
#[test]
fn a_file_configured_client_is_isolated_even_by_default() {
    let models = [RouterModel {
        id: "test-model".to_string(),
        owned_by: "test".to_string(),
        ..RouterModel::default()
    }];
    assert!(
        !extends_user_configuration(ClientKind::Opencode, false),
        "opencode sets no base-url variable, so there is nothing to layer"
    );
    assert!(
        extends_user_configuration(ClientKind::ClaudeCode, false),
        "claude code sets both variables, so the default extends"
    );
    assert!(
        !extends_user_configuration(ClientKind::ClaudeCode, true),
        "--isolated-config wins over the default"
    );

    // And it still prepares rather than failing.
    let profiles = tempfile::tempdir().expect("profile root");
    TemporaryClient::prepare(&Preparation {
        client: ClientKind::Opencode,
        base_url: "http://router.test",
        token: "task-token",
        model_override: None,
        models: &models,
        isolated_config: false,
        one_shot: true,
        profile_root: Some(profiles.path()),
        codex_reasoning_effort: None,
    })
    .expect("a file-configured client must still run");
}

/// Gemini CLI sets both connection variables and still cannot be extended.
///
/// It is pointed at the router by a `settings.json` it resolves from `HOME`,
/// so extending — which leaves `HOME` alone — would write that file where
/// the client never looks and let the user's own settings decide the run
/// (issue #227). Having both variables is therefore not enough to layer
/// onto, and the default must not assume it is.
#[test]
fn a_client_needing_a_written_file_is_isolated_despite_its_variables() {
    let integration = ClientKind::GeminiCli.integration();
    assert!(
        integration.token_env.is_some() && integration.base_url_env.is_some(),
        "the variables alone would otherwise qualify it for extending"
    );
    assert!(
        !extends_user_configuration(ClientKind::GeminiCli, false),
        "routing depends on a file only isolation makes reachable"
    );
}

#[test]
fn a_prepared_gemini_run_leaves_settings_where_the_cli_reads_them() {
    let models = [RouterModel {
        id: "test-model".to_string(),
        owned_by: "test".to_string(),
        ..RouterModel::default()
    }];
    let profiles = tempfile::tempdir().expect("profile root");
    let temporary = TemporaryClient::prepare(&Preparation {
        client: ClientKind::GeminiCli,
        base_url: "http://router.test",
        token: "task-token",
        model_override: None,
        models: &models,
        isolated_config: false,
        one_shot: true,
        profile_root: Some(profiles.path()),
        codex_reasoning_effort: None,
    })
    .expect("prepare gemini");
    let root = temporary.directory.path();
    let home = temporary
        .command
        .get_envs()
        .find_map(|(name, value)| (name == "HOME").then_some(value?))
        .expect("gemini run sets HOME");
    // The CLI resolves its settings from HOME; the file must be there.
    let settings = Path::new(home).join(".gemini/settings.json");
    assert!(
        settings.is_file(),
        "no settings at {}, which is where the CLI looks",
        settings.display()
    );
    let written = fs::read_to_string(&settings).expect("read settings");
    assert!(written.contains("gemini-api-key"), "{written}");
    assert!(Path::new(home).starts_with(root), "HOME escaped the root");
}

/// An isolated run must be governed by the settings the router wrote. The
/// previous `create_new` silently deferred to whatever was already there,
/// which with the `HOME` fix would let an inherited `oauth-personal`
/// survive and fail the run.
#[test]
fn written_gemini_settings_replace_an_existing_file() {
    let root = tempfile::tempdir().expect("isolated root");
    let path = root.path().join(".gemini/settings.json");
    fs::create_dir_all(path.parent().expect("parent")).expect("create directory");
    fs::write(
        &path,
        r#"{"security":{"auth":{"selectedType":"oauth-personal"}}}"#,
    )
    .expect("seed a conflicting file");

    write_gemini_settings(&path).expect("write settings");

    let written = fs::read_to_string(&path).expect("read settings");
    assert!(written.contains("gemini-api-key"), "{written}");
    assert!(
        !written.contains("oauth-personal"),
        "the inherited value survived: {written}"
    );
}

/// The value itself is the one the CLI accepts; a wrong spelling is what
/// produced the original error, so it is pinned rather than assumed.
#[test]
fn gemini_settings_select_the_api_key_flow() {
    let root = tempfile::tempdir().expect("isolated root");
    let path = root.path().join(".gemini/settings.json");
    write_gemini_settings(&path).expect("write settings");
    let written: serde_json::Value =
        serde_json::from_str(&fs::read_to_string(&path).expect("read")).expect("valid JSON");
    assert_eq!(
        written["security"]["auth"]["selectedType"],
        "gemini-api-key"
    );
}

/// Every client prepares under a root the router owns, and only the ones
/// that were meant to be thrown away are.
///
/// A client routed through a file the router writes *lives* in that
/// directory. Discarding it after every run made every launch a first
/// launch — no session history, so nothing to resume, and onboarding
/// answered again from scratch (issue #298).
#[test]
fn a_client_that_cannot_be_extended_keeps_its_profile() {
    let models = [RouterModel {
        id: "test-model".to_string(),
        owned_by: "test".to_string(),
        default_reasoning_level: Some("medium".to_string()),
        supported_reasoning_levels: Some(vec![crate::clients::RouterReasoningLevel {
            effort: "medium".to_string(),
            description: "Test reasoning".to_string(),
        }]),
    }];
    let profiles = tempfile::tempdir().expect("profile root");
    for client in ClientKind::ALL {
        if client == ClientKind::Cursor {
            assert!(
                TemporaryClient::prepare(&Preparation {
                    client,
                    base_url: "http://router.test",
                    token: "task-token",
                    model_override: None,
                    models: &models,
                    isolated_config: false,
                    one_shot: true,
                    profile_root: Some(profiles.path()),
                    codex_reasoning_effort: None,
                })
                .is_err()
            );
            continue;
        }
        let temporary = TemporaryClient::prepare(&Preparation {
            client,
            base_url: "http://router.test",
            token: "task-token",
            model_override: None,
            models: &models,
            isolated_config: false,
            one_shot: true,
            profile_root: Some(profiles.path()),
            codex_reasoning_effort: None,
        })
        .unwrap_or_else(|error| panic!("{client} failed setup: {error}"));
        let root = temporary.directory.path().to_path_buf();
        assert_eq!(temporary.command.get_program(), client.command());
        let environment = temporary
            .command
            .get_envs()
            .filter_map(|(name, value)| value.map(|value| (name, value)))
            .collect::<std::collections::HashMap<_, _>>();
        if let Some(token_env) = client.token_env() {
            assert_eq!(
                environment.get(std::ffi::OsStr::new(token_env)).copied(),
                Some(std::ffi::OsStr::new("task-token")),
                "{client} did not receive its token environment"
            );
        }
        for name in [
            "HOME",
            "CLAUDE_CONFIG_DIR",
            "GEMINI_CLI_HOME",
            "OPENCODE_CONFIG",
            "OPENCODE_CONFIG_DIR",
        ] {
            if let Some(value) = environment.get(std::ffi::OsStr::new(name)) {
                assert!(
                    Path::new(value).starts_with(&root),
                    "{client} {name} escaped its root"
                );
            }
        }
        let keeps_a_profile = !extends_user_configuration(client, false);
        drop(temporary);
        assert_eq!(
            root.exists(),
            keeps_a_profile,
            "{client}: a client routed through a written file must keep its profile, and \
             one that only needs two environment variables must not leave a directory behind"
        );
        if keeps_a_profile {
            assert!(
                root.starts_with(profiles.path()),
                "{client} profile must live under the router's own directory, not TMPDIR: \
                 {}",
                root.display()
            );
        }
    }
}

/// The same client twice gets the same directory, which is what makes a
/// session resumable through the router.
#[test]
fn two_runs_of_the_same_client_share_one_profile() {
    let profiles = tempfile::tempdir().expect("profile root");
    let root = Some(profiles.path());
    let first = persistent_profile(ClientKind::Codex, root).expect("first profile");
    let second = persistent_profile(ClientKind::Codex, root).expect("second profile");
    assert_eq!(first, second);
    assert!(first.is_dir());
    assert_ne!(
        first,
        persistent_profile(ClientKind::GeminiCli, root).expect("another client")
    );
}

#[test]
fn registry_order_matches_client_discriminants() {
    for client in ClientKind::ALL {
        assert_eq!(client.integration().kind, client);
    }
}

/// The default label names the client and a run, never the directory the
/// command was run in — a deployment was accumulating a list of every project
/// its users work in, visible to anyone who can list tokens (issue #316).
#[test]
fn the_default_label_carries_no_directory_name() {
    let label = format!("with-{}-{}", ClientKind::ClaudeCode, super::run_suffix());

    assert!(label.starts_with("with-claude-"), "{label}");
    // Whatever the working directory is called, it is not in the label.
    let cwd = std::env::current_dir().expect("cwd");
    let name = cwd
        .file_name()
        .expect("directory name")
        .to_string_lossy()
        .into_owned();
    assert!(
        !label.contains(&name),
        "the working directory's name must not reach the router: {label} contains {name}"
    );
    // The suffix distinguishes concurrent runs without describing them.
    assert_eq!(super::run_suffix().len(), 4, "a fixed-width run suffix");
    assert_eq!(
        super::run_suffix(),
        super::run_suffix(),
        "stable within one process, so one run has one label"
    );
}