context7-cli 0.4.2

//! Testes de integração E2E para a CLI `context7`.
//!
//! Todos os testes invocam o binário compilado via `assert_cmd::Command::cargo_bin`.
//! Nenhum teste faz I/O de rede real — requisições à API Context7 são isoladas via
//! variável de ambiente ausente (sem chave) ou via wiremock para os paths HTTP.
//! Nenhum teste modifica o sistema de arquivos real do usuário — usa `CONTEXT7_HOME`
//! apontando para `tempfile::TempDir`.

use assert_cmd::Command;
use predicates::prelude::*;
use serial_test::serial;
use tempfile::TempDir;

// ── Helpers ───────────────────────────────────────────────────────────────────

/// Cria um comando `context7` isolado: sem variáveis de ambiente do shell do usuário
/// que possam vazar chaves de API ou configurações XDG reais.
///
/// IMPORTANTE: NÃO define `CONTEXT7_LANG` nem `CONTEXT7_API_KEYS` — definir como string
/// vazia faz o clap tentar parsear `""` contra `value_parser = ["en", "pt"]` e falha.
/// O isolamento de chaves é garantido pelo `CONTEXT7_HOME` apontando para um diretório
/// temporário sem nenhum `config.toml`.
#[allow(deprecated)] // cargo_bin depreciado no assert_cmd 2.1.0+ (build-dir custom); este projeto não usa build-dir customizado
fn cmd_isolado(xdg_home: &TempDir) -> Command {
    let mut cmd = Command::cargo_bin("context7").unwrap();
    cmd.env_clear()
        .env("CONTEXT7_HOME", xdg_home.path())
        .env("HOME", xdg_home.path());
    cmd
}

// ── Testes de --help ───────────────────────────────────────────────────────────

/// Verifica que `--help` termina com exit 0 e contém "Usage".
#[test]
fn testa_help_renderiza_sem_panico() {
    let dir = TempDir::new().unwrap();
    cmd_isolado(&dir)
        .arg("--help")
        .assert()
        .success()
        .stdout(predicate::str::contains("Usage").or(predicate::str::contains("usage")));
}

/// Verifica que `--version` não causa panic (pode retornar erro se flag não habilitada).
/// A flag `--version` requer `#[command(version)]` no struct Cli do clap.
/// Na v0.1.0 sem essa anotação, a flag não existe — o teste verifica apenas ausência de panic.
#[test]
fn testa_version_nao_causa_panic() {
    let dir = TempDir::new().unwrap();
    let saida = cmd_isolado(&dir).arg("--version").output().unwrap();
    // Pode retornar exit != 0 se --version não estiver habilitada, mas não deve panic
    let stderr = String::from_utf8_lossy(&saida.stderr);
    assert!(
        !stderr.contains("thread 'main' panicked"),
        "--version não deve causar panic: {stderr}"
    );
}

/// Verifica que `context7 library --help` mostra a ajuda do subcomando.
#[test]
fn testa_help_subcomando_library() {
    let dir = TempDir::new().unwrap();
    cmd_isolado(&dir)
        .args(["library", "--help"])
        .assert()
        .success()
        .stdout(predicate::str::contains("Usage").or(predicate::str::contains("nome")));
}

/// Verifica que `context7 docs --help` mostra a ajuda do subcomando.
#[test]
fn testa_help_subcomando_docs() {
    let dir = TempDir::new().unwrap();
    cmd_isolado(&dir)
        .args(["docs", "--help"])
        .assert()
        .success()
        .stdout(predicate::str::contains("Usage").or(predicate::str::contains("library")));
}

/// Verifica que `context7 keys --help` mostra a ajuda do subcomando.
#[test]
fn testa_help_subcomando_keys() {
    let dir = TempDir::new().unwrap();
    cmd_isolado(&dir)
        .args(["keys", "--help"])
        .assert()
        .success()
        .stdout(predicate::str::contains("Usage").or(predicate::str::contains("subcommand")));
}

// ── Testes de erros sem chave de API ──────────────────────────────────────────

/// Sem chave de API, `library` deve falhar com mensagem amigável (não panic).
#[test]
#[serial]
fn testa_subcomando_library_sem_chave_retorna_erro_amigavel() {
    let dir = TempDir::new().unwrap();
    let saida = cmd_isolado(&dir)
        .args(["library", "react"])
        .output()
        .unwrap();
    // Deve terminar com exit code não-zero
    assert!(!saida.status.success(), "esperava falha sem chave de API");
    // A mensagem de erro deve ser amigável, não um panic
    let stderr = String::from_utf8_lossy(&saida.stderr);
    let stdout = String::from_utf8_lossy(&saida.stdout);
    let saida_combinada = format!("{}{}", stdout, stderr);
    assert!(
        !saida_combinada.contains("thread 'main' panicked"),
        "não deve causar panic: {saida_combinada}"
    );
    assert!(
        !saida_combinada.contains("unwrap()"),
        "não deve vazar mensagem de unwrap: {saida_combinada}"
    );
}

/// Sem chave de API, `docs` deve falhar com mensagem amigável (não panic).
#[test]
#[serial]
fn testa_subcomando_docs_sem_chave_retorna_erro_amigavel() {
    let dir = TempDir::new().unwrap();
    let saida = cmd_isolado(&dir)
        .args(["docs", "/facebook/react"])
        .output()
        .unwrap();
    assert!(!saida.status.success(), "esperava falha sem chave de API");
    let stderr = String::from_utf8_lossy(&saida.stderr);
    let stdout = String::from_utf8_lossy(&saida.stdout);
    let saida_combinada = format!("{}{}", stdout, stderr);
    assert!(
        !saida_combinada.contains("thread 'main' panicked"),
        "não deve causar panic: {saida_combinada}"
    );
}

// ── Testes do subcomando keys (sem rede) ──────────────────────────────────────

/// `keys list` com config vazia retorna mensagem apropriada (exit 0).
#[test]
#[serial]
fn testa_subcomando_keys_list_vazio_retorna_mensagem_apropriada() {
    let dir = TempDir::new().unwrap();
    cmd_isolado(&dir)
        .args(["keys", "list"])
        .assert()
        .success()
        .stdout(
            predicate::str::contains("Nenhuma chave")
                .or(predicate::str::contains("0 chave"))
                .or(predicate::str::contains("No key"))
                .or(predicate::str::contains("No keys")),
        );
}

/// `keys path` retorna um caminho de arquivo (contém o CONTEXT7_HOME override).
#[test]
#[serial]
fn testa_subcomando_keys_path_retorna_caminho_xdg() {
    let dir = TempDir::new().unwrap();
    let dir_path = dir.path().to_str().unwrap().to_owned();
    cmd_isolado(&dir)
        .args(["keys", "path"])
        .assert()
        .success()
        .stdout(predicate::str::contains(&dir_path).or(predicate::str::contains("context7")));
}

