//! Subscription login CLI contract (`SMH-SPEC-SPEC0001`, `SMH-SPEC-PLUG0001`). use assert_cmd::Command; #[test] fn subscription_auth_key_operations_never_read_stdin_or_coerce_to_api_billing() { for (action, provider) in ["add", "check", "remove"].into_iter().flat_map(|action| { [ "openai-chatgpt-plan", "anthropic-claude-plan", "google-gemini-cli-plan", ] .map(|provider| (action, provider)) }) { Command::cargo_bin("smith") .unwrap() .env_clear() .args(["auth", action, "--provider", provider]) .assert() .failure() .stderr(predicates::str::contains("not API-key add/check/remove")); } } #[test] fn subscription_eval_requires_explicit_profile_even_with_an_api_key_available() { Command::cargo_bin("smith") .unwrap() .env_clear() .env("OPENAI_API_KEY", "fixture-api-key-must-not-fallback") .args([ "eval", "must not dispatch", "--provider", "openai-chatgpt-plan", "--model", "gpt-4o-mini", ]) .assert() .failure() .stderr(predicates::str::contains( "requires --profile ID; no implicit account or API-key fallback", )); } #[test] fn anthropic_subscription_eval_never_falls_back_to_api_key() { Command::cargo_bin("smith") .unwrap() .env_clear() .env("ANTHROPIC_API_KEY", "fixture-api-key-must-not-fallback") .args([ "eval", "must not dispatch", "--provider", "anthropic-claude-plan", "--model", "claude-sonnet-4-5", ]) .assert() .failure() .stderr(predicates::str::contains( "requires --profile ID; no implicit account or API-key fallback", )); } #[test] fn subscription_catalog_never_labels_bundled_models_as_account_entitlement() { Command::cargo_bin("smith") .unwrap() .env_clear() .env( "XDG_CACHE_HOME", std::env::temp_dir().join(format!("subscription-catalog-{}", std::process::id())), ) .args([ "catalog", "show", "--provider", "openai-chatgpt-plan", "--json", ]) .assert() .failure() .stderr(predicates::str::contains( "entitlement requires an explicitly selected profile", )); } #[test] fn auth_profiles_discloses_verified_metadata_but_no_token_state() { let root = std::env::temp_dir().join(format!("profile-list-{}", std::process::id())); let store = root.join("smith/auth/oauth"); std::fs::create_dir_all(&store).unwrap(); let profile = serde_json::json!({ "flow":"DynamicOidc", "connection_id":"openai-chatgpt-plan", "id":"a".repeat(64), "issuer":"https://auth.openai.com", "subject":"fixture-subject", "client_id":"oaiapp_fixture", "workspace":null, "label":"fixture@example.test", "scopes":["openid","chatgpt.tokens.use.direct"], "expires_at":1000 }); let document = serde_json::json!({"version":2,"host_id":"urn:uuid:12345678-1234-4234-8234-123456789012","profiles":[{"metadata":profile,"tokens":null,"refresh_pending":false}]}); let path = store.join("profiles.json"); std::fs::write(&path, serde_json::to_vec(&document).unwrap()).unwrap(); #[cfg(unix)] { use std::os::unix::fs::PermissionsExt; std::fs::set_permissions(&store, std::fs::Permissions::from_mode(0o700)).unwrap(); std::fs::set_permissions(&path, std::fs::Permissions::from_mode(0o600)).unwrap(); } let output = Command::cargo_bin("smith") .unwrap() .env_clear() .env("XDG_DATA_HOME", &root) .args(["auth", "profiles"]) .output() .unwrap(); assert!(output.status.success()); assert!(output.stderr.is_empty()); let value: serde_json::Value = serde_json::from_slice(&output.stdout).unwrap(); assert_eq!(value, serde_json::json!([profile])); insta::assert_snapshot!(serde_json::to_string_pretty(&value).unwrap(), @r#" [ { "flow": "DynamicOidc", "connection_id": "openai-chatgpt-plan", "id": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "issuer": "https://auth.openai.com", "subject": "fixture-subject", "client_id": "oaiapp_fixture", "workspace": null, "label": "fixture@example.test", "scopes": [ "openid", "chatgpt.tokens.use.direct" ], "expires_at": 1000 } ] "#); std::fs::remove_dir_all(root).unwrap(); } #[test] fn login_with_api_connection_stores_stdin_secret_without_exposing_it() { let root = std::env::temp_dir().join(format!("login-api-{}", std::process::id())); let secret = "sk-login-secret-must-not-appear"; let mut login = Command::cargo_bin("smith").unwrap(); let output = login .env_clear() .env("XDG_DATA_HOME", &root) .args(["login", "--provider", "openai"]) .write_stdin(format!("{secret}\n")) .output() .unwrap(); assert!(output.status.success(), "{output:?}"); assert!( output .stdout .windows(secret.len()) .all(|window| window != secret.as_bytes()) ); assert!( output .stderr .windows(secret.len()) .all(|window| window != secret.as_bytes()) ); let mut check = Command::cargo_bin("smith").unwrap(); check .env_clear() .env("XDG_DATA_HOME", &root) .args(["auth", "check", "--provider", "openai"]) .assert() .success() .stdout("openai: store\n"); std::fs::remove_dir_all(root).unwrap(); } #[test] fn login_rejects_subscription_only_flags_for_api_connections_before_stdin() { for flag in ["--profile", "--fixture-issuer", "--project"] { let root = std::env::temp_dir().join(format!("login-api-invalid-{flag}-{}", std::process::id())); let mut login = Command::cargo_bin("smith").unwrap(); let command = login.env_clear().env("XDG_DATA_HOME", &root); command.args(["login", "--provider", "anthropic", flag, "fixture-value"]); let output = command .write_stdin("must-not-be-stored\n") .output() .unwrap(); assert!(!output.status.success(), "{flag} unexpectedly accepted"); assert!( String::from_utf8_lossy(&output.stderr).contains("subscription-only"), "{output:?}" ); assert!( !root.join("smith/auth/anthropic").exists(), "{flag} consumed stdin" ); let _ = std::fs::remove_dir_all(root); } } #[test] fn login_exposes_explicit_subscription_identity_without_api_billing_fallback() { Command::cargo_bin("smith") .unwrap() .env_clear() .args(["login", "--help"]) .assert() .success() .stdout(predicates::str::contains("API credentials")); }