Luigit
repositories / smith

smith

There are many coding harnesses - but this one is fast

owned by admin

smith-cli/tests/e2e_auth.rs

Raw
//! End-to-end credential store behavior through the `smith auth` CLI
//! (`SMH-SPEC-SPEC0001`, Providers: authentication).

use assert_cmd::Command;
use insta::assert_snapshot;
use std::net::TcpListener;
use std::path::PathBuf;
use std::time::Duration;

fn scratch(name: &str) -> PathBuf {
    PathBuf::from("/var/tmp/smith-session-e2e")
        .join(format!("smith-auth-test-{name}-{}", std::process::id()))
}

fn smith(name: &str) -> Command {
    let mut command = Command::cargo_bin("smith").unwrap();
    command
        .env_clear()
        .env("XDG_DATA_HOME", scratch(name))
        .env_remove("ANTHROPIC_API_KEY")
        .env_remove("OPENAI_API_KEY")
        .env_remove("GOOGLE_API_KEY")
        .env_remove("GEMINI_API_KEY")
        .env_remove("ZAI_API_KEY")
        .env_remove("SMITH_PLUGIN_API_KEY");
    command
}

#[test]
fn add_list_remove_round_trips_with_user_only_permissions() {
    let mut add = smith("roundtrip");
    add.args(["auth", "add", "--provider", "anthropic"])
        .write_stdin("sk-test-secret\n")
        .assert()
        .success()
        .stdout("anthropic: stored\n");

    let mut list = smith("roundtrip");
    list.args(["auth", "list"])
        .assert()
        .success()
        .stdout("anthropic: store (not verified; offline)\n");

    let mut check = smith("roundtrip");
    check
        .args(["auth", "check", "--provider", "anthropic"])
        .assert()
        .success()
        .stdout("anthropic: store\n");

    let mut remove = smith("roundtrip");
    remove
        .args(["auth", "remove", "--provider", "anthropic"])
        .assert()
        .success()
        .stdout("anthropic: removed\n");

    let mut gone = smith("roundtrip");
    gone.args(["auth", "check", "--provider", "anthropic"])
        .assert()
        .failure()
        .stderr(predicates::str::contains(
            "no credential for anthropic (tried store, env ANTHROPIC_API_KEY)",
        ));

    let mut empty = smith("roundtrip");
    empty
        .args(["auth", "remove", "--provider", "anthropic"])
        .assert()
        .failure()
        .stderr(predicates::str::contains(
            "no stored credential for anthropic",
        ));
}

#[test]
fn add_rejects_oversized_stdin_credential_without_storing_it() {
    let secret = "x".repeat(64 * 1024 + 1);
    let mut add = smith("oversized");
    add.args(["auth", "add", "--provider", "google"])
        .write_stdin(secret)
        .assert()
        .failure()
        .stdout("")
        .stderr(predicates::str::contains(
            "credential input exceeds 65536 bytes",
        ));
    assert!(!scratch("oversized").join("smith/auth/google").exists());
}

#[test]
fn stored_secret_never_prints_and_permissions_are_user_only() {
    let mut add = smith("hygiene");
    add.args(["auth", "add", "--provider", "openai"])
        .write_stdin("sk-super-secret-value\n")
        .assert()
        .success();

    let secret_file = scratch("hygiene").join("smith/auth/openai");
    #[cfg(unix)]
    {
        use std::os::unix::fs::PermissionsExt;
        let mode = std::fs::metadata(&secret_file)
            .unwrap()
            .permissions()
            .mode();
        assert_eq!(mode & 0o777, 0o600);
    }

    let mut list = smith("hygiene");
    list.args(["auth", "list"])
        .assert()
        .stdout("openai: store (not verified; offline)\n");
}

#[test]
fn check_reports_environment_source() {
    let mut check = smith("envsource");
    check
        .args(["auth", "check", "--provider", "google"])
        .env("GEMINI_API_KEY", "sk-env")
        .assert()
        .success()
        .stdout("google: env:GEMINI_API_KEY\n");
}