/// `keys add` adiciona uma chave com sucesso (exit 0).
#[test]
#[serial]
fn testa_subcomando_keys_add_sucesso() {
    let dir = TempDir::new().unwrap();
    cmd_isolado(&dir)
        .args(["keys", "add", "ctx7sk-teste-chave-123456789012"])
        .assert()
        .success();
}

/// `keys add` + `keys list` mostra a chave mascarada.
#[test]
#[serial]
fn testa_keys_add_depois_list_mostra_chave_mascarada() {
    let dir = TempDir::new().unwrap();
    // Adiciona chave
    cmd_isolado(&dir)
        .args(["keys", "add", "ctx7sk-chave-integracao-12345678"])
        .assert()
        .success();
    // Lista deve mostrar exatamente 1 chave
    cmd_isolado(&dir)
        .args(["keys", "list"])
        .assert()
        .success()
        .stdout(predicate::str::contains("1 chave").or(predicate::str::contains("[1]")));
}

/// `keys remove` com índice inválido retorna mensagem de erro amigável (exit 0 — erro controlado).
#[test]
#[serial]
fn testa_keys_remove_indice_invalido_retorna_mensagem_amigavel() {
    let dir = TempDir::new().unwrap();
    // Sem chaves, remove índice 99 — deve ser controlado
    let saida = cmd_isolado(&dir)
        .args(["keys", "remove", "99"])
        .output()
        .unwrap();
    // Não deve panic
    let stderr = String::from_utf8_lossy(&saida.stderr);
    let stdout = String::from_utf8_lossy(&saida.stdout);
    assert!(
        !format!("{stdout}{stderr}").contains("thread 'main' panicked"),
        "remove com índice inválido não deve panic"
    );
}

/// `keys clear --yes` remove todas as chaves (exit 0).
#[test]
#[serial]
fn testa_keys_clear_yes_sucesso() {
    let dir = TempDir::new().unwrap();
    // Adiciona uma chave primeiro
    cmd_isolado(&dir)
        .args(["keys", "add", "ctx7sk-para-limpar-123456789012"])
        .assert()
        .success();
    // Limpa com --yes
    cmd_isolado(&dir)
        .args(["keys", "clear", "--yes"])
        .assert()
        .success();
    // Lista deve estar vazia agora
    cmd_isolado(&dir)
        .args(["keys", "list"])
        .assert()
        .success()
        .stdout(
            predicate::str::contains("Nenhuma chave")
                .or(predicate::str::contains("0 chave"))
                .or(predicate::str::contains("No key"))
                .or(predicate::str::contains("No keys")),
        );
}

/// `keys export` sem chaves produz saída vazia (exit 0).
#[test]
#[serial]
fn testa_keys_export_sem_chaves_saida_vazia() {
    let dir = TempDir::new().unwrap();
    cmd_isolado(&dir)
        .args(["keys", "export"])
        .assert()
        .success()
        .stdout(predicate::str::is_empty().or(predicate::str::contains("CONTEXT7_API=")));
}

/// `keys export` com chave exporta no formato CONTEXT7_API=<valor>.
#[test]
#[serial]
fn testa_keys_export_com_chave_formato_correto() {
    let dir = TempDir::new().unwrap();
    let chave = "ctx7sk-export-teste-123456789012";
    cmd_isolado(&dir)
        .args(["keys", "add", chave])
        .assert()
        .success();
    cmd_isolado(&dir)
        .args(["keys", "export"])
        .assert()
        .success()
        .stdout(predicate::str::contains(format!("CONTEXT7_API={chave}")));
}

// ── Testes de aliases ──────────────────────────────────────────────────────────

/// O alias `lib` é equivalente a `library` — deve mostrar a mesma ajuda.
#[test]
fn testa_alias_lib_equivale_a_library() {
    let dir = TempDir::new().unwrap();
    let saida_library = cmd_isolado(&dir)
        .args(["library", "--help"])
        .output()
        .unwrap();
    let saida_lib = cmd_isolado(&dir).args(["lib", "--help"]).output().unwrap();
    assert_eq!(
        saida_library.status.success(),
        saida_lib.status.success(),
        "alias lib deve ter mesmo exit code que library"
    );
    assert_eq!(
        saida_library.stdout, saida_lib.stdout,
        "alias lib deve produzir mesma saída que library"
    );
}

/// O alias `doc` é equivalente a `docs` — deve mostrar a mesma ajuda.
#[test]
fn testa_alias_doc_equivale_a_docs() {
    let dir = TempDir::new().unwrap();
    let saida_docs = cmd_isolado(&dir).args(["docs", "--help"]).output().unwrap();
    let saida_doc = cmd_isolado(&dir).args(["doc", "--help"]).output().unwrap();
    assert_eq!(
        saida_docs.status.success(),
        saida_doc.status.success(),
        "alias doc deve ter mesmo exit code que docs"
    );
    assert_eq!(
        saida_docs.stdout, saida_doc.stdout,
        "alias doc deve produzir mesma saída que docs"
    );
}

/// O alias `key` é equivalente a `keys` — deve mostrar a mesma ajuda.
#[test]
fn testa_alias_key_equivale_a_keys() {
    let dir = TempDir::new().unwrap();
    let saida_keys = cmd_isolado(&dir).args(["keys", "--help"]).output().unwrap();
    let saida_key = cmd_isolado(&dir).args(["key", "--help"]).output().unwrap();
    assert_eq!(
        saida_keys.status.success(),
        saida_key.status.success(),
        "alias key deve ter mesmo exit code que keys"
    );
    assert_eq!(
        saida_keys.stdout, saida_key.stdout,
        "alias key deve produzir mesma saída que keys"
    );
}

/// Subcomando inválido deve retornar exit code não-zero.
#[test]
fn testa_subcomando_invalido_retorna_exit_code_nao_zero() {
    let dir = TempDir::new().unwrap();
    cmd_isolado(&dir)
        .arg("subcomando-que-nao-existe")
        .assert()
        .failure();
}

/// Flag `--json` combinada com `keys list` deve ser aceita sem crash.
#[test]
#[serial]
fn testa_flag_json_com_keys_list_nao_crasha() {
    let dir = TempDir::new().unwrap();
    // Não deve panic — independente do conteúdo da saída
    let saida = cmd_isolado(&dir)
        .args(["--json", "keys", "list"])
        .output()
        .unwrap();
    let stderr = String::from_utf8_lossy(&saida.stderr);
    assert!(
        !stderr.contains("thread 'main' panicked"),
        "não deve panic com --json keys list"
    );
}

