Luigit
repositories / smith

smith

There are many coding harnesses - but this one is fast

owned by admin

smith-cli/tests/e2e_login.rs

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