use axum::body::Body;
use http::Request;
use kz_server::config::*;
use kz_server::server::build_router;
use std::collections::HashMap;
use tower::ServiceExt;
async fn axum_test_helper(
app: &axum::Router,
method: &str,
path: &str,
body: Option<String>,
auth: Option<String>,
) -> (http::StatusCode, String) {
let mut req = Request::builder().method(method).uri(path);
if let Some(token) = auth {
req = req.header("Authorization", format!("Bearer {token}"));
}
let body = body.map(Body::from).unwrap_or(Body::empty());
let req = req
.header("Content-Type", "application/json")
.body(body)
.unwrap();
let response = app.clone().oneshot(req).await.unwrap();
let status = response.status();
let body_bytes = axum::body::to_bytes(response.into_body(), usize::MAX)
.await
.unwrap();
(status, String::from_utf8(body_bytes.to_vec()).unwrap())
}
fn test_bundle(env_path: &str) -> Bundle {
Bundle {
version: "1".into(),
issuers: vec![Issuer {
name: "test-issuer".into(),
issuer_url: "https://test-issuer.example.com".into(),
jwks_url: None,
audience: Some("keyzero".into()),
static_keys: Some(vec![StaticKey {
kid: "test-key-01".into(),
alg: "RS256".into(),
pem: String::from_utf8(include_bytes!("fixtures/test_rsa_public.pem").to_vec())
.unwrap(),
}]),
}],
tag_mappings: vec![TagMapping {
match_rule: TagMatchRule {
issuer: "test-issuer".into(),
claims: HashMap::from([("repository".into(), "myorg/*".into())]),
},
tags: vec!["env:ci".into(), "team:platform".into()],
}],
policies: vec![
Policy {
name: "allow-ci".into(),
description: Some("Allow CI".into()),
match_rule: Some(PolicyMatchRule {
resource_tags: vec!["env:ci".into()],
}),
rule: "'env:ci' in caller_tags".into(),
effect: Effect::Allow,
},
Policy {
name: "default-deny".into(),
description: None,
match_rule: None,
rule: "true".into(),
effect: Effect::Deny,
},
],
resources: vec![Resource {
id: "ci/api-key".into(),
tags: vec!["env:ci".into(), "type:api".into()],
resolvers: vec![ResolverConfig {
name: "key".into(),
mode: ResolverMode::Direct,
backend: "local".into(),
path: None,
field: Some("API_KEY".into()),
role_arn: None,
duration_seconds: None,
secret_id: None,
credential_location: None,
ttl: None,
}],
}],
backends: HashMap::from([(
"local".into(),
BackendConfig {
backend_type: BackendType::EnvFile,
address: None,
auth: None,
region: None,
path: Some(env_path.into()),
vault: None,
},
)]),
}
}
fn make_test_jwt() -> String {
use jsonwebtoken::{encode, Algorithm, EncodingKey, Header};
let rsa_private = include_bytes!("fixtures/test_rsa_private.pem");
let mut claims = std::collections::HashMap::new();
claims.insert("sub", serde_json::json!("test-subject"));
claims.insert("iss", serde_json::json!("https://test-issuer.example.com"));
claims.insert("aud", serde_json::json!("keyzero"));
claims.insert(
"exp",
serde_json::json!((chrono::Utc::now() + chrono::Duration::hours(1)).timestamp()),
);
claims.insert("repository", serde_json::json!("myorg/myrepo"));
let mut header = Header::new(Algorithm::RS256);
header.kid = Some("test-key-01".into());
encode(
&header,
&claims,
&EncodingKey::from_rsa_pem(rsa_private).unwrap(),
)
.unwrap()
}
#[tokio::test]
async fn test_healthz() {
let dir = tempfile::tempdir().unwrap();
let env_path = dir.path().join("secrets.env");
std::fs::write(&env_path, "API_KEY=sk-test-123\n").unwrap();
let bundle = test_bundle(env_path.to_str().unwrap());
let app = build_router(bundle).await.unwrap();
let (status, body) = axum_test_helper(&app, "GET", "/healthz", None, None).await;
assert_eq!(status, http::StatusCode::OK);
let json: serde_json::Value = serde_json::from_str(&body).unwrap();
assert_eq!(json["status"], "ok");
assert_eq!(json["bundle_loaded"], true);
}
#[tokio::test]
async fn test_resolve_endpoint_success() {
let dir = tempfile::tempdir().unwrap();
let env_path = dir.path().join("secrets.env");
std::fs::write(&env_path, "API_KEY=sk-test-123\n").unwrap();
let bundle = test_bundle(env_path.to_str().unwrap());
let app = build_router(bundle).await.unwrap();
let token = make_test_jwt();
let body = serde_json::json!({"resource": "ci/api-key"}).to_string();
let (status, response_body) =
axum_test_helper(&app, "POST", "/v1/resolve", Some(body), Some(token)).await;
assert_eq!(status, http::StatusCode::OK);
let json: serde_json::Value = serde_json::from_str(&response_body).unwrap();
assert_eq!(json["allowed"], true);
assert_eq!(json["resource"], "ci/api-key");
assert_eq!(json["secrets"]["key"]["value"], "sk-test-123");
}
#[tokio::test]
async fn test_resolve_endpoint_no_auth() {
let dir = tempfile::tempdir().unwrap();
let env_path = dir.path().join("secrets.env");
std::fs::write(&env_path, "API_KEY=sk-test-123\n").unwrap();
let bundle = test_bundle(env_path.to_str().unwrap());
let app = build_router(bundle).await.unwrap();
let body = serde_json::json!({"resource": "ci/api-key"}).to_string();
let (status, response_body) = axum_test_helper(
&app,
"POST",
"/v1/resolve",
Some(body),
None, )
.await;
assert_eq!(status, http::StatusCode::UNAUTHORIZED);
let json: serde_json::Value = serde_json::from_str(&response_body).unwrap();
assert_eq!(json["error"], "invalid_token");
}
#[tokio::test]
async fn test_resolve_expired_jwt_returns_401() {
let dir = tempfile::tempdir().unwrap();
let env_path = dir.path().join("secrets.env");
std::fs::write(&env_path, "API_KEY=sk-test-123\n").unwrap();
let bundle = test_bundle(env_path.to_str().unwrap());
let app = build_router(bundle).await.unwrap();
let rsa_private = include_bytes!("fixtures/test_rsa_private.pem");
let mut claims = std::collections::HashMap::new();
claims.insert("sub", serde_json::json!("test-subject"));
claims.insert("iss", serde_json::json!("https://test-issuer.example.com"));
claims.insert("aud", serde_json::json!("keyzero"));
claims.insert(
"exp",
serde_json::json!((chrono::Utc::now() - chrono::Duration::hours(1)).timestamp()),
);
claims.insert("repository", serde_json::json!("myorg/myrepo"));
let mut header = jsonwebtoken::Header::new(jsonwebtoken::Algorithm::RS256);
header.kid = Some("test-key-01".into());
let token = jsonwebtoken::encode(
&header,
&claims,
&jsonwebtoken::EncodingKey::from_rsa_pem(rsa_private).unwrap(),
)
.unwrap();
let body = serde_json::json!({"resource": "ci/api-key"}).to_string();
let (status, _) =
axum_test_helper(&app, "POST", "/v1/resolve", Some(body), Some(token)).await;
assert_eq!(status, http::StatusCode::UNAUTHORIZED);
}
#[tokio::test]
async fn test_resolve_wrong_kid_returns_401() {
let dir = tempfile::tempdir().unwrap();
let env_path = dir.path().join("secrets.env");
std::fs::write(&env_path, "API_KEY=sk-test-123\n").unwrap();
let bundle = test_bundle(env_path.to_str().unwrap());
let app = build_router(bundle).await.unwrap();
let rsa_private = include_bytes!("fixtures/test_rsa_private.pem");
let mut claims = std::collections::HashMap::new();
claims.insert("sub", serde_json::json!("test-subject"));
claims.insert("iss", serde_json::json!("https://test-issuer.example.com"));
claims.insert("aud", serde_json::json!("keyzero"));
claims.insert(
"exp",
serde_json::json!((chrono::Utc::now() + chrono::Duration::hours(1)).timestamp()),
);
claims.insert("repository", serde_json::json!("myorg/myrepo"));
let mut header = jsonwebtoken::Header::new(jsonwebtoken::Algorithm::RS256);
header.kid = Some("nonexistent-key-id".into());
let token = jsonwebtoken::encode(
&header,
&claims,
&jsonwebtoken::EncodingKey::from_rsa_pem(rsa_private).unwrap(),
)
.unwrap();
let body = serde_json::json!({"resource": "ci/api-key"}).to_string();
let (status, _) =
axum_test_helper(&app, "POST", "/v1/resolve", Some(body), Some(token)).await;
assert_eq!(status, http::StatusCode::UNAUTHORIZED);
}
#[tokio::test]
async fn test_resolve_unknown_issuer_returns_401() {
let dir = tempfile::tempdir().unwrap();
let env_path = dir.path().join("secrets.env");
std::fs::write(&env_path, "API_KEY=sk-test-123\n").unwrap();
let bundle = test_bundle(env_path.to_str().unwrap());
let app = build_router(bundle).await.unwrap();
let rsa_private = include_bytes!("fixtures/test_rsa_private.pem");
let mut claims = std::collections::HashMap::new();
claims.insert("sub", serde_json::json!("test-subject"));
claims.insert("iss", serde_json::json!("https://unknown-issuer.example.com"));
claims.insert("aud", serde_json::json!("keyzero"));
claims.insert(
"exp",
serde_json::json!((chrono::Utc::now() + chrono::Duration::hours(1)).timestamp()),
);
claims.insert("repository", serde_json::json!("myorg/myrepo"));
let mut header = jsonwebtoken::Header::new(jsonwebtoken::Algorithm::RS256);
header.kid = Some("test-key-01".into());
let token = jsonwebtoken::encode(
&header,
&claims,
&jsonwebtoken::EncodingKey::from_rsa_pem(rsa_private).unwrap(),
)
.unwrap();
let body = serde_json::json!({"resource": "ci/api-key"}).to_string();
let (status, _) =
axum_test_helper(&app, "POST", "/v1/resolve", Some(body), Some(token)).await;
assert_eq!(status, http::StatusCode::UNAUTHORIZED);
}