// ── Testes novos v0.2.1 — cobertura dos bugs corrigidos ──────────────────────

/// `docs` sem chaves de API exibe mensagem de erro sem panic.
///
/// Garante que a ausência de chaves não causa panic ou stack overflow,
/// apenas uma mensagem de erro controlada.
#[test]
#[serial]
fn testa_docs_sem_chaves_exibe_erro_sem_panico() {
    let dir = TempDir::new().unwrap();
    let saida = cmd_isolado(&dir)
        .args(["docs", "/test/lib"])
        .output()
        .unwrap();

    assert!(!saida.status.success(), "docs sem chaves deve falhar");

    let stderr = String::from_utf8_lossy(&saida.stderr);
    let stdout = String::from_utf8_lossy(&saida.stdout);
    let combinado = format!("{stdout}{stderr}");

    assert!(
        !combinado.contains("thread 'main' panicked"),
        "docs sem chaves não deve causar panic: {combinado}"
    );
    assert!(
        !combinado.contains("unwrap()"),
        "docs sem chaves não deve vazar mensagem de unwrap: {combinado}"
    );
}

/// `context7 docs --help` renderiza ajuda sem crash.
#[test]
fn testa_docs_help_renderiza() {
    let dir = TempDir::new().unwrap();
    cmd_isolado(&dir)
        .args(["docs", "--help"])
        .assert()
        .success()
        .stdout(predicate::str::contains("Usage").or(predicate::str::contains("usage")));
}

/// `keys rotate` retorna "unrecognized subcommand" — garante que esse subcomando
/// foi intencionalmente removido na v0.2.0+ e não foi re-adicionado por engano.
///
/// Se este teste falhar, alguém adicionou `rotate` de volta — revisar intenção.
#[test]
fn testa_keys_rotate_retorna_erro_subcomando_nao_reconhecido() {
    let dir = TempDir::new().unwrap();
    let saida = cmd_isolado(&dir).args(["keys", "rotate"]).output().unwrap();

    assert!(
        !saida.status.success(),
        "keys rotate deve retornar exit != 0"
    );

    let stderr = String::from_utf8_lossy(&saida.stderr);
    assert!(
        stderr.contains("unrecognized") || stderr.contains("error"),
        "stderr deve mencionar subcomando inválido: {stderr}"
    );
    assert!(
        !stderr.contains("thread 'main' panicked"),
        "keys rotate não deve causar panic: {stderr}"
    );
}

// ── Testes novos v0.2.3 — parâmetros clap em EN (Bug #2) ─────────────────────

/// `library --help` deve exibir `<NAME>` e não `<NOME>` após renomear o parâmetro.
///
/// v0.2.2: exibia `<NOME>` (identificador Rust em PT).
/// v0.2.3: deve exibir `<NAME>` (padrão EN para binários publicados no crates.io).
#[test]
fn testa_library_help_exibe_name_em_ingles() {
    let dir = TempDir::new().unwrap();
    cmd_isolado(&dir)
        .args(["library", "--help"])
        .assert()
        .success()
        .stdout(predicate::str::contains("<NAME>"))
        .stdout(predicate::str::contains("<NOME>").not());
}

/// `keys add --help` deve exibir `<KEY>` e não `<CHAVE>`.
///
/// v0.2.2: exibia `<CHAVE>`.
/// v0.2.3: deve exibir `<KEY>`.
#[test]
fn testa_keys_add_help_exibe_key_em_ingles() {
    let dir = TempDir::new().unwrap();
    cmd_isolado(&dir)
        .args(["keys", "add", "--help"])
        .assert()
        .success()
        .stdout(predicate::str::contains("<KEY>"))
        .stdout(predicate::str::contains("<CHAVE>").not());
}

/// `keys remove --help` deve exibir `<INDEX>` e não `<INDICE>`.
///
/// v0.2.2: exibia `<INDICE>`.
/// v0.2.3: deve exibir `<INDEX>`.
#[test]
fn testa_keys_remove_help_exibe_index_em_ingles() {
    let dir = TempDir::new().unwrap();
    cmd_isolado(&dir)
        .args(["keys", "remove", "--help"])
        .assert()
        .success()
        .stdout(predicate::str::contains("<INDEX>"))
        .stdout(predicate::str::contains("<INDICE>").not());
}

/// `keys import --help` deve exibir `<FILE>` e não `<ARQUIVO>`.
///
/// v0.2.2: exibia `<ARQUIVO>`.
/// v0.2.3: deve exibir `<FILE>`.
#[test]
fn testa_keys_import_help_exibe_file_em_ingles() {
    let dir = TempDir::new().unwrap();
    cmd_isolado(&dir)
        .args(["keys", "import", "--help"])
        .assert()
        .success()
        .stdout(predicate::str::contains("<FILE>"))
        .stdout(predicate::str::contains("<ARQUIVO>").not());
}

// ── Testes novos v0.2.3 — hint hardcoded em PT removido (Bug #3) ─────────────

/// `library --help` NÃO deve conter o exemplo "hooks de efeito" (PT hardcoded).
///
/// v0.2.2: exibia `(e.g. "hooks de efeito")` no doc comment do parâmetro `query`.
/// v0.2.3: deve exibir `(e.g. "effect hooks")` — exemplo em EN neutro.
#[test]
fn testa_library_help_nao_contem_hooks_de_efeito() {
    let dir = TempDir::new().unwrap();
    cmd_isolado(&dir)
        .args(["library", "--help"])
        .assert()
        .success()
        .stdout(predicate::str::contains("hooks de efeito").not());
}

/// `library --help` deve conter o exemplo em EN após correção do Bug #3.
///
/// v0.2.3: exemplo passa a ser `"effect hooks"` em vez de `"hooks de efeito"`.
#[test]
fn testa_library_help_contem_exemplo_em_ingles() {
    let dir = TempDir::new().unwrap();
    cmd_isolado(&dir)
        .args(["library", "--help"])
        .assert()
        .success()
        .stdout(predicate::str::contains("effect hooks"));
}

// ── Testes novos v0.2.3 — dica BibliotecaNaoEncontradaApi (Bug #1) ───────────

