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