use async_trait::async_trait;
use axum::body::Body;
use http::Request;
use kz_server::config::*;
use kz_server::proxy::build_proxy_router;
use kz_server::resolver::{ResolvedSecret, SecretResolver};
use kz_server::signing::KeyzeroSigner;
use std::collections::HashMap;
use std::sync::Arc;
use tower::ServiceExt; use wiremock::matchers::{header, method, path};
use wiremock::{Mock, MockServer, ResponseTemplate};
struct FixedResolver {
value: String,
}
#[async_trait]
impl SecretResolver for FixedResolver {
async fn resolve(&self, _config: &ResolverConfig) -> kz_server::error::Result<ResolvedSecret> {
Ok(ResolvedSecret {
value: self.value.clone(),
ttl: None,
})
}
}
fn test_bundle_for_proxy(mock_url: &str) -> Bundle {
Bundle {
version: "1".into(),
issuers: vec![],
tag_mappings: vec![],
policies: vec![],
resources: vec![Resource {
id: "ai/openai".into(),
tags: vec!["env:prod".into()],
resolvers: vec![ResolverConfig {
name: "api_key".into(),
mode: ResolverMode::ShortLived,
backend: "test_backend".into(),
path: None,
field: None,
role_arn: None,
duration_seconds: None,
secret_id: None,
credential_location: Some("header:Authorization:Bearer".into()),
ttl: Some(300),
}],
}],
backends: HashMap::from([(
"test_backend".into(),
BackendConfig {
backend_type: "env_file".into(),
address: Some(mock_url.into()),
auth: None,
region: None,
path: None,
vault: None,
},
)]),
}
}
fn sign_proxy_jwt(resource: &str, resolver: &str) -> String {
let private_pem = include_bytes!("fixtures/test_rsa_private.pem");
let signer = KeyzeroSigner::new(private_pem, "kzagent").unwrap();
signer.sign_short_lived(resource, resolver, 300).unwrap()
}
#[tokio::test]
async fn test_proxy_swaps_credentials_and_forwards() {
let mock_server = MockServer::start().await;
Mock::given(method("GET"))
.and(path("/v1/chat/completions"))
.and(header("authorization", "Bearer sk-real-secret-key-123"))
.respond_with(
ResponseTemplate::new(200)
.set_body_json(serde_json::json!({"response": "hello from upstream"})),
)
.mount(&mock_server)
.await;
let public_pem = include_bytes!("fixtures/test_rsa_public.pem");
let bundle = test_bundle_for_proxy(&mock_server.uri());
let resolvers: HashMap<String, Arc<dyn SecretResolver>> = HashMap::from([(
"test_backend".into(),
Arc::new(FixedResolver {
value: "sk-real-secret-key-123".into(),
}) as Arc<dyn SecretResolver>,
)]);
let app = build_proxy_router(bundle, public_pem, resolvers)
.await
.unwrap();
let kz_token = sign_proxy_jwt("ai/openai", "api_key");
let target_url = format!("{}/v1/chat/completions", mock_server.uri());
let req = Request::builder()
.method("GET")
.uri(&target_url)
.header("Authorization", format!("Bearer {kz_token}"))
.header("Host", "api.openai.com")
.body(Body::empty())
.unwrap();
let response = app.oneshot(req).await.unwrap();
assert_eq!(response.status(), http::StatusCode::OK);
let body_bytes = axum::body::to_bytes(response.into_body(), usize::MAX)
.await
.unwrap();
let body: serde_json::Value = serde_json::from_slice(&body_bytes).unwrap();
assert_eq!(body["response"], "hello from upstream");
}
#[tokio::test]
async fn test_proxy_rejects_missing_auth() {
let public_pem = include_bytes!("fixtures/test_rsa_public.pem");
let bundle = test_bundle_for_proxy("http://localhost:9999");
let resolvers: HashMap<String, Arc<dyn SecretResolver>> = HashMap::new();
let app = build_proxy_router(bundle, public_pem, resolvers)
.await
.unwrap();
let req = Request::builder()
.method("GET")
.uri("http://localhost:9999/v1/test")
.body(Body::empty())
.unwrap();
let response = app.oneshot(req).await.unwrap();
assert_eq!(response.status(), http::StatusCode::UNAUTHORIZED);
}
#[tokio::test]
async fn test_proxy_rejects_invalid_jwt() {
let public_pem = include_bytes!("fixtures/test_rsa_public.pem");
let bundle = test_bundle_for_proxy("http://localhost:9999");
let resolvers: HashMap<String, Arc<dyn SecretResolver>> = HashMap::new();
let app = build_proxy_router(bundle, public_pem, resolvers)
.await
.unwrap();
let req = Request::builder()
.method("GET")
.uri("http://localhost:9999/v1/test")
.header("Authorization", "Bearer invalid.jwt.token")
.body(Body::empty())
.unwrap();
let response = app.oneshot(req).await.unwrap();
assert_eq!(response.status(), http::StatusCode::UNAUTHORIZED);
}
#[tokio::test]
async fn test_proxy_custom_credential_location() {
let mock_server = MockServer::start().await;
Mock::given(method("POST"))
.and(path("/api/generate"))
.and(header("x-api-key", "real-api-key-456"))
.respond_with(
ResponseTemplate::new(200).set_body_json(serde_json::json!({"result": "generated"})),
)
.mount(&mock_server)
.await;
let public_pem = include_bytes!("fixtures/test_rsa_public.pem");
let mut bundle = test_bundle_for_proxy(&mock_server.uri());
bundle.resources[0].resolvers[0].credential_location = Some("header:X-API-Key:".into());
let resolvers: HashMap<String, Arc<dyn SecretResolver>> = HashMap::from([(
"test_backend".into(),
Arc::new(FixedResolver {
value: "real-api-key-456".into(),
}) as Arc<dyn SecretResolver>,
)]);
let app = build_proxy_router(bundle, public_pem, resolvers)
.await
.unwrap();
let kz_token = sign_proxy_jwt("ai/openai", "api_key");
let target_url = format!("{}/api/generate", mock_server.uri());
let req = Request::builder()
.method("POST")
.uri(&target_url)
.header("Authorization", format!("Bearer {kz_token}"))
.header("Content-Type", "application/json")
.body(Body::from(r#"{"prompt": "hello"}"#))
.unwrap();
let response = app.oneshot(req).await.unwrap();
assert_eq!(response.status(), http::StatusCode::OK);
let body_bytes = axum::body::to_bytes(response.into_body(), usize::MAX)
.await
.unwrap();
let body: serde_json::Value = serde_json::from_slice(&body_bytes).unwrap();
assert_eq!(body["result"], "generated");
}