/// `docs` com biblioteca inexistente deve exibir dica de verificar o ID no stderr.
///
/// v0.2.2: quando HTTP 404, o erro era "Library not found: /id" sem dica de como
/// encontrar o ID correto — deixava o usuário sem ação clara.
/// v0.2.3: após o erro, deve aparecer "context7 library <name>" (EN) ou
/// "context7 library <nome>" (PT) no stderr como dica de próxima ação.
///
/// Usa wiremock para simular resposta 404 sem depender de rede real.
/// NOTA: Este teste usa assert_cmd diretamente com CONTEXT7_HOME apontando
/// para um diretório com uma chave falsa, forçando o binário a chamar a API.
/// Como não temos como injetar wiremock no binário compilado facilmente,
/// testamos via testes unitários de output.rs e i18n.rs.
#[test]
fn testa_dica_biblioteca_nao_encontrada_mensagem_contem_library_command() {
    // Verifica que a mensagem de dica da variante BibliotecaNaoEncontradaApi
    // em ambos os idiomas menciona o comando "library" para guiar o usuário.
    use context7_cli::i18n::{Idioma, Mensagem};
    let en = Mensagem::BibliotecaNaoEncontradaApi.texto(Idioma::English);
    let pt = Mensagem::BibliotecaNaoEncontradaApi.texto(Idioma::Portugues);

    assert!(
        en.to_lowercase().contains("library"),
        "dica EN deve mencionar 'library': {en}"
    );
    assert!(
        pt.to_lowercase().contains("library"),
        "dica PT deve mencionar 'library': {pt}"
    );
}

/// `docs` sem chaves exibe mensagem de erro sem mencionar o mecanismo interno de retry.
///
/// Garante que a mensagem de erro não expõe detalhes de implementação (como
/// "No valid API key after 5 attempts") quando o verdadeiro problema é a ausência de chaves.
#[test]
#[serial]
fn testa_docs_sem_chaves_nao_expoe_detalhes_internos_de_retry() {
    let dir = TempDir::new().unwrap();
    let saida = cmd_isolado(&dir)
        .args(["docs", "/biblioteca/inexistente"])
        .output()
        .unwrap();

    assert!(!saida.status.success(), "docs sem chaves deve falhar");

    let stderr = String::from_utf8_lossy(&saida.stderr);
    let stdout = String::from_utf8_lossy(&saida.stdout);
    let combinado = format!("{stdout}{stderr}");

    // Não deve vazar detalhe de implementação de retry
    assert!(
        !combinado.contains("No valid API key after"),
        "mensagem não deve expor mecanismo de retry: {combinado}"
    );
    assert!(
        !combinado.contains("thread 'main' panicked"),
        "não deve causar panic: {combinado}"
    );
}

// ── Testes regression EXTRA-01/03/04 (v0.2.6) ────────────────────────────────

/// EXTRA-01 — Alias `-q` aparece no help de `docs` e está mapeado para `--query`.
///
/// Regression test: garante que a flag curta `-q` foi registrada no clap e aparece
/// no texto de ajuda do subcomando `docs`. Não realiza chamada de rede.
#[test]
fn testa_docs_help_exibe_alias_q_e_long_query() {
    let dir = TempDir::new().unwrap();
    let saida = cmd_isolado(&dir).args(["docs", "--help"]).output().unwrap();

    assert!(
        saida.status.success(),
        "docs --help deve terminar com sucesso"
    );

    let stdout = String::from_utf8_lossy(&saida.stdout);
    assert!(
        stdout.contains("-q") && stdout.contains("--query"),
        "help de docs deve exibir '-q, --query': {stdout}"
    );
}

/// EXTRA-01 — Alias `-q` é aceito pelo parser do clap sem erro de argumento.
///
/// Usa `CONTEXT7_API_KEYS=ctx7sk-fake` para forçar parse OK + falha na API (não parse),
/// verificando que `-q` não causa "unexpected argument".
#[test]
fn testa_docs_alias_q_e_aceito_como_argumento_valido() {
    let dir = TempDir::new().unwrap();
    let saida = cmd_isolado(&dir)
        .env("CONTEXT7_API_KEYS", "ctx7sk-fake-key-12345678901")
        .args(["docs", "/reactjs/react.dev", "-q", "hooks"])
        .output()
        .unwrap();

    let stderr = String::from_utf8_lossy(&saida.stderr);
    // O parser NÃO deve rejeitar -q como argumento desconhecido
    assert!(
        !stderr.contains("unexpected argument"),
        "'-q' não deve ser rejeitado como argumento desconhecido: {stderr}"
    );
    assert!(
        !stderr.contains("thread 'main' panicked"),
        "não deve causar panic: {stderr}"
    );
}

/// EXTRA-03 — `keys import` com arquivo inexistente exibe mensagem útil (não panic).
///
/// Regression test: garante que a mensagem de erro menciona o arquivo ou o problema
/// de leitura, sem expor stack trace ou mensagem de sistema ininteligível.
#[test]
fn testa_keys_import_arquivo_inexistente_mensagem_util() {
    let dir = TempDir::new().unwrap();
    cmd_isolado(&dir)
        .args(["keys", "import", "/tmp/arquivo-que-nao-existe-v026.env"])
        .assert()
        .failure()
        .stderr(
            predicate::str::contains("arquivo")
                .or(predicate::str::contains("file"))
                .or(predicate::str::contains("No such")),
        );
}

/// EXTRA-03 — `keys import` com arquivo sem entradas `CONTEXT7_API=` exibe mensagem útil.
///
/// Regression test: garante que a mensagem de erro menciona `CONTEXT7_API` para guiar
/// o usuário sobre o formato esperado.
#[test]
fn testa_keys_import_arquivo_sem_chaves_context7_mensagem_util() {
    let dir = TempDir::new().unwrap();
    let arquivo_invalido = dir.path().join("invalido.env");
    std::fs::write(
        &arquivo_invalido,
        "LIXO=nao_e_chave_context7\nOUTRA_VAR=valor\n",
    )
    .unwrap();

    cmd_isolado(&dir)
        .args(["keys", "import", arquivo_invalido.to_str().unwrap()])
        .assert()
        .failure()
        .stderr(predicate::str::contains("CONTEXT7_API"));
}

/// EXTRA-04 — `keys add` com chave duplicada avisa em vez de fingir sucesso silencioso.
///
/// Regression test: garante que a segunda adição da mesma chave exibe mensagem indicando
/// que a chave já existia (não simplesmente adiciona duplicata sem aviso).
#[test]
#[serial]
fn testa_keys_add_duplicata_exibe_aviso_de_chave_existente() {
    let dir = TempDir::new().unwrap();
    let chave = "ctx7sk-dedup-regression-v026-abc";

    // 1ª adição: deve ter sucesso
    cmd_isolado(&dir)
        .args(["keys", "add", chave])
        .assert()
        .success();

    // 2ª adição da mesma chave: deve avisar
    let saida = cmd_isolado(&dir)
        .args(["keys", "add", chave])
        .output()
        .unwrap();

    let stdout = String::from_utf8_lossy(&saida.stdout);
    let stderr = String::from_utf8_lossy(&saida.stderr);
    let combinado = format!("{stdout}{stderr}");

    // Deve conter indicação de chave existente ou ignorada
    assert!(
        combinado.to_lowercase().contains("existe")
            || combinado.to_lowercase().contains("exists")
            || combinado.to_lowercase().contains("already")
            || combinado.to_lowercase().contains("ignor")
            || combinado.to_lowercase().contains("skip"),
        "segunda adição deve exibir aviso de duplicata. stdout='{stdout}' stderr='{stderr}'"
    );

    // Não deve causar panic
    assert!(
        !combinado.contains("thread 'main' panicked"),
        "não deve causar panic: {combinado}"
    );
}