#[test]
fn list_reports_stored_and_nonempty_environment_sources_offline_without_secrets() {
    let root = scratch("source-list");
    let auth = root.join("smith/auth");
    std::fs::create_dir_all(&auth).unwrap();
    std::fs::write(auth.join("zai"), "metered-store-\"secret").unwrap();
    std::fs::write(auth.join("zai-coding-plan"), "plan-store-\\secret").unwrap();
    let proxy = TcpListener::bind("127.0.0.1:0").unwrap();
    proxy.set_nonblocking(true).unwrap();

    let mut list = smith("source-list");
    list.env_remove("GOOGLE_API_KEY")
        .env("ZAI_API_KEY", "zai-environment-\"secret")
        .env(
            "HTTP_PROXY",
            format!("http://{}", proxy.local_addr().unwrap()),
        )
        .env(
            "HTTPS_PROXY",
            format!("http://{}", proxy.local_addr().unwrap()),
        )
        .args(["auth", "list"])
        .timeout(Duration::from_secs(30));
    let output = list.output().unwrap();
    assert!(output.status.success(), "{output:?}");
    let stdout = String::from_utf8(output.stdout).unwrap();
    let stderr = String::from_utf8(output.stderr).unwrap();
    assert_snapshot!(stdout, @r"
zai: store (not verified; offline)
zai: env:ZAI_API_KEY (not verified; offline)
zai-coding-plan: store (not verified; offline)
zai-coding-plan: env:ZAI_API_KEY (not verified; offline)
");
    for secret in [
        "metered-store-\"secret",
        "plan-store-\\secret",
        "zai-environment-\"secret",
        r#"metered-store-\"secret"#,
        r#"plan-store-\\secret"#,
        r#"zai-environment-\"secret"#,
    ] {
        assert!(!stdout.contains(secret), "credential leaked: {secret}");
        assert!(!stderr.contains(secret), "credential leaked: {secret}");
    }
    assert!(proxy.accept().is_err(), "auth list made a network request");

    let store_only = scratch("store-only-source-list");
    std::fs::create_dir_all(store_only.join("smith/auth")).unwrap();
    std::fs::write(
        store_only.join("smith/auth/zai-coding-plan"),
        "plan-only-secret",
    )
    .unwrap();
    let mut stored = smith("store-only-source-list");
    stored
        .args(["auth", "list"])
        .assert()
        .success()
        .stdout("zai-coding-plan: store (not verified; offline)\n");

    let mut empty = smith("empty-environment-source");
    empty
        .env("ZAI_API_KEY", "")
        .args(["auth", "list"])
        .assert()
        .success()
        .stdout("");
}

#[test]
fn empty_store_is_invalid_and_never_falls_back_to_environment() {
    let data = scratch("empty-stored-source");
    let auth = data.join("smith/auth");
    std::fs::create_dir_all(&auth).unwrap();
    std::fs::write(auth.join("google"), "").unwrap();

    let mut empty_only = smith("empty-stored-source");
    empty_only
        .args(["auth", "check", "--provider", "google"])
        .assert()
        .failure()
        .stdout("")
        .stderr(predicates::str::contains("storage [AUTH_STORE]"));

    let mut check = smith("empty-stored-source");
    check
        .args(["auth", "check", "--provider", "google"])
        .env("GOOGLE_API_KEY", "valid-fallback")
        .assert()
        .failure()
        .stdout("")
        .stderr(predicates::str::contains("storage [AUTH_STORE]"));

    let mut list = smith("empty-stored-source");
    list.args(["auth", "list"])
        .env("GOOGLE_API_KEY", "valid-fallback")
        .assert()
        .failure()
        .stdout("")
        .stderr(predicates::str::contains("storage [AUTH_STORE]"));
}

#[test]
fn list_rejects_directory_at_credential_path_without_environment_fallback() {
    let root = scratch("directory-credential-list");
    let credential = root.join("smith/auth/google");
    std::fs::create_dir_all(&credential).unwrap();
    std::fs::write(credential.join("entry"), "not a credential").unwrap();

    let mut list = smith("directory-credential-list");
    list.args(["auth", "list"])
        .env("GOOGLE_API_KEY", "valid-fallback")
        .assert()
        .failure()
        .stdout("")
        .stderr(predicates::str::contains("storage [AUTH_STORE]"));
}

#[test]
fn google_environment_sources_use_precedence_and_skip_ineligible_values() {
    let mut both = smith("google-env-precedence");
    both.args(["auth", "check", "--provider", "google"])
        .env("GOOGLE_API_KEY", "primary")
        .env("GEMINI_API_KEY", "fallback")
        .assert()
        .success()
        .stdout("google: env:GOOGLE_API_KEY\n");

    let mut empty_primary = smith("google-env-empty-primary");
    empty_primary
        .args(["auth", "check", "--provider", "google"])
        .env("GOOGLE_API_KEY", "")
        .env("GEMINI_API_KEY", "fallback")
        .assert()
        .success()
        .stdout("google: env:GEMINI_API_KEY\n");

    #[cfg(unix)]
    {
        use std::os::unix::ffi::OsStringExt;
        let mut non_unicode_primary = smith("google-env-non-unicode-primary");
        non_unicode_primary
            .args(["auth", "check", "--provider", "google"])
            .env("GOOGLE_API_KEY", std::ffi::OsString::from_vec(vec![0xff]))
            .env("GEMINI_API_KEY", "fallback")
            .assert()
            .success()
            .stdout("google: env:GEMINI_API_KEY\n");
    }
}

#[test]
fn list_preserves_corrupt_store_error() {
    let data = scratch("corrupt-source-list");
    std::fs::write(&data, "not a directory").unwrap();
    let mut list = Command::cargo_bin("smith").unwrap();
    list.env_clear()
        .env("XDG_DATA_HOME", &data)
        .args(["auth", "list"])
        .timeout(Duration::from_secs(30))
        .assert()
        .failure()
        .stderr(predicates::str::contains("storage [AUTH_STORE]"));
}