🧪 test(server): e2e — admin POST credential → agent pin → resolve env vars (ADR-005)

chaizhenhua · chaizhenhua · commit 106a15238865 · 2026-04-28T22:38:24.000+08:00
diff --git a/crates/oversight-server/tests/credential_e2e.rs b/crates/oversight-server/tests/credential_e2e.rs
@@ -0,0 +1,371 @@
+//! ADR-005 end-to-end: prove that a credential configured via the
+//! admin API actually reaches the agent runtime as the right env vars.
+//!
+//! Path under test (each step uses its production code path; the test
+//! only forges the auth context):
+//!
+//!   1. **Configure**: `POST /api/admin/credentials/llm` writes the
+//!      profile through `admin_api::create_llm_credential` →
+//!      `EncryptingConfigStore::put_with_actor` → vault.
+//!   2. **Reference**: insert an agent_def via the storage trait, then
+//!      `PUT /api/agent-definitions/:id` to set `credential_id` —
+//!      this exercises the same handler the AgentEditorForm hits.
+//!   3. **Visibility**: `GET /api/agent-definitions/:id/resolved-credential`
+//!      returns the resolved binding (mode + namespace + profile_id)
+//!      so the UI can show "Will use: providers:openai-prod".
+//!   4. **Runtime materialisation**: call `resolve_credential_for_agent`
+//!      (the same function `dispatch_api`/`cli_agent_api` use) and
+//!      assert the resulting `SecretMaterial::Env` entries carry the
+//!      adapter-correct names + the value from the *configured*
+//!      profile. This is what gets injected as env vars into the
+//!      spawned CLI process.
+//!
+//! Steps 1, 2, 3 hit real HTTP handlers via `tower::ServiceExt::oneshot`
+//! against the routers admin_api/api expose. Step 4 calls into the
+//! resolver directly against the same `AppState`, proving the runtime
+//! reads the same row the API persisted.
+
+use std::sync::{Arc, Mutex as StdMutex};
+
+use awaken_contract::contract::config_store::ConfigStore;
+use axum::body::{to_bytes, Body};
+use axum::http::{Request, StatusCode};
+use chrono::Utc;
+use oversight_models::{AgentDef, AuthUser};
+use oversight_server::auth_mw::AuthContext;
+use oversight_server::credentials::{resolve_credential_for_agent, BindingMode};
+use oversight_server::state::AppState;
+use oversight_server::{admin_api, build_api_router};
+use oversight_store::repo_authz::NewGrant;
+use oversight_vault::{
+    CooldownRepo, CredentialPool, ProfileMetaRepo, SqliteCooldownRepo, SqliteProfileMetaRepo,
+};
+use serde_json::{json, Value};
+use tower::ServiceExt;
+
+mod common;
+
+const VAULT_SCHEMA: &str = include_str!("../../../migrations/V068__vault.sql");
+
+fn admin_user() -> AuthUser {
+    AuthUser {
+        id: "admin-e2e".into(),
+        username: "admin".into(),
+        password_hash: String::new(),
+        role: "admin".into(),
+        created_at: Utc::now(),
+        disabled_at: None,
+    }
+}
+
+fn req(method: &str, path: &str, body: Option<Value>, auth: Option<AuthContext>) -> Request<Body> {
+    let mut builder = Request::builder().method(method).uri(path);
+    if body.is_some() {
+        builder = builder.header("content-type", "application/json");
+    }
+    let body = match body {
+        Some(value) => Body::from(value.to_string()),
+        None => Body::empty(),
+    };
+    let mut request = builder.body(body).expect("request");
+    if let Some(auth) = auth {
+        request.extensions_mut().insert(auth);
+    }
+    request
+}
+
+async fn body_json(response: axum::response::Response) -> Value {
+    let bytes = to_bytes(response.into_body(), 1024 * 1024)
+        .await
+        .expect("body");
+    if bytes.is_empty() {
+        Value::Null
+    } else {
+        serde_json::from_slice(&bytes).expect("json")
+    }
+}
+
+/// Wire a real `CredentialPool` into the AppState. The common helper
+/// leaves it `None` (most tests don't need it); for this e2e we want
+/// the resolver to actually walk the vault.
+fn install_credential_pool(state: &mut AppState) {
+    let conn = rusqlite::Connection::open_in_memory().expect("sqlite open");
+    conn.execute_batch(VAULT_SCHEMA).expect("vault schema");
+    let conn = Arc::new(StdMutex::new(conn));
+    let meta: Arc<dyn ProfileMetaRepo> = Arc::new(SqliteProfileMetaRepo::new(conn.clone()));
+    let cooldowns: Arc<dyn CooldownRepo> = Arc::new(SqliteCooldownRepo::new(conn));
+    state.credential_pool = Some(Arc::new(CredentialPool::new(
+        state.vault.clone() as Arc<dyn ConfigStore>,
+        meta,
+        cooldowns,
+    )));
+}
+
+/// Grant the given user the workspace-admin role and reload the
+/// authorizer so the new grant takes effect for subsequent calls.
+/// `agent.create` and `agent.write` permissions cascade from this.
+async fn grant_admin_workspace_async(state: &AppState, user_id: &str) {
+    {
+        let store = state.store.lock().await;
+        store
+            .insert_authz_grant(NewGrant {
+                principal_type: "user".into(),
+                principal_id: user_id.into(),
+                role_id: "admin".into(),
+                scope_type: "workspace".into(),
+                scope_id: "root".into(),
+                require_approval: false,
+                granted_by_type: "system".into(),
+                granted_by_id: "system".into(),
+                expires_at: None,
+            })
+            .expect("insert grant");
+    }
+    oversight_server::authz_sync::reload_authorizer(state)
+        .await
+        .expect("reload authorizer");
+}
+
+#[tokio::test]
+async fn config_to_dispatch_chain_injects_provider_env_vars() {
+    let mut state = common::build_sqlite_app_state().await;
+    install_credential_pool(&mut state);
+
+    let admin = AuthContext { user: admin_user() };
+    grant_admin_workspace_async(&state, &admin.user.id).await;
+
+    // ── 1. Configure: admin POST creates an LLM credential profile. ──
+    let admin_router = admin_api::routes(state.clone());
+    let create_response = admin_router
+        .clone()
+        .oneshot(req(
+            "POST",
+            "/credentials/llm",
+            Some(json!({
+                "id": "openai-prod",
+                "adapter": "openai",
+                "api_key": "sk-CONFIGURED-VIA-API",
+                "base_url": "https://api.openai.example/v1",
+            })),
+            Some(admin.clone()),
+        ))
+        .await
+        .expect("admin create");
+    // admin_api::create_llm_credential returns 201 CREATED on success.
+    assert_eq!(
+        create_response.status(),
+        StatusCode::CREATED,
+        "credential create",
+    );
+
+    // Sanity: the vault now has a redacted view of the row.
+    let list_response = admin_router
+        .clone()
+        .oneshot(req("GET", "/credentials/llm", None, Some(admin.clone())))
+        .await
+        .expect("admin list");
+    assert_eq!(list_response.status(), StatusCode::OK);
+    let listed = body_json(list_response).await;
+    let items = listed
+        .get("items")
+        .and_then(Value::as_array)
+        .expect("items array");
+    assert_eq!(items.len(), 1);
+    assert_eq!(items[0]["id"], "openai-prod");
+    assert_eq!(
+        items[0]["has_api_key"].as_bool(),
+        Some(true),
+        "list endpoint reports the key is set",
+    );
+
+    // ── 2. Reference: create the agent via HTTP POST so the creator-admin
+    //     grant gets recorded (the API has authorization checks on
+    //     subsequent PUT). Then PUT to set credential_id (Pinned mode).
+    let api_router = build_api_router(state.clone());
+    let create_agent = api_router
+        .clone()
+        .oneshot(req(
+            "POST",
+            "/api/agent-definitions",
+            Some(json!({
+                "agent_id": "codex-prod",
+                "display_name": "Codex Prod",
+                "system_prompt": "system prompt",
+                "model": "gpt-5-codex",
+                "agent_type": "codex",
+                "created_by": format!("user:{}", admin.user.id),
+            })),
+            Some(admin.clone()),
+        ))
+        .await
+        .expect("create agent");
+    assert_eq!(
+        create_agent.status(),
+        StatusCode::CREATED,
+        "agent POST should create + grant creator-admin",
+    );
+    let created = body_json(create_agent).await;
+    let agent_id = created["id"].as_str().expect("agent id").to_string();
+
+    let pin_body = json!({
+        // Mirror the AgentEditorForm payload shape (CreateAgentDefRequest).
+        "agent_id": "codex-prod",
+        "display_name": "Codex Prod",
+        "model": "gpt-5-codex",
+        "agent_type": "codex",
+        "credential_id": "providers:openai-prod",
+    });
+    let pin_response = api_router
+        .clone()
+        .oneshot(req(
+            "PUT",
+            &format!("/api/agent-definitions/{agent_id}"),
+            Some(pin_body),
+            Some(admin.clone()),
+        ))
+        .await
+        .expect("pin agent");
+    assert_eq!(
+        pin_response.status(),
+        StatusCode::OK,
+        "agent PUT with credential_id should succeed",
+    );
+
+    // Confirm the storage layer persisted the pin.
+    let stored = state
+        .storage
+        .get_agent_def(&agent_id)
+        .await
+        .expect("get agent");
+    assert_eq!(
+        stored.credential_id.as_deref(),
+        Some("providers:openai-prod"),
+        "agent_def must carry the pin after PUT",
+    );
+
+    // ── 3. Visibility: the read endpoint reports the resolved binding. ──
+    let resolved_response = api_router
+        .clone()
+        .oneshot(req(
+            "GET",
+            &format!("/api/agent-definitions/{agent_id}/resolved-credential"),
+            None,
+            Some(admin.clone()),
+        ))
+        .await
+        .expect("resolved endpoint");
+    assert_eq!(resolved_response.status(), StatusCode::OK);
+    let resolved_json = body_json(resolved_response).await;
+    assert_eq!(resolved_json["mode"], "pinned");
+    assert_eq!(resolved_json["namespace"], "providers");
+    assert_eq!(resolved_json["profile_id"], "openai-prod");
+    // No note expected on the happy path — pinned + present + materialised.
+    assert!(
+        resolved_json["note"].is_null(),
+        "no note on a clean pinned resolution",
+    );
+
+    // ── 4. Runtime materialisation: dispatch path uses the same resolver. ──
+    //
+    // The resolver returns `SecretMaterial::Env` entries that are then
+    // copied into `DispatchPayload.secrets` by both `dispatch_api` and
+    // `cli_agent_api`. Asserting them here proves the configured profile
+    // makes it all the way to what the worker would inject as env vars.
+    let pool = state.credential_pool.as_ref().expect("pool wired");
+    let runtime = resolve_credential_for_agent(pool, &stored).await;
+    assert_eq!(runtime.mode, BindingMode::Pinned, "runtime sees Pinned");
+    let materialised = runtime.resolved.expect("runtime materialises secrets");
+    assert_eq!(materialised.namespace, "providers");
+    assert_eq!(materialised.profile_id, "openai-prod");
+    assert_eq!(
+        materialised.secrets.len(),
+        2,
+        "expected OPENAI_API_KEY + OPENAI_BASE_URL",
+    );
+
+    let env_pairs: Vec<(String, String)> = materialised
+        .secrets
+        .iter()
+        .map(|m| match m {
+            oversight_vault::SecretMaterial::Env { name, value } => {
+                (name.clone(), value.expose_secret().to_string())
+            }
+            other => panic!("expected Env material, got {other:?}"),
+        })
+        .collect();
+
+    assert!(
+        env_pairs
+            .iter()
+            .any(|(n, v)| n == "OPENAI_API_KEY" && v == "sk-CONFIGURED-VIA-API"),
+        "OPENAI_API_KEY must carry the value the admin POSTed; got {env_pairs:?}",
+    );
+    assert!(
+        env_pairs
+            .iter()
+            .any(|(n, v)| n == "OPENAI_BASE_URL" && v == "https://api.openai.example/v1"),
+        "OPENAI_BASE_URL must carry the base_url the admin POSTed; got {env_pairs:?}",
+    );
+}
+
+#[tokio::test]
+async fn config_to_dispatch_chain_auto_mode_picks_pool_default() {
+    // Companion test to the pinned path: when the agent has *no*
+    // credential_id, the same chain still works — the pool's auto-pick
+    // resolves to the only configured profile and its env vars flow
+    // through to the dispatch payload. This guards against accidentally
+    // breaking the legacy Auto path in the unified resolver.
+    let mut state = common::build_sqlite_app_state().await;
+    install_credential_pool(&mut state);
+
+    let admin = AuthContext { user: admin_user() };
+    grant_admin_workspace_async(&state, &admin.user.id).await;
+    let admin_router = admin_api::routes(state.clone());
+
+    // Configure a single CLI claude profile via the admin endpoint.
+    let response = admin_router
+        .oneshot(req(
+            "POST",
+            "/credentials/cli",
+            Some(json!({
+                "id": "claude-default",
+                "adapter_type": "claude",
+                "auth_kind": "api_key",
+                "secret": "sk-CLAUDE-DEFAULT",
+                "base_url": "https://api.anthropic.com/",
+            })),
+            Some(admin.clone()),
+        ))
+        .await
+        .expect("create");
+    assert_eq!(response.status(), StatusCode::CREATED);
+
+    // Insert an agent with NO credential_id (Auto mode).
+    let mut def = AgentDef::new("claude-auto", "Claude Auto", "prompt");
+    def.agent_type = "claude".into();
+    def.model = "sonnet".into();
+    state.storage.insert_agent_def(&def).await.unwrap();
+
+    // Resolve and verify env vars come from the only configured profile.
+    let pool = state.credential_pool.as_ref().expect("pool wired");
+    let runtime = resolve_credential_for_agent(pool, &def).await;
+    assert_eq!(runtime.mode, BindingMode::Auto);
+    let materialised = runtime.resolved.expect("auto materialises");
+    let env_pairs: Vec<(String, String)> = materialised
+        .secrets
+        .iter()
+        .map(|m| match m {
+            oversight_vault::SecretMaterial::Env { name, value } => {
+                (name.clone(), value.expose_secret().to_string())
+            }
+            other => panic!("expected Env, got {other:?}"),
+        })
+        .collect();
+
+    assert!(env_pairs
+        .iter()
+        .any(|(n, v)| n == "ANTHROPIC_API_KEY" && v == "sk-CLAUDE-DEFAULT"));
+    assert!(env_pairs
+        .iter()
+        .any(|(n, v)| n == "ANTHROPIC_BASE_URL" && v == "https://api.anthropic.com/"));
+}