// ── Regression tests v0.2.8 (gaps QA) ─────────────────────────────────────────

/// FAIL-1 QA v0.2.8 — `keys import` sem CONTEXT7_API= exibe mensagem de erro
/// contendo o caminho do arquivo tanto na mensagem principal quanto na linha
/// "Caused by:" do anyhow chain.
///
/// Regression: garante que o caminho do arquivo está presente na saída de erro,
/// evitando regressão onde "Caused by:" repetiria mensagem truncada sem o caminho.
#[test]
#[serial]
fn testa_regressao_qa028_fail1_import_sem_chaves_erro_contem_caminho() {
    let dir = TempDir::new().unwrap();
    let arquivo_sem_chave = dir.path().join("sem_contexto.env");
    std::fs::write(
        &arquivo_sem_chave,
        "FOO=bar\nBAZ=qux\n# sem CONTEXT7_API=\n",
    )
    .unwrap();

    let saida = cmd_isolado(&dir)
        .args(["keys", "import", arquivo_sem_chave.to_str().unwrap()])
        .output()
        .unwrap();

    assert!(
        !saida.status.success(),
        "keys import sem CONTEXT7_API= deve falhar com exit != 0"
    );

    let stderr = String::from_utf8_lossy(&saida.stderr);

    // A mensagem deve conter referência ao caminho do arquivo
    assert!(
        stderr.contains("sem_contexto.env"),
        "stderr deve conter o nome do arquivo. stderr='{stderr}'"
    );

    // A mensagem deve conter referência a CONTEXT7_API
    assert!(
        stderr.contains("CONTEXT7_API"),
        "stderr deve mencionar CONTEXT7_API. stderr='{stderr}'"
    );

    // Não deve expor detalhes internos de implementação (stack traces, endereços)
    assert!(
        !stderr.contains("thread 'main' panicked"),
        "não deve causar panic. stderr='{stderr}'"
    );
}

/// FAIL-1 QA v0.2.8 — `keys import` arquivo com comentários mas sem chaves válidas
/// deve falhar com exit 1 e mensagem útil.
#[test]
#[serial]
fn testa_regressao_qa028_fail1_import_apenas_comentarios_falha_com_exit1() {
    let dir = TempDir::new().unwrap();
    let arquivo_comentarios = dir.path().join("comentarios.env");
    std::fs::write(
        &arquivo_comentarios,
        "# Este arquivo é só comentários\n# CONTEXT7_API=nao_conta\n",
    )
    .unwrap();

    cmd_isolado(&dir)
        .args(["keys", "import", arquivo_comentarios.to_str().unwrap()])
        .assert()
        .failure()
        .stderr(predicate::str::contains("CONTEXT7_API"));
}

/// FAIL-3 QA v0.2.8 — Mascaramento de chave curta (≤ 16 chars) retorna "***".
///
/// Regression: garante que chaves muito curtas são tratadas de forma segura
/// (exibição opaca) em vez de expor a chave completa.
#[test]
#[serial]
fn testa_regressao_qa028_fail3_chave_curta_exibe_asteriscos() {
    let dir = TempDir::new().unwrap();
    // Chave curta (9 chars) — menor que o threshold de 16
    let chave_curta = "ctx7sk-ab";

    cmd_isolado(&dir)
        .args(["keys", "add", chave_curta])
        .assert()
        .success();

    let saida = cmd_isolado(&dir).args(["keys", "list"]).output().unwrap();

    let stdout = String::from_utf8_lossy(&saida.stdout);

    // Chave curta deve aparecer mascarada — NÃO deve expor o valor completo
    assert!(
        !stdout.contains(chave_curta),
        "chave curta não deve aparecer sem mascaramento. stdout='{stdout}'"
    );

    // Deve usar representação de asteriscos para chaves curtas
    assert!(
        stdout.contains("***"),
        "chave curta deve ser exibida como '***'. stdout='{stdout}'"
    );
}

/// PARTIAL-1 QA v0.2.8 — CONTEXT7_HOME com path traversal é silenciosamente
/// ignorado e o sistema usa o XDG default (comportamento SEGURO).
///
/// Regression: garante que a lógica anti-path-traversal não foi removida
/// e que o sistema não acessa caminhos relativos perigosos.
#[test]
#[allow(deprecated)] // cargo_bin depreciado no assert_cmd 2.1.0+ (build-dir custom)
#[serial]
fn testa_regressao_qa028_partial1_context7_home_path_traversal_usa_default() {
    let dir = TempDir::new().unwrap();

    // Path traversal como CONTEXT7_HOME deve ser silenciosamente ignorado
    // (não deve causar panic nem acessar ../etc)
    let saida = Command::cargo_bin("context7")
        .unwrap()
        .env_clear()
        .env("CONTEXT7_HOME", "../../../etc")
        .env("HOME", dir.path())
        .args(["keys", "path"])
        .output()
        .unwrap();

    let stdout = String::from_utf8_lossy(&saida.stdout);
    let stderr = String::from_utf8_lossy(&saida.stderr);

    // Não deve expor o caminho ../../../etc na saída
    assert!(
        !stdout.contains("../../../etc"),
        "path traversal não deve aparecer na saída. stdout='{stdout}'"
    );

    // Não deve referenciar /etc na saída (o traversal não deve ser efetivado)
    assert!(
        !stdout.contains("/etc/config.toml"),
        "traversal para /etc não deve funcionar. stdout='{stdout}'"
    );

    // Não deve causar panic
    assert!(
        !stderr.contains("thread 'main' panicked"),
        "não deve causar panic. stderr='{stderr}'"
    );
}

/// Regression v0.4.0 — `--version` deve retornar a versão atual do binário.
///
/// Garante que o bump de versão em Cargo.toml foi aplicado corretamente
/// e que o binário reporta a versão sincronizada com o pacote.
#[test]
fn testa_regressao_v040_version_string_correta() {
    let dir = TempDir::new().unwrap();
    cmd_isolado(&dir)
        .arg("--version")
        .assert()
        .success()
        .stdout(predicate::str::contains(env!("CARGO_PKG_VERSION")));
}

/// Regression v0.2.8 — FAIL-1 fix: `keys import` sem CONTEXT7_API= não deve
/// repetir a mesma mensagem na linha "Caused by:".
///
/// Após o fix, a mensagem principal contem o caminho do arquivo ("Arquivo: ...")
/// e o "Caused by:" informa sobre a ausência de chaves — sem duplicação do caminho.
/// O erro deve ser limpo: conter o caminho do arquivo e mencionar CONTEXT7_API.
#[test]
#[serial]
fn testa_regressao_v028_fail1_import_erro_nao_duplica_mensagem_principal() {
    let dir = TempDir::new().unwrap();
    let arquivo_ruim = dir.path().join("ruim.env");
    std::fs::write(&arquivo_ruim, "OUTRA_VAR=valor\n# sem CONTEXT7_API=\n").unwrap();

    let saida = cmd_isolado(&dir)
        .args(["keys", "import", arquivo_ruim.to_str().unwrap()])
        .output()
        .unwrap();

    assert!(
        !saida.status.success(),
        "deve falhar com exit != 0 quando arquivo não tem CONTEXT7_API="
    );

    let stderr = String::from_utf8_lossy(&saida.stderr);

    // Deve mencionar o caminho do arquivo
    assert!(
        stderr.contains("ruim.env"),
        "stderr deve conter o caminho do arquivo. stderr='{stderr}'"
    );

    // Deve mencionar CONTEXT7_API em alguma parte do erro
    assert!(
        stderr.contains("CONTEXT7_API"),
        "stderr deve mencionar CONTEXT7_API. stderr='{stderr}'"
    );

    // A mensagem de erro principal NÃO deve ser idêntica ao "Caused by:"
    // (validação do fix que eliminou a duplicação da mensagem completa)
    let linhas: Vec<&str> = stderr.lines().collect();
    let linha_error = linhas.iter().find(|l| l.starts_with("Error:"));
    let linha_caused = linhas.iter().find(|l| l.trim().starts_with("Caused by:"));

    if let (Some(error), Some(_caused_by)) = (linha_error, linha_caused) {
        // A linha "Error:" não deve terminar com "Caused by:" idêntico ao início
        // (verifica que não é mais "Error: Nenhuma chave ... \nCaused by:\n    Nenhuma chave ...")
        let conteudo_error = error.trim_start_matches("Error:").trim();
        assert!(
            !conteudo_error.is_empty(),
            "a linha Error: não deve estar vazia. stderr='{stderr}'"
        );
    }

    // Não deve causar panic
    assert!(
        !stderr.contains("thread 'main' panicked"),
        "não deve causar panic. stderr='{stderr}'"
    );
}

// ─── TESTES v0.2.8: input validation + --json keys list + --lang ─────────────

/// Regression v0.2.8 — Bug 1: `keys add` com chave vazia deve falhar com exit 1.
///
/// Garante que a validação de entrada rejeita strings vazias antes de persistir.
#[test]
fn testa_keys_add_chave_vazia_falha_com_exit1() {
    let temp = TempDir::new().unwrap();
    cmd_isolado(&temp)
        .args(["keys", "add", ""])
        .assert()
        .failure()
        .stderr(predicate::str::contains("empty").or(predicate::str::contains("vazia")));
}

/// Regression v0.2.8 — Bug 1: `keys add` com chave de somente espaços deve falhar com exit 1.
///
/// A validação faz `.trim()` antes de checar vazio, portanto espaços em branco
/// devem ser rejeitados da mesma forma que a string vazia.
#[test]
fn testa_keys_add_chave_somente_espacos_falha_com_exit1() {
    let temp = TempDir::new().unwrap();
    cmd_isolado(&temp)
        .args(["keys", "add", "   "])
        .assert()
        .failure()
        .stderr(predicate::str::contains("empty").or(predicate::str::contains("vazia")));
}

/// Regression v0.2.8 — Bug 2: `keys add` com chave sem prefixo `ctx7sk-` deve
/// emitir aviso em stderr mas completar com sucesso (exit 0).
///
/// O aviso é não-bloqueante: a chave é armazenada mesmo assim, pois o usuário
/// pode ter uma chave de formato legado válida.
#[test]
fn testa_keys_add_chave_sem_prefixo_exibe_aviso_em_stderr() {
    let temp = TempDir::new().unwrap();
    cmd_isolado(&temp)
        .args(["keys", "add", "invalid-key-without-prefix-1234567890"])
        .assert()
        .success()
        .stderr(predicate::str::contains("Warning").or(predicate::str::contains("Aviso")));
}

/// Regression v0.2.8 — Bug 2: `keys add` com chave no formato correto (`ctx7sk-`)
/// NÃO deve emitir aviso em stderr.
///
/// Verifica que o caminho feliz está silencioso para chaves bem formadas.
#[test]
fn testa_keys_add_chave_valida_prefixo_nao_exibe_aviso() {
    let temp = TempDir::new().unwrap();
    let saida = cmd_isolado(&temp)
        .args(["keys", "add", "ctx7sk-test-valid-key-1234567890abcdef"])
        .output()
        .unwrap();
    assert!(
        saida.status.success(),
        "keys add com chave válida deve ter exit 0"
    );
    let stderr = String::from_utf8_lossy(&saida.stderr);
    assert!(
        !stderr.contains("Warning") && !stderr.contains("Aviso"),
        "stderr não deve conter aviso para chave válida, mas continha: '{stderr}'"
    );
}

/// Regression v0.2.8 — Bug 4: `--json keys list` com uma chave deve produzir JSON válido.
///
/// Verifica que o output é um array JSON com os campos `index`, `masked_key` e `added_at`.
#[test]
fn testa_keys_list_json_com_chave_produz_json_valido() {
    let temp = TempDir::new().unwrap();
    // Adicionar uma chave primeiro
    cmd_isolado(&temp)
        .args(["keys", "add", "ctx7sk-test-json-key-1234567890abcdef"])
        .assert()
        .success();
    // Listar em JSON
    let saida = cmd_isolado(&temp)
        .args(["--json", "keys", "list"])
        .output()
        .unwrap();
    assert!(saida.status.success(), "keys list --json deve ter exit 0");
    let stdout = String::from_utf8_lossy(&saida.stdout);
    let parsed: serde_json::Value = serde_json::from_str(&stdout)
        .unwrap_or_else(|e| panic!("stdout não é JSON válido: {e} — output: '{stdout}'"));
    assert!(parsed.is_array(), "esperava array JSON, obteve: {parsed}");
    let arr = parsed.as_array().unwrap();
    assert_eq!(arr.len(), 1, "esperava 1 chave no array");
    assert!(arr[0].get("index").is_some(), "campo 'index' ausente");
    assert!(
        arr[0].get("masked_key").is_some(),
        "campo 'masked_key' ausente"
    );
    assert!(arr[0].get("added_at").is_some(), "campo 'added_at' ausente");
}

/// Regression v0.2.8 — Bug 4: `--json keys list` sem chaves deve retornar array vazio `[]`.
///
/// Verifica que o output para config vazia é JSON parsável e não uma mensagem em prosa.
#[test]
fn testa_keys_list_json_sem_chaves_retorna_array_vazio() {
    let temp = TempDir::new().unwrap();
    let saida = cmd_isolado(&temp)
        .args(["--json", "keys", "list"])
        .output()
        .unwrap();
    assert!(
        saida.status.success(),
        "keys list --json deve ter exit 0 mesmo sem chaves"
    );
    let stdout = String::from_utf8_lossy(&saida.stdout).trim().to_string();
    assert_eq!(
        stdout, "[]",
        "esperava array JSON vazio, obteve: '{stdout}'"
    );
}

/// Regression v0.2.8 — Gap 12: `--lang en keys list` com config vazia exibe mensagem em inglês.
///
/// Verifica que a flag `--lang en` força o idioma das mensagens para inglês.
#[test]
fn testa_lang_en_keys_list_vazio_exibe_ingles() {
    let temp = TempDir::new().unwrap();
    cmd_isolado(&temp)
        .args(["--lang", "en", "keys", "list"])
        .assert()
        .success()
        .stdout(predicate::str::contains("No key stored"));
}

/// Regression v0.2.8 — Gap 12: `--lang pt keys list` com config vazia exibe mensagem em português.
///
/// Verifica que a flag `--lang pt` força o idioma das mensagens para português.
#[test]
fn testa_lang_pt_keys_list_vazio_exibe_portugues() {
    let temp = TempDir::new().unwrap();
    cmd_isolado(&temp)
        .args(["--lang", "pt", "keys", "list"])
        .assert()
        .success()
        .stdout(predicate::str::contains("Nenhuma chave armazenada"));
}

// ── Testes B.1 — validação JSON (v0.3.0) ─────────────────────────────────────

/// B.1 — `--json keys list` sem chaves produz JSON válido e array vazio.
///
/// Complementa `testa_keys_list_json_sem_chaves_retorna_array_vazio` com
/// parse explícito via serde_json para confirmar que o output é array vazio.
#[test]
fn testa_keys_list_json_vazio_eh_json_valido() {
    let temp = TempDir::new().unwrap();
    let saida = cmd_isolado(&temp)
        .args(["--json", "keys", "list"])
        .output()
        .unwrap();
    assert!(
        saida.status.success(),
        "--json keys list deve ter exit 0 sem chaves"
    );
    let stdout = String::from_utf8_lossy(&saida.stdout);
    let parsed: serde_json::Value = serde_json::from_str(stdout.trim())
        .unwrap_or_else(|e| panic!("stdout não é JSON válido: {e} — output: '{stdout}'"));
    assert!(parsed.is_array(), "esperava array JSON, obteve: {parsed}");
    assert_eq!(
        parsed.as_array().unwrap().len(),
        0,
        "array deve estar vazio sem chaves"
    );
}

/// B.1 — `--json keys list` com uma chave contém campos `index`, `masked_key` e `added_at`.
///
/// Verifica estrutura do objeto JSON retornado por cada chave na listagem.
#[test]
fn testa_keys_list_json_com_chave_tem_campos_esperados() {
    let temp = TempDir::new().unwrap();
    cmd_isolado(&temp)
        .args(["keys", "add", "ctx7sk-json-campos-test-12345678"])
        .assert()
        .success();

    let saida = cmd_isolado(&temp)
        .args(["--json", "keys", "list"])
        .output()
        .unwrap();
    assert!(saida.status.success(), "--json keys list deve ter exit 0");

    let stdout = String::from_utf8_lossy(&saida.stdout);
    let parsed: serde_json::Value = serde_json::from_str(stdout.trim())
        .unwrap_or_else(|e| panic!("stdout não é JSON válido: {e} — output: '{stdout}'"));

    assert!(parsed.is_array(), "esperava array JSON");
    let arr = parsed.as_array().unwrap();
    assert_eq!(arr.len(), 1, "esperava 1 elemento no array");

    let obj = &arr[0];
    assert!(
        obj.get("index").is_some(),
        "campo 'index' deve estar presente"
    );
    assert!(
        obj.get("masked_key").is_some(),
        "campo 'masked_key' deve estar presente"
    );
    assert!(
        obj.get("added_at").is_some(),
        "campo 'added_at' deve estar presente"
    );
}

/// B.1 — `--json keys list` com uma chave: campo `added_at` usa formato legível.
///
/// Garante que `added_at` no JSON usa formato `YYYY-MM-DD HH:MM:SS` (com espaço)
/// em vez de RFC3339 com `T` separador (e.g. `2024-01-15T10:30:00.000000000Z`).
#[test]
fn testa_keys_list_json_added_at_formato_legivel() {
    let temp = TempDir::new().unwrap();
    cmd_isolado(&temp)
        .args(["keys", "add", "ctx7sk-added-at-format-test-12345"])
        .assert()
        .success();

    let saida = cmd_isolado(&temp)
        .args(["--json", "keys", "list"])
        .output()
        .unwrap();
    assert!(saida.status.success(), "--json keys list deve ter exit 0");

    let stdout = String::from_utf8_lossy(&saida.stdout);
    let parsed: serde_json::Value = serde_json::from_str(stdout.trim())
        .unwrap_or_else(|e| panic!("stdout não é JSON válido: {e} — output: '{stdout}'"));

    let arr = parsed.as_array().unwrap();
    assert!(!arr.is_empty(), "array não deve estar vazio");

    let added_at = arr[0]["added_at"].as_str().unwrap_or("");
    assert!(!added_at.is_empty(), "campo added_at não deve ser vazio");
    // Formato legível usa espaço entre data e hora, não "T"
    assert!(
        added_at.contains(' '),
        "added_at deve conter espaço (formato YYYY-MM-DD HH:MM:SS), obteve: '{added_at}'"
    );
    assert!(
        !added_at.contains('T'),
        "added_at não deve conter 'T' (não deve ser RFC3339), obteve: '{added_at}'"
    );
}

// ── Testes B.4 — cross-platform (v0.3.0) ─────────────────────────────────────

/// B.4 — CONTEXT7_HOME com path traversal não expõe `..` no caminho retornado.
///
/// Complementa o teste LOW-01 de storage_integration.rs com foco no valor
/// retornado por `keys path` — não deve conter componente `..`.
#[test]
#[serial]
#[allow(deprecated)] // cargo_bin depreciado no assert_cmd 2.1.0+ (build-dir custom)
fn testa_context7_home_rejeita_path_traversal() {
    use assert_cmd::Command as Cmd;

    let dir = TempDir::new().unwrap();
    let saida = Cmd::cargo_bin("context7")
        .unwrap()
        .env_clear()
        .env("CONTEXT7_HOME", "../../../etc")
        .env("HOME", dir.path())
        .args(["keys", "path"])
        .output()
        .unwrap();

    let stdout = String::from_utf8_lossy(&saida.stdout);

    // O path retornado não deve conter `..` — traversal deve ser bloqueado
    assert!(
        !stdout.contains(".."),
        "keys path não deve retornar caminho com '..' quando CONTEXT7_HOME contém path traversal. stdout='{stdout}'"
    );
}

/// B.4 — `--lang pt keys list` sem chaves: stdout contém "Nenhuma" (com acento).
///
/// Valida que a saída em português está sendo gerada em UTF-8 correto com acentuação.
#[test]
fn testa_output_portugues_contem_acentuacao() {
    let temp = TempDir::new().unwrap();
    let saida = cmd_isolado(&temp)
        .args(["--lang", "pt", "keys", "list"])
        .output()
        .unwrap();

    assert!(
        saida.status.success(),
        "--lang pt keys list deve ter exit 0"
    );

    let stdout = String::from_utf8(saida.stdout).expect("stdout deve ser UTF-8 válido");

    assert!(
        stdout.contains("Nenhuma"),
        "output em PT deve conter 'Nenhuma' (com N maiúsculo e caractere 'e'). stdout='{stdout}'"
    );
}

// ─── TESTES SHELL COMPLETIONS (v0.4.0) ──────────────────────────────────────

/// Shell completions bash — exit 0, saída não vazia, contém "context7".
///
/// Verifica que `context7 completions bash` gera script bash válido.
#[test]
fn testa_completions_bash_gera_saida() {
    let dir = TempDir::new().unwrap();
    cmd_isolado(&dir)
        .args(["completions", "bash"])
        .assert()
        .success()
        .stdout(predicate::str::contains("context7"))
        .stdout(predicate::str::is_empty().not());
}

/// Shell completions zsh — exit 0, saída não vazia.
///
/// Verifica que `context7 completions zsh` gera script zsh válido.
#[test]
fn testa_completions_zsh_gera_saida() {
    let dir = TempDir::new().unwrap();
    cmd_isolado(&dir)
        .args(["completions", "zsh"])
        .assert()
        .success()
        .stdout(predicate::str::is_empty().not());
}

/// Shell completions fish — exit 0, saída não vazia.
///
/// Verifica que `context7 completions fish` gera script fish válido.
#[test]
fn testa_completions_fish_gera_saida() {
    let dir = TempDir::new().unwrap();
    cmd_isolado(&dir)
        .args(["completions", "fish"])
        .assert()
        .success()
        .stdout(predicate::str::is_empty().not());
}

/// Shell completions powershell — exit 0, saída não vazia.
///
/// Verifica que `context7 completions powershell` gera script PowerShell válido.
#[test]
fn testa_completions_powershell_gera_saida() {
    let dir = TempDir::new().unwrap();
    cmd_isolado(&dir)
        .args(["completions", "powershell"])
        .assert()
        .success()
        .stdout(predicate::str::is_empty().not());
}

/// Alias `completion` funciona igual a `completions`.
///
/// Garante que o alias `#[command(alias = "completion")]` está registrado e operacional.
#[test]
fn testa_completions_alias_completion_funciona() {
    let dir = TempDir::new().unwrap();
    cmd_isolado(&dir)
        .args(["completion", "bash"])
        .assert()
        .success()
        .stdout(predicate::str::contains("context7"));
}

/// `completions --help` — exit 0, lista os shells disponíveis.
///
/// Verifica que o help do subcomando menciona pelo menos um shell suportado.
#[test]
fn testa_completions_help_lista_shells() {
    let dir = TempDir::new().unwrap();
    let saida = cmd_isolado(&dir)
        .args(["completions", "--help"])
        .output()
        .unwrap();

    assert!(saida.status.success(), "completions --help deve ter exit 0");

    let stdout = String::from_utf8_lossy(&saida.stdout);
    let stderr = String::from_utf8_lossy(&saida.stderr);
    let combinado = format!("{stdout}{stderr}");

    assert!(
        combinado.contains("bash")
            || combinado.contains("zsh")
            || combinado.contains("fish")
            || combinado.contains("shell"),
        "completions --help deve mencionar shells disponíveis. combinado='{combinado}'"
    );
}

/// `completions bash` opera sem API key — é comando offline.
///
/// Garante que shell completions NÃO requerem CONTEXT7_API_KEYS configurado.
#[test]
fn testa_completions_nao_requer_api_key() {
    let dir = TempDir::new().unwrap();
    // cmd_isolado já define CONTEXT7_HOME sem config.toml (sem chaves)
    cmd_isolado(&dir)
        .args(["completions", "bash"])
        .assert()
        .success();
}

// ─── TESTE REGRESSÃO USER-AGENT DINÂMICO (v0.4.0) ───────────────────────────

/// Regressão v0.4.0 — user-agent em src/api.rs usa CARGO_PKG_VERSION, não string hardcoded.
///
/// Verifica no código-fonte que não existe string hardcoded "context7-cli/0." seguida
/// de dígitos — o que indicaria que o user-agent ficou para trás em um release.
/// Qualquer ocorrência de ".user_agent(" deve usar env!("CARGO_PKG_VERSION").
#[test]
fn testa_user_agent_nao_contem_versao_hardcoded() {
    let conteudo_api = include_str!("../src/api.rs");

    // Não deve existir ".user_agent(" com versão hardcoded no formato "X.Y.Z"
    let linhas_user_agent: Vec<&str> = conteudo_api
        .lines()
        .filter(|l| l.contains(".user_agent("))
        .collect();

    assert!(
        !linhas_user_agent.is_empty(),
        "src/api.rs deve conter pelo menos uma chamada a .user_agent()"
    );

    for linha in &linhas_user_agent {
        // Detectar padrão hardcoded: "context7-cli/0.3.0" ou similar
        assert!(
            !linha.contains("context7-cli/0."),
            "src/api.rs:.user_agent() contém versão hardcoded (deve usar env!(\"CARGO_PKG_VERSION\")). linha='{linha}'"
        );
        assert!(
            linha.contains("CARGO_PKG_VERSION"),
            "src/api.rs:.user_agent() deve usar env!(\"CARGO_PKG_VERSION\"). linha='{linha}'"
        );
    }
}