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]"));
}