use crate::common::time_utils;
use crate::domain::auth::ScopePermission;
use crate::infrastructure::auth::get_garrison_dao;
use crate::infrastructure::database::entities::api_key::{ActiveModel, Entity};
use crate::infrastructure::database::entities::team::Entity as TeamEntity;
use crate::presentation::handlers::response_builder::{
error_response, json_rejection_response, ApiResponse,
};
use crate::presentation::middleware::auth_middleware::AuthState;
use axum::{
extract::Extension,
http::{header, HeaderValue, StatusCode},
response::{IntoResponse, Response},
Json,
};
use chrono::Utc;
use dbnexus::sea_orm::EntityTrait;
use serde::{Deserialize, Serialize};
use std::sync::Arc;
const GARRISON_NAMESPACE: &str = "crawlrs";
const DEFAULT_EXPIRES_IN_SECS: i64 = 30 * 24 * 60 * 60;
const MAX_EXPIRES_IN_SECS: i64 = 365 * 24 * 60 * 60;
const MAX_SCOPES_LEN: usize = 10;
const SCOPE_READ: &str = "read";
const SCOPE_WRITE: &str = "write";
const SCOPE_ADMIN: &str = "admin";
const PERM_PREFIX: &str = "crawlrs:";
#[derive(Debug, Clone, Deserialize)]
pub struct CreateApiKeyRequest {
pub team_id: crate::domain::id::Id,
pub scopes: Vec<String>,
pub expires_in_secs: Option<i64>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CreateApiKeyResponse {
pub api_key: String,
pub api_key_id: crate::domain::id::Id,
pub team_id: crate::domain::id::Id,
pub scopes: Vec<String>,
pub expires_at: String,
}
pub async fn create_api_key(
Extension(auth_state): Extension<AuthState>,
payload: Result<Json<CreateApiKeyRequest>, axum::extract::rejection::JsonRejection>,
) -> Response {
let Json(req) = match payload {
Ok(parsed) => parsed,
Err(ref rej) => return json_rejection_response(rej),
};
if !auth_state.scope.has_permission(ScopePermission::Admin) {
return error_response(
StatusCode::FORBIDDEN,
"Admin permission required to issue API keys",
);
}
if let Err(msg) = validate_request(&req) {
return error_response(StatusCode::BAD_REQUEST, msg);
}
let pool_for_check = auth_state.pool.clone();
if let Err(e) = check_team_exists(&pool_for_check, req.team_id).await {
log::warn!(
"team_id existence check failed (team_id={}): {}",
req.team_id,
e
);
return error_response(
StatusCode::INTERNAL_SERVER_ERROR,
"Failed to validate team_id",
);
}
let api_key_id = crate::domain::id::Id::generate();
let expires_in_secs = req.expires_in_secs.unwrap_or(DEFAULT_EXPIRES_IN_SECS);
let now = Utc::now();
let expires_at = now + chrono::Duration::seconds(expires_in_secs);
let garrison_scopes = map_scopes_to_garrison_perms(&req.scopes);
let plaintext_key = match issue_garrison_key(api_key_id, garrison_scopes, expires_in_secs).await
{
Ok(key) => key,
Err(response) => return response,
};
let garrison_key_id = match parse_garrison_key_id(&plaintext_key, api_key_id) {
Ok(key_id) => key_id,
Err(response) => return response,
};
match insert_api_key_mapping(&pool_for_check, api_key_id, req.team_id, garrison_key_id).await {
Ok(()) => {
let response = CreateApiKeyResponse {
api_key: plaintext_key,
api_key_id,
team_id: req.team_id,
scopes: req.scopes.clone(),
expires_at: expires_at.to_rfc3339(),
};
created_api_key_response(response)
}
Err(e) => {
log::error!(
"Failed to insert api_key mapping (api_key_id={}, team_id={}): {}",
api_key_id,
req.team_id,
e
);
error_response(
StatusCode::INTERNAL_SERVER_ERROR,
"Failed to persist API key mapping",
)
}
}
}
#[allow(clippy::result_large_err)]
async fn issue_garrison_key(
api_key_id: crate::domain::id::Id,
garrison_scopes: Vec<String>,
expires_in_secs: i64,
) -> Result<String, Response> {
let dao = match get_garrison_dao() {
Some(d) => d,
None => {
log::error!(
"garrison DAO not injected — call init_garrison_auth before serving requests"
);
return Err(error_response(
StatusCode::INTERNAL_SERVER_ERROR,
"Authentication service unavailable",
));
}
};
let handler = garrison::protocol::apikey::ApiKeyHandler::new(dao);
match handler
.generate_with_namespace(
api_key_id.to_string(),
GARRISON_NAMESPACE,
garrison_scopes,
expires_in_secs,
)
.await
{
Ok(k) => Ok(k),
Err(e) => {
log::error!(
"garrison ApiKeyHandler::generate_with_namespace failed: api_key_id={}, err={}",
api_key_id,
e
);
Err(error_response(
StatusCode::INTERNAL_SERVER_ERROR,
"Failed to issue API key",
))
}
}
}
#[allow(clippy::result_large_err)]
fn parse_garrison_key_id(
plaintext_key: &str,
api_key_id: crate::domain::id::Id,
) -> Result<String, Response> {
match plaintext_key.split_once('.') {
Some((k_id, _)) => Ok(k_id.to_string()),
None => {
log::error!(
"garrison returned malformed key (no '.' separator): api_key_id={} (key length={})",
api_key_id,
plaintext_key.len()
);
Err(error_response(
StatusCode::INTERNAL_SERVER_ERROR,
"Authentication service returned malformed key",
))
}
}
}
fn created_api_key_response(response: CreateApiKeyResponse) -> Response {
let mut resp = (StatusCode::CREATED, Json(ApiResponse::success(response))).into_response();
resp.headers_mut()
.insert(header::CACHE_CONTROL, HeaderValue::from_static("no-store"));
resp.headers_mut()
.insert(header::PRAGMA, HeaderValue::from_static("no-cache"));
resp.headers_mut()
.insert(header::EXPIRES, HeaderValue::from_static("0"));
resp
}
fn validate_request(req: &CreateApiKeyRequest) -> Result<(), String> {
if req.team_id == crate::domain::id::Id::nil() {
return Err("team_id must not be nil UUID".to_string());
}
if req.scopes.is_empty() {
return Err("scopes must not be empty".to_string());
}
if req.scopes.len() > MAX_SCOPES_LEN {
return Err(format!(
"scopes length must not exceed {} (got {})",
MAX_SCOPES_LEN,
req.scopes.len()
));
}
for scope in &req.scopes {
match scope.as_str() {
SCOPE_READ | SCOPE_WRITE | SCOPE_ADMIN => {}
other => {
return Err(format!(
"invalid scope: {} (allowed: read/write/admin)",
other
));
}
}
}
if let Some(expires_in) = req.expires_in_secs {
if expires_in <= 0 {
return Err("expires_in_secs must be positive".to_string());
}
if expires_in > MAX_EXPIRES_IN_SECS {
return Err(format!(
"expires_in_secs must not exceed {} seconds (1 year)",
MAX_EXPIRES_IN_SECS
));
}
}
Ok(())
}
async fn check_team_exists(
pool: &Arc<dbnexus::DbPool>,
team_id: crate::domain::id::Id,
) -> Result<(), dbnexus::sea_orm::DbErr> {
let session = pool
.get_session("admin")
.await
.map_err(|e| dbnexus::sea_orm::DbErr::Custom(format!("db session: {}", e)))?;
let conn = session
.connection()
.map_err(|e| dbnexus::sea_orm::DbErr::Custom(format!("db conn: {}", e)))?;
let row = TeamEntity::find_by_id(team_id).one(conn).await?;
if row.is_some() {
Ok(())
} else {
Err(dbnexus::sea_orm::DbErr::RecordNotFound(format!(
"team not found: {}",
team_id
)))
}
}
fn map_scopes_to_garrison_perms(scopes: &[String]) -> Vec<String> {
scopes
.iter()
.map(|s| match s.as_str() {
SCOPE_READ => format!("{}{}", PERM_PREFIX, SCOPE_READ),
SCOPE_WRITE => format!("{}{}", PERM_PREFIX, SCOPE_WRITE),
SCOPE_ADMIN => format!("{}{}", PERM_PREFIX, SCOPE_ADMIN),
_ => unreachable!("validate_request guarantees the scope is valid"),
})
.collect()
}
async fn insert_api_key_mapping(
pool: &Arc<dbnexus::DbPool>,
api_key_id: crate::domain::id::Id,
team_id: crate::domain::id::Id,
garrison_key_id: String,
) -> Result<(), dbnexus::sea_orm::DbErr> {
let session = pool
.get_session("admin")
.await
.map_err(|e| dbnexus::sea_orm::DbErr::Custom(format!("db session: {}", e)))?;
let conn = session
.connection()
.map_err(|e| dbnexus::sea_orm::DbErr::Custom(format!("db conn: {}", e)))?;
let now = time_utils::to_db_datetime(Utc::now());
let active = ActiveModel {
id: dbnexus::sea_orm::ActiveValue::Set(api_key_id.into()),
team_id: dbnexus::sea_orm::ActiveValue::Set(team_id.into()),
key: dbnexus::sea_orm::ActiveValue::Set(garrison_key_id),
created_at: dbnexus::sea_orm::ActiveValue::Set(now),
updated_at: dbnexus::sea_orm::ActiveValue::Set(None),
};
Entity::insert(active).exec(conn).await?;
Ok(())
}
#[cfg(test)]
mod tests {
use super::*;
use crate::common::test_helpers::{create_test_db_pool, skip_if_no_test_db};
use crate::domain::auth::ApiKeyScope;
use crate::infrastructure::auth::garrison_dao::{
init_garrison_dao, reset_garrison_dao_for_test, set_garrison_dao,
};
use crate::infrastructure::database::entities::api_key::Entity as ApiKeyEntity;
use crate::presentation::handlers::response_builder::ApiResponse;
use axum::response::IntoResponse;
use dbnexus::sea_orm::EntityTrait;
fn make_admin_auth_state() -> AuthState {
let pool = create_test_db_pool();
AuthState::new(
pool,
crate::domain::id::Id::generate(),
crate::domain::id::Id::generate(),
ApiKeyScope::full_access(),
)
}
fn make_read_only_auth_state() -> AuthState {
let pool = create_test_db_pool();
AuthState::new(
pool,
crate::domain::id::Id::generate(),
crate::domain::id::Id::generate(),
ApiKeyScope::read_only(),
)
}
async fn inject_test_garrison_dao() {
let dao = init_garrison_dao()
.await
.expect("init_garrison_dao must succeed in test");
if set_garrison_dao(dao).is_err() {
panic!(
"set_garrison_dao failed: DAO already injected \
(call reset_garrison_dao_for_test() before inject)"
);
}
}
async fn seed_team_in_db(pool: &Arc<dbnexus::DbPool>, team_id: crate::domain::id::Id) {
use crate::infrastructure::database::entities::team::ActiveModel as TeamActiveModel;
use dbnexus::sea_orm::ActiveValue;
let session = pool
.get_session("admin")
.await
.expect("get_session failed in seed_team_in_db");
let conn = session
.connection()
.expect("connection failed in seed_team_in_db");
let now = time_utils::to_db_datetime(Utc::now());
let active = TeamActiveModel {
id: ActiveValue::Set(team_id.into()),
name: ActiveValue::Set(format!("test-team-{}", team_id)),
allowed_countries: ActiveValue::Set(None),
blocked_countries: ActiveValue::Set(None),
ip_whitelist: ActiveValue::Set(None),
domain_blacklist: ActiveValue::Set(None),
enable_geo_restrictions: ActiveValue::Set(false),
created_at: ActiveValue::Set(now),
updated_at: ActiveValue::Set(now),
};
TeamEntity::insert(active)
.exec(conn)
.await
.map(|_| ())
.or_else(|e| {
let msg = e.to_string();
if msg.contains("duplicate key") || msg.contains("23505") {
Ok(())
} else {
Err(e)
}
})
.expect("Failed to seed team in DB");
}
#[test]
fn test_validate_request_happy_path_minimal() {
let req = CreateApiKeyRequest {
team_id: crate::domain::id::Id::generate(),
scopes: vec!["read".to_string()],
expires_in_secs: Some(3600),
};
assert!(validate_request(&req).is_ok());
}
#[test]
fn test_validate_request_happy_path_all_scopes() {
let req = CreateApiKeyRequest {
team_id: crate::domain::id::Id::generate(),
scopes: vec!["read".to_string(), "write".to_string(), "admin".to_string()],
expires_in_secs: Some(86400),
};
assert!(validate_request(&req).is_ok());
}
#[test]
fn test_validate_request_default_expires_ok() {
let req = CreateApiKeyRequest {
team_id: crate::domain::id::Id::generate(),
scopes: vec!["admin".to_string()],
expires_in_secs: None,
};
assert!(validate_request(&req).is_ok());
}
#[test]
fn test_validate_request_max_expires_ok() {
let req = CreateApiKeyRequest {
team_id: crate::domain::id::Id::generate(),
scopes: vec!["read".to_string()],
expires_in_secs: Some(MAX_EXPIRES_IN_SECS),
};
assert!(validate_request(&req).is_ok());
}
#[test]
fn test_validate_request_nil_team_id_rejected() {
let req = CreateApiKeyRequest {
team_id: crate::domain::id::Id::nil(),
scopes: vec!["read".to_string()],
expires_in_secs: None,
};
let err = validate_request(&req).unwrap_err();
assert!(err.contains("team_id"), "err: {}", err);
}
#[test]
fn test_validate_request_empty_scopes_rejected() {
let req = CreateApiKeyRequest {
team_id: crate::domain::id::Id::generate(),
scopes: vec![],
expires_in_secs: None,
};
let err = validate_request(&req).unwrap_err();
assert!(err.contains("scopes"), "err: {}", err);
}
#[test]
fn test_validate_request_invalid_scope_rejected() {
let req = CreateApiKeyRequest {
team_id: crate::domain::id::Id::generate(),
scopes: vec!["superuser".to_string()],
expires_in_secs: None,
};
let err = validate_request(&req).unwrap_err();
assert!(err.contains("invalid scope"), "err: {}", err);
assert!(err.contains("superuser"), "err: {}", err);
}
#[test]
fn test_validate_request_mix_valid_invalid_scope_rejected() {
let req = CreateApiKeyRequest {
team_id: crate::domain::id::Id::generate(),
scopes: vec!["read".to_string(), "delete".to_string()],
expires_in_secs: None,
};
let err = validate_request(&req).unwrap_err();
assert!(err.contains("delete"), "err: {}", err);
}
#[test]
fn test_validate_request_zero_expires_rejected() {
let req = CreateApiKeyRequest {
team_id: crate::domain::id::Id::generate(),
scopes: vec!["read".to_string()],
expires_in_secs: Some(0),
};
let err = validate_request(&req).unwrap_err();
assert!(err.contains("positive"), "err: {}", err);
}
#[test]
fn test_validate_request_negative_expires_rejected() {
let req = CreateApiKeyRequest {
team_id: crate::domain::id::Id::generate(),
scopes: vec!["read".to_string()],
expires_in_secs: Some(-1),
};
let err = validate_request(&req).unwrap_err();
assert!(err.contains("positive"), "err: {}", err);
}
#[test]
fn test_validate_request_over_max_expires_rejected() {
let req = CreateApiKeyRequest {
team_id: crate::domain::id::Id::generate(),
scopes: vec!["read".to_string()],
expires_in_secs: Some(MAX_EXPIRES_IN_SECS + 1),
};
let err = validate_request(&req).unwrap_err();
assert!(err.contains("1 year"), "err: {}", err);
}
#[test]
fn test_validate_request_scopes_too_long_rejected() {
let oversized_scopes: Vec<String> =
std::iter::repeat_n("read".to_string(), MAX_SCOPES_LEN + 1).collect();
let req = CreateApiKeyRequest {
team_id: crate::domain::id::Id::generate(),
scopes: oversized_scopes,
expires_in_secs: None,
};
let err = validate_request(&req).unwrap_err();
assert!(
err.contains("scopes length must not exceed"),
"must reject oversized scopes, err: {}",
err
);
assert!(err.contains(&MAX_SCOPES_LEN.to_string()));
}
#[test]
fn test_validate_request_scopes_at_limit_ok() {
let scopes: Vec<String> = std::iter::repeat_n("read".to_string(), MAX_SCOPES_LEN).collect();
let req = CreateApiKeyRequest {
team_id: crate::domain::id::Id::generate(),
scopes,
expires_in_secs: None,
};
assert!(
validate_request(&req).is_ok(),
"MAX_SCOPES_LEN boundary must pass"
);
}
#[test]
fn test_validate_request_empty_string_scope_rejected() {
let req = CreateApiKeyRequest {
team_id: crate::domain::id::Id::generate(),
scopes: vec!["".to_string()],
expires_in_secs: None,
};
let err = validate_request(&req).unwrap_err();
assert!(err.contains("invalid scope"), "err: {}", err);
}
#[test]
fn test_garrison_key_parsing_rejects_no_separator() {
let malformed_key = "no_separator_in_this_key_string";
assert!(malformed_key.split_once('.').is_none());
let normal_key = "abc123key_id.xyz456secret";
let parsed = normal_key.split_once('.').map(|(k_id, _)| k_id.to_string());
assert_eq!(parsed.as_deref(), Some("abc123key_id"));
}
#[test]
fn test_validate_request_case_sensitive_scope_rejected() {
let req = CreateApiKeyRequest {
team_id: crate::domain::id::Id::generate(),
scopes: vec!["Read".to_string()],
expires_in_secs: None,
};
let err = validate_request(&req).unwrap_err();
assert!(
err.contains("Read") || err.contains("invalid scope"),
"err: {}",
err
);
}
#[test]
fn test_validate_request_duplicate_scopes_ok() {
let req = CreateApiKeyRequest {
team_id: crate::domain::id::Id::generate(),
scopes: vec!["read".to_string(), "read".to_string()],
expires_in_secs: None,
};
assert!(validate_request(&req).is_ok());
}
#[test]
fn test_map_scopes_read_only() {
let perms = map_scopes_to_garrison_perms(&["read".to_string()]);
assert_eq!(perms, vec!["crawlrs:read".to_string()]);
}
#[test]
fn test_map_scopes_write_only() {
let perms = map_scopes_to_garrison_perms(&["write".to_string()]);
assert_eq!(perms, vec!["crawlrs:write".to_string()]);
}
#[test]
fn test_map_scopes_admin_only() {
let perms = map_scopes_to_garrison_perms(&["admin".to_string()]);
assert_eq!(perms, vec!["crawlrs:admin".to_string()]);
}
#[test]
fn test_map_scopes_all_three() {
let perms = map_scopes_to_garrison_perms(&[
"read".to_string(),
"write".to_string(),
"admin".to_string(),
]);
assert_eq!(
perms,
vec![
"crawlrs:read".to_string(),
"crawlrs:write".to_string(),
"crawlrs:admin".to_string(),
]
);
}
#[test]
fn test_map_scopes_empty_input_returns_empty() {
let perms = map_scopes_to_garrison_perms(&[]);
assert!(perms.is_empty());
}
#[tokio::test]
async fn test_create_api_key_non_admin_returns_403() {
if skip_if_no_test_db() {
return;
}
let auth_state = make_read_only_auth_state();
let req = CreateApiKeyRequest {
team_id: crate::domain::id::Id::generate(),
scopes: vec!["read".to_string()],
expires_in_secs: None,
};
let response = create_api_key(Extension(auth_state), Ok(Json(req)))
.await
.into_response();
assert_eq!(response.status(), StatusCode::FORBIDDEN);
}
#[tokio::test]
async fn test_create_api_key_denied_scope_returns_403() {
if skip_if_no_test_db() {
return;
}
let auth_state = AuthState::new(
create_test_db_pool(),
crate::domain::id::Id::generate(),
crate::domain::id::Id::generate(),
ApiKeyScope::denied(),
);
let req = CreateApiKeyRequest {
team_id: crate::domain::id::Id::generate(),
scopes: vec!["read".to_string()],
expires_in_secs: None,
};
let response = create_api_key(Extension(auth_state), Ok(Json(req)))
.await
.into_response();
assert_eq!(response.status(), StatusCode::FORBIDDEN);
}
#[tokio::test]
async fn test_create_api_key_nil_team_id_returns_400() {
if skip_if_no_test_db() {
return;
}
let auth_state = make_admin_auth_state();
let req = CreateApiKeyRequest {
team_id: crate::domain::id::Id::nil(),
scopes: vec!["read".to_string()],
expires_in_secs: None,
};
let response = create_api_key(Extension(auth_state), Ok(Json(req)))
.await
.into_response();
assert_eq!(response.status(), StatusCode::BAD_REQUEST);
}
#[tokio::test]
async fn test_create_api_key_empty_scopes_returns_400() {
if skip_if_no_test_db() {
return;
}
let auth_state = make_admin_auth_state();
let req = CreateApiKeyRequest {
team_id: crate::domain::id::Id::generate(),
scopes: vec![],
expires_in_secs: None,
};
let response = create_api_key(Extension(auth_state), Ok(Json(req)))
.await
.into_response();
assert_eq!(response.status(), StatusCode::BAD_REQUEST);
}
#[tokio::test]
async fn test_create_api_key_invalid_scope_returns_400() {
if skip_if_no_test_db() {
return;
}
let auth_state = make_admin_auth_state();
let req = CreateApiKeyRequest {
team_id: crate::domain::id::Id::generate(),
scopes: vec!["superuser".to_string()],
expires_in_secs: None,
};
let response = create_api_key(Extension(auth_state), Ok(Json(req)))
.await
.into_response();
assert_eq!(response.status(), StatusCode::BAD_REQUEST);
}
#[tokio::test]
async fn test_create_api_key_zero_expires_returns_400() {
if skip_if_no_test_db() {
return;
}
let auth_state = make_admin_auth_state();
let req = CreateApiKeyRequest {
team_id: crate::domain::id::Id::generate(),
scopes: vec!["read".to_string()],
expires_in_secs: Some(0),
};
let response = create_api_key(Extension(auth_state), Ok(Json(req)))
.await
.into_response();
assert_eq!(response.status(), StatusCode::BAD_REQUEST);
}
#[tokio::test]
async fn test_create_api_key_negative_expires_returns_400() {
if skip_if_no_test_db() {
return;
}
let auth_state = make_admin_auth_state();
let req = CreateApiKeyRequest {
team_id: crate::domain::id::Id::generate(),
scopes: vec!["read".to_string()],
expires_in_secs: Some(-100),
};
let response = create_api_key(Extension(auth_state), Ok(Json(req)))
.await
.into_response();
assert_eq!(response.status(), StatusCode::BAD_REQUEST);
}
#[tokio::test]
async fn test_create_api_key_over_max_expires_returns_400() {
if skip_if_no_test_db() {
return;
}
let auth_state = make_admin_auth_state();
let req = CreateApiKeyRequest {
team_id: crate::domain::id::Id::generate(),
scopes: vec!["read".to_string()],
expires_in_secs: Some(MAX_EXPIRES_IN_SECS + 1),
};
let response = create_api_key(Extension(auth_state), Ok(Json(req)))
.await
.into_response();
assert_eq!(response.status(), StatusCode::BAD_REQUEST);
}
#[tokio::test]
async fn test_create_api_key_dao_not_injected_returns_500() {
let _guard = crate::infrastructure::auth::garrison_dao::test_mutex()
.lock()
.await;
reset_garrison_dao_for_test();
if skip_if_no_test_db() {
return;
}
let auth_state = make_admin_auth_state();
let req = CreateApiKeyRequest {
team_id: crate::domain::id::Id::generate(),
scopes: vec!["read".to_string()],
expires_in_secs: None,
};
let response = create_api_key(Extension(auth_state), Ok(Json(req)))
.await
.into_response();
assert_eq!(response.status(), StatusCode::INTERNAL_SERVER_ERROR);
}
#[tokio::test(flavor = "multi_thread", worker_threads = 1)]
#[allow(deprecated)]
async fn test_create_api_key_happy_path_admin_creates_key_for_any_team() {
if skip_if_no_test_db() {
return;
}
let _guard = crate::infrastructure::auth::garrison_dao::test_mutex()
.lock()
.await;
reset_garrison_dao_for_test();
inject_test_garrison_dao().await;
if skip_if_no_test_db() {
return;
}
let auth_state = make_admin_auth_state();
let target_team_id = crate::domain::id::Id::generate();
seed_team_in_db(&auth_state.pool, target_team_id).await;
let req = CreateApiKeyRequest {
team_id: target_team_id,
scopes: vec!["read".to_string(), "write".to_string()],
expires_in_secs: Some(3600),
};
let response = create_api_key(Extension(auth_state.clone()), Ok(Json(req)))
.await
.into_response();
assert_eq!(response.status(), StatusCode::CREATED);
let body = axum::body::to_bytes(response.into_body(), usize::MAX)
.await
.unwrap();
let parsed: ApiResponse<CreateApiKeyResponse> = serde_json::from_slice(&body).unwrap();
assert!(parsed.success);
let data = parsed.data.unwrap();
assert!(!data.api_key.is_empty(), "api_key must be non-empty");
assert!(
data.api_key.contains('.'),
"api_key must be dual-segment format"
);
assert_eq!(data.team_id, target_team_id);
assert_eq!(data.scopes, vec!["read".to_string(), "write".to_string()]);
assert!(!data.expires_at.is_empty());
let session = auth_state.pool.get_session("admin").await.unwrap();
let conn = session.connection().unwrap();
let row = ApiKeyEntity::find_by_id(data.api_key_id)
.one(conn)
.await
.unwrap()
.expect("api_key mapping must exist in DB after create");
assert_eq!(target_team_id, row.team_id);
assert_eq!(row.key, data.api_key.split_once('.').unwrap().0);
reset_garrison_dao_for_test();
}
#[tokio::test(flavor = "multi_thread", worker_threads = 1)]
async fn test_create_api_key_default_expires_used_when_none() {
if skip_if_no_test_db() {
return;
}
let _guard = crate::infrastructure::auth::garrison_dao::test_mutex()
.lock()
.await;
reset_garrison_dao_for_test();
inject_test_garrison_dao().await;
if skip_if_no_test_db() {
return;
}
let auth_state = make_admin_auth_state();
let target_team_id = crate::domain::id::Id::generate();
seed_team_in_db(&auth_state.pool, target_team_id).await;
let req = CreateApiKeyRequest {
team_id: target_team_id,
scopes: vec!["read".to_string()],
expires_in_secs: None, };
let response = create_api_key(Extension(auth_state), Ok(Json(req)))
.await
.into_response();
assert_eq!(response.status(), StatusCode::CREATED);
reset_garrison_dao_for_test();
}
#[tokio::test(flavor = "multi_thread", worker_threads = 1)]
async fn test_create_api_key_admin_scope_single() {
if skip_if_no_test_db() {
return;
}
let _guard = crate::infrastructure::auth::garrison_dao::test_mutex()
.lock()
.await;
reset_garrison_dao_for_test();
inject_test_garrison_dao().await;
if skip_if_no_test_db() {
return;
}
let auth_state = make_admin_auth_state();
let target_team_id = crate::domain::id::Id::generate();
seed_team_in_db(&auth_state.pool, target_team_id).await;
let req = CreateApiKeyRequest {
team_id: target_team_id,
scopes: vec!["admin".to_string()],
expires_in_secs: Some(86400),
};
let response = create_api_key(Extension(auth_state), Ok(Json(req)))
.await
.into_response();
assert_eq!(response.status(), StatusCode::CREATED);
reset_garrison_dao_for_test();
}
#[tokio::test(flavor = "multi_thread", worker_threads = 1)]
async fn test_create_api_key_returns_distinct_keys_per_call() {
if skip_if_no_test_db() {
return;
}
let _guard = crate::infrastructure::auth::garrison_dao::test_mutex()
.lock()
.await;
reset_garrison_dao_for_test();
inject_test_garrison_dao().await;
if skip_if_no_test_db() {
return;
}
let auth_state = make_admin_auth_state();
let target_team_id = crate::domain::id::Id::generate();
seed_team_in_db(&auth_state.pool, target_team_id).await;
let req = CreateApiKeyRequest {
team_id: target_team_id,
scopes: vec!["read".to_string()],
expires_in_secs: Some(3600),
};
let resp1 = create_api_key(Extension(auth_state.clone()), Ok(Json(req.clone())))
.await
.into_response();
let resp2 = create_api_key(Extension(auth_state.clone()), Ok(Json(req)))
.await
.into_response();
assert_eq!(resp1.status(), StatusCode::CREATED);
assert_eq!(resp2.status(), StatusCode::CREATED);
let body1 = axum::body::to_bytes(resp1.into_body(), usize::MAX)
.await
.unwrap();
let body2 = axum::body::to_bytes(resp2.into_body(), usize::MAX)
.await
.unwrap();
let parsed1: ApiResponse<CreateApiKeyResponse> = serde_json::from_slice(&body1).unwrap();
let parsed2: ApiResponse<CreateApiKeyResponse> = serde_json::from_slice(&body2).unwrap();
assert_ne!(
parsed1.data.unwrap().api_key,
parsed2.data.unwrap().api_key,
"consecutive generate calls must return distinct keys"
);
reset_garrison_dao_for_test();
}
#[test]
fn test_garrison_namespace_value() {
assert_eq!(GARRISON_NAMESPACE, "crawlrs");
}
#[test]
fn test_default_expires_in_secs_value() {
assert_eq!(DEFAULT_EXPIRES_IN_SECS, 30 * 24 * 60 * 60);
}
#[test]
fn test_max_expires_in_secs_value() {
assert_eq!(MAX_EXPIRES_IN_SECS, 365 * 24 * 60 * 60);
}
#[test]
fn test_scope_constants() {
assert_eq!(SCOPE_READ, "read");
assert_eq!(SCOPE_WRITE, "write");
assert_eq!(SCOPE_ADMIN, "admin");
}
#[test]
fn test_create_api_key_request_deserialize_minimal() {
let json = r#"{"team_id":"550e8400-e29b-41d4-a716-446655440000","scopes":["read"]}"#;
let req: CreateApiKeyRequest = serde_json::from_str(json).unwrap();
assert_eq!(
req.team_id.to_string(),
"550e8400-e29b-41d4-a716-446655440000"
);
assert_eq!(req.scopes, vec!["read".to_string()]);
assert!(req.expires_in_secs.is_none());
}
#[test]
fn test_create_api_key_request_deserialize_full() {
let json = r#"{
"team_id":"550e8400-e29b-41d4-a716-446655440000",
"scopes":["read","write","admin"],
"expires_in_secs":7200
}"#;
let req: CreateApiKeyRequest = serde_json::from_str(json).unwrap();
assert_eq!(req.scopes.len(), 3);
assert_eq!(req.expires_in_secs, Some(7200));
}
#[test]
fn test_create_api_key_request_missing_team_id_fails() {
let json = r#"{"scopes":["read"]}"#;
let result: Result<CreateApiKeyRequest, _> = serde_json::from_str(json);
assert!(result.is_err());
}
#[test]
fn test_create_api_key_request_missing_scopes_fails() {
let json = r#"{"team_id":"550e8400-e29b-41d4-a716-446655440000"}"#;
let result: Result<CreateApiKeyRequest, _> = serde_json::from_str(json);
assert!(result.is_err());
}
#[test]
fn test_create_api_key_request_invalid_team_id_fails() {
let json = r#"{"team_id":"not-a-uuid","scopes":["read"]}"#;
let result: Result<CreateApiKeyRequest, _> = serde_json::from_str(json);
assert!(result.is_err());
}
#[test]
fn test_create_api_key_response_serialize() {
let resp = CreateApiKeyResponse {
api_key: "abc123.def456".to_string(),
api_key_id: crate::domain::id::Id::generate(),
team_id: crate::domain::id::Id::generate(),
scopes: vec!["read".to_string()],
expires_at: "2026-08-25T12:00:00Z".to_string(),
};
let json = serde_json::to_string(&resp).unwrap();
let parsed: serde_json::Value = serde_json::from_str(&json).unwrap();
assert_eq!(parsed["api_key"], "abc123.def456");
assert!(parsed["api_key_id"].is_string());
assert!(parsed["team_id"].is_string());
assert_eq!(parsed["scopes"][0], "read");
assert_eq!(parsed["expires_at"], "2026-08-25T12:00:00Z");
}
}