use crate::common::constants::server_config;
use crate::domain::auth::ScopePermission;
use crate::domain::services::audit_service::AuditServiceTrait;
use crate::i18n::{I18nBundle, Locale};
use crate::presentation::handlers::response_builder::{error_response, ApiResponse};
use crate::presentation::middleware::auth_middleware::AuthState;
use axum::{
extract::{Extension, Query},
http::StatusCode,
response::{IntoResponse, Response},
Json,
};
use serde::Deserialize;
use std::sync::Arc;
#[derive(Deserialize)]
pub struct AuditLogsQuery {
pub limit: Option<u64>,
pub offset: Option<u64>,
pub api_key_id: Option<crate::domain::id::Id>,
pub team_id: Option<crate::domain::id::Id>,
}
#[derive(Deserialize)]
pub struct DeniedRequestsQuery {
pub limit: Option<u64>,
}
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
pub struct AuditLogsResponseDto<T> {
pub logs: Vec<T>,
}
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
pub struct DeniedRequestsResponseDto<T> {
pub denied_requests: Vec<T>,
}
pub async fn get_audit_logs(
Extension(audit_service): Extension<Arc<dyn AuditServiceTrait>>,
Extension(auth_state): Extension<AuthState>,
Extension(locale): Extension<Locale>,
Extension(bundle): Extension<Arc<I18nBundle>>,
Query(query): Query<AuditLogsQuery>,
) -> impl IntoResponse {
let limit = query
.limit
.unwrap_or(server_config::DEFAULT_PAGE_LIMIT as u64)
.min(server_config::MAX_PAGE_LIMIT as u64);
let offset = query.offset.unwrap_or(0);
if let Some(response) = enforce_audit_scope(&query, &auth_state, &locale, &bundle) {
return response;
}
match query {
AuditLogsQuery {
api_key_id: Some(api_key_id),
..
} => logs_response(
audit_service
.get_logs_for_key(api_key_id, limit, offset)
.await,
),
AuditLogsQuery {
team_id: Some(team_id),
..
} => logs_response(
audit_service
.get_logs_for_team(team_id, limit, offset)
.await,
),
_ => logs_response(
audit_service
.get_logs_for_key(auth_state.api_key_id, limit, offset)
.await,
),
}
}
fn enforce_audit_scope(
query: &AuditLogsQuery,
auth_state: &AuthState,
locale: &Locale,
bundle: &I18nBundle,
) -> Option<Response> {
let is_admin = auth_state.scope.has_permission(ScopePermission::Admin);
if let Some(req_key_id) = query.api_key_id {
if req_key_id != auth_state.api_key_id && !is_admin {
return Some(error_response(
StatusCode::FORBIDDEN,
crate::i18n::t(locale, bundle, "api-insufficient-permissions-api-key"),
));
}
}
if let Some(req_team_id) = query.team_id {
if req_team_id != auth_state.team_id && !is_admin {
return Some(error_response(
StatusCode::FORBIDDEN,
crate::i18n::t(locale, bundle, "api-insufficient-permissions-team"),
));
}
}
None
}
fn logs_response<T, E>(result: Result<Vec<T>, E>) -> Response
where
T: serde::Serialize,
E: std::fmt::Display,
{
match result {
Ok(logs) => {
let response = AuditLogsResponseDto { logs };
(StatusCode::OK, Json(ApiResponse::success(response))).into_response()
}
Err(e) => error_response(StatusCode::INTERNAL_SERVER_ERROR, e.to_string()),
}
}
pub async fn get_denied_requests(
Extension(audit_service): Extension<Arc<dyn AuditServiceTrait>>,
Extension(auth_state): Extension<AuthState>,
Query(query): Query<DeniedRequestsQuery>,
) -> impl IntoResponse {
let limit = query
.limit
.unwrap_or(server_config::DEFAULT_PAGE_LIMIT as u64)
.min(server_config::MAX_PAGE_LIMIT as u64);
match audit_service
.get_denied_requests(auth_state.api_key_id, limit)
.await
{
Ok(logs) => {
let response = DeniedRequestsResponseDto {
denied_requests: logs,
};
(StatusCode::OK, Json(ApiResponse::success(response))).into_response()
}
Err(e) => error_response(StatusCode::INTERNAL_SERVER_ERROR, e.to_string()),
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_audit_logs_query_empty() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let query = serde_urlencoded::from_str::<AuditLogsQuery>("").unwrap();
assert!(query.limit.is_none());
assert!(query.offset.is_none());
assert!(query.api_key_id.is_none());
assert!(query.team_id.is_none());
}
#[test]
fn test_audit_logs_query_with_limit_and_offset() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let query_str = "limit=50&offset=100";
let query = serde_urlencoded::from_str::<AuditLogsQuery>(query_str).unwrap();
assert_eq!(query.limit, Some(50));
assert_eq!(query.offset, Some(100));
}
#[test]
fn test_audit_logs_query_with_api_key_id() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let uuid_str = "550e8400-e29b-41d4-a716-446655440000";
let query_str = format!("api_key_id={}", uuid_str);
let query = serde_urlencoded::from_str::<AuditLogsQuery>(&query_str).unwrap();
assert!(query.api_key_id.is_some());
assert_eq!(query.api_key_id.unwrap().to_string(), uuid_str);
}
#[test]
fn test_audit_logs_query_with_team_id() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let uuid_str = "550e8400-e29b-41d4-a716-446655440000";
let query_str = format!("team_id={}", uuid_str);
let query = serde_urlencoded::from_str::<AuditLogsQuery>(&query_str).unwrap();
assert!(query.team_id.is_some());
}
#[test]
fn test_audit_logs_query_with_all_params() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let uuid_str = "550e8400-e29b-41d4-a716-446655440000";
let query_str = format!(
"limit=10&offset=20&api_key_id={}&team_id={}",
uuid_str, uuid_str
);
let query = serde_urlencoded::from_str::<AuditLogsQuery>(&query_str).unwrap();
assert_eq!(query.limit, Some(10));
assert_eq!(query.offset, Some(20));
assert!(query.api_key_id.is_some());
assert!(query.team_id.is_some());
}
#[test]
fn test_audit_logs_query_invalid_uuid_fails() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let query_str = "api_key_id=not-a-uuid";
let result = serde_urlencoded::from_str::<AuditLogsQuery>(query_str);
assert!(result.is_err());
}
#[test]
fn test_audit_logs_query_invalid_limit_fails() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let query_str = "limit=abc";
let result = serde_urlencoded::from_str::<AuditLogsQuery>(query_str);
assert!(result.is_err());
}
#[test]
fn test_audit_logs_response_dto_empty() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let dto: AuditLogsResponseDto<serde_json::Value> = AuditLogsResponseDto { logs: vec![] };
let json = serde_json::to_string(&dto).unwrap();
let parsed: serde_json::Value = serde_json::from_str(&json).unwrap();
assert_eq!(parsed["logs"], serde_json::Value::Array(vec![]));
}
#[test]
fn test_audit_logs_response_dto_with_string_logs() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let dto: AuditLogsResponseDto<&str> = AuditLogsResponseDto {
logs: vec!["log entry 1", "log entry 2"],
};
let json = serde_json::to_string(&dto).unwrap();
let parsed: serde_json::Value = serde_json::from_str(&json).unwrap();
assert_eq!(parsed["logs"].as_array().unwrap().len(), 2);
assert_eq!(parsed["logs"][0], "log entry 1");
assert_eq!(parsed["logs"][1], "log entry 2");
}
#[test]
fn test_audit_logs_response_dto_with_json_logs() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let logs = vec![
serde_json::json!({"action": "read", "resource": "task"}),
serde_json::json!({"action": "write", "resource": "webhook"}),
];
let dto = AuditLogsResponseDto { logs };
let json = serde_json::to_string(&dto).unwrap();
let parsed: serde_json::Value = serde_json::from_str(&json).unwrap();
assert_eq!(parsed["logs"][0]["action"], "read");
assert_eq!(parsed["logs"][1]["action"], "write");
}
#[test]
fn test_denied_requests_response_dto_empty() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let dto: DeniedRequestsResponseDto<serde_json::Value> = DeniedRequestsResponseDto {
denied_requests: vec![],
};
let json = serde_json::to_string(&dto).unwrap();
let parsed: serde_json::Value = serde_json::from_str(&json).unwrap();
assert_eq!(parsed["denied_requests"], serde_json::Value::Array(vec![]));
}
#[test]
fn test_denied_requests_response_dto_with_entries() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let dto = DeniedRequestsResponseDto {
denied_requests: vec![
serde_json::json!({"reason": "rate limited", "ip": "1.2.3.4"}),
serde_json::json!({"reason": "forbidden", "ip": "5.6.7.8"}),
],
};
let json = serde_json::to_string(&dto).unwrap();
let parsed: serde_json::Value = serde_json::from_str(&json).unwrap();
assert_eq!(parsed["denied_requests"].as_array().unwrap().len(), 2);
assert_eq!(parsed["denied_requests"][0]["reason"], "rate limited");
assert_eq!(parsed["denied_requests"][1]["reason"], "forbidden");
}
#[test]
fn test_default_page_limit_value() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
assert_eq!(server_config::DEFAULT_PAGE_LIMIT, 100);
}
#[test]
fn test_max_page_limit_value() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
assert_eq!(server_config::MAX_PAGE_LIMIT, 1000);
}
#[test]
#[allow(clippy::assertions_on_constants)]
fn test_default_page_limit_less_than_max() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
assert!(server_config::DEFAULT_PAGE_LIMIT < server_config::MAX_PAGE_LIMIT);
}
use crate::common::test_helpers::create_test_db_pool;
use crate::domain::auth::ApiKeyScope;
use crate::domain::auth::{AuditDecision, AuditLogEntry};
use crate::domain::repositories::audit_log_repository::AuditRepositoryError;
use crate::domain::services::audit_service::{
AuditLogBuilder, AuditServiceError, AuditServiceTrait,
};
use crate::presentation::middleware::auth_middleware::AuthState;
use async_trait::async_trait;
use axum::response::IntoResponse;
use std::sync::Mutex;
fn make_auth_state() -> AuthState {
let pool = create_test_db_pool();
AuthState::new(
pool,
crate::domain::id::Id::generate(),
crate::domain::id::Id::generate(),
ApiKeyScope::default(),
)
}
fn test_locale() -> Locale {
"en-US".parse().unwrap()
}
fn test_bundle() -> Arc<I18nBundle> {
Arc::new(I18nBundle::load("en-US", &["en-US", "zh-CN"]).unwrap())
}
fn make_auth_state_with_key(api_key_id: crate::domain::id::Id) -> AuthState {
let pool = create_test_db_pool();
AuthState::new(
pool,
crate::domain::id::Id::generate(),
api_key_id,
ApiKeyScope::default(),
)
}
fn make_auth_state_with_team(team_id: crate::domain::id::Id) -> AuthState {
let pool = create_test_db_pool();
AuthState::new(
pool,
team_id,
crate::domain::id::Id::generate(),
ApiKeyScope::default(),
)
}
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 sample_entry(action: &str, decision: AuditDecision) -> AuditLogEntry {
AuditLogBuilder::new(action, decision)
.with_api_key_id(crate::domain::id::Id::generate())
.with_team_id(crate::domain::id::Id::generate())
.build()
}
struct MockAuditService {
logs: Mutex<Vec<AuditLogEntry>>,
should_fail: bool,
}
impl MockAuditService {
fn new(logs: Vec<AuditLogEntry>) -> Self {
Self {
logs: Mutex::new(logs),
should_fail: false,
}
}
fn failing() -> Self {
Self {
logs: Mutex::new(Vec::new()),
should_fail: true,
}
}
}
#[async_trait]
impl AuditServiceTrait for MockAuditService {
async fn log(&self, _entry: AuditLogEntry) -> Result<(), AuditServiceError> {
Ok(())
}
async fn log_allow(
&self,
_action: String,
_api_key_id: crate::domain::id::Id,
_team_id: crate::domain::id::Id,
_scope: ApiKeyScope,
) -> Result<(), AuditServiceError> {
Ok(())
}
async fn log_deny(
&self,
_action: String,
_api_key_id: Option<crate::domain::id::Id>,
_team_id: Option<crate::domain::id::Id>,
_reason: String,
_scope: Option<ApiKeyScope>,
) -> Result<(), AuditServiceError> {
Ok(())
}
async fn get_logs_for_key(
&self,
_api_key_id: crate::domain::id::Id,
_limit: u64,
_offset: u64,
) -> Result<Vec<AuditLogEntry>, AuditServiceError> {
if self.should_fail {
return Err(AuditServiceError::RepositoryError(
AuditRepositoryError::DatabaseError(
dbnexus::sea_orm::DbErr::Custom("mock error".to_string()).into(),
),
));
}
Ok(self.logs.lock().unwrap().clone())
}
async fn get_logs_for_team(
&self,
_team_id: crate::domain::id::Id,
_limit: u64,
_offset: u64,
) -> Result<Vec<AuditLogEntry>, AuditServiceError> {
if self.should_fail {
return Err(AuditServiceError::RepositoryError(
AuditRepositoryError::DatabaseError(
dbnexus::sea_orm::DbErr::Custom("mock error".to_string()).into(),
),
));
}
Ok(self.logs.lock().unwrap().clone())
}
async fn get_denied_requests(
&self,
_api_key_id: crate::domain::id::Id,
_limit: u64,
) -> Result<Vec<AuditLogEntry>, AuditServiceError> {
if self.should_fail {
return Err(AuditServiceError::RepositoryError(
AuditRepositoryError::DatabaseError(
dbnexus::sea_orm::DbErr::Custom("mock error".to_string()).into(),
),
));
}
Ok(self
.logs
.lock()
.unwrap()
.iter()
.filter(|e| e.decision == AuditDecision::Deny)
.cloned()
.collect())
}
}
#[test]
fn test_branch_selects_api_key_when_api_key_id_present() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let query = AuditLogsQuery {
limit: Some(10),
offset: Some(0),
api_key_id: Some(crate::domain::id::Id::generate()),
team_id: Some(crate::domain::id::Id::generate()),
};
assert!(query.api_key_id.is_some());
}
#[test]
fn test_branch_selects_team_when_only_team_id_present() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let query = AuditLogsQuery {
limit: Some(10),
offset: Some(0),
api_key_id: None,
team_id: Some(crate::domain::id::Id::generate()),
};
assert!(query.api_key_id.is_none());
assert!(query.team_id.is_some());
}
#[test]
fn test_branch_falls_back_to_auth_state_when_neither_present() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let query = AuditLogsQuery {
limit: Some(10),
offset: Some(0),
api_key_id: None,
team_id: None,
};
assert!(query.api_key_id.is_none());
assert!(query.team_id.is_none());
}
#[test]
fn test_branch_api_key_takes_priority_over_team_id() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let query = AuditLogsQuery {
limit: None,
offset: None,
api_key_id: Some(crate::domain::id::Id::generate()),
team_id: Some(crate::domain::id::Id::generate()),
};
match query {
AuditLogsQuery {
api_key_id: Some(_),
..
} => {}
AuditLogsQuery {
team_id: Some(_), ..
} => {
panic!("team_id branch should not be reached when api_key_id is Some");
}
_ => {
panic!("fallback branch should not be reached");
}
}
}
#[tokio::test]
async fn test_get_audit_logs_by_api_key_id() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let logs = vec![
sample_entry("search", AuditDecision::Allow),
sample_entry("scrape", AuditDecision::Allow),
];
let mock = Arc::new(MockAuditService::new(logs));
let api_key_id = crate::domain::id::Id::generate();
let auth_state = make_auth_state_with_key(api_key_id);
let query = AuditLogsQuery {
limit: Some(10),
offset: Some(0),
api_key_id: Some(api_key_id),
team_id: None,
};
let response = get_audit_logs(
Extension(mock),
Extension(auth_state),
Extension(test_locale()),
Extension(test_bundle()),
Query(query),
)
.await
.into_response();
assert_eq!(response.status(), StatusCode::OK);
}
#[tokio::test]
async fn test_get_audit_logs_by_team_id() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let logs = vec![sample_entry("crawl", AuditDecision::Allow)];
let mock = Arc::new(MockAuditService::new(logs));
let team_id = crate::domain::id::Id::generate();
let auth_state = make_auth_state_with_team(team_id);
let query = AuditLogsQuery {
limit: Some(50),
offset: None,
api_key_id: None,
team_id: Some(team_id),
};
let response = get_audit_logs(
Extension(mock),
Extension(auth_state),
Extension(test_locale()),
Extension(test_bundle()),
Query(query),
)
.await
.into_response();
assert_eq!(response.status(), StatusCode::OK);
}
#[tokio::test]
async fn test_get_audit_logs_fallback_to_auth_state_api_key() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let logs = vec![sample_entry("extract", AuditDecision::Allow)];
let mock = Arc::new(MockAuditService::new(logs));
let auth_state = make_auth_state();
let query = AuditLogsQuery {
limit: None,
offset: None,
api_key_id: None,
team_id: None,
};
let response = get_audit_logs(
Extension(mock),
Extension(auth_state),
Extension(test_locale()),
Extension(test_bundle()),
Query(query),
)
.await
.into_response();
assert_eq!(response.status(), StatusCode::OK);
}
#[tokio::test]
async fn test_get_audit_logs_api_key_takes_priority_over_team_id() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let logs = vec![sample_entry("search", AuditDecision::Allow)];
let mock = Arc::new(MockAuditService::new(logs));
let auth_state = make_admin_auth_state();
let query = AuditLogsQuery {
limit: Some(10),
offset: Some(0),
api_key_id: Some(crate::domain::id::Id::generate()),
team_id: Some(crate::domain::id::Id::generate()),
};
let response = get_audit_logs(
Extension(mock),
Extension(auth_state),
Extension(test_locale()),
Extension(test_bundle()),
Query(query),
)
.await
.into_response();
assert_eq!(response.status(), StatusCode::OK);
}
#[tokio::test]
async fn test_get_audit_logs_error_returns_internal_server_error() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let mock = Arc::new(MockAuditService::failing());
let auth_state = make_admin_auth_state();
let query = AuditLogsQuery {
limit: Some(10),
offset: Some(0),
api_key_id: Some(crate::domain::id::Id::generate()),
team_id: None,
};
let response = get_audit_logs(
Extension(mock),
Extension(auth_state),
Extension(test_locale()),
Extension(test_bundle()),
Query(query),
)
.await
.into_response();
assert_eq!(response.status(), StatusCode::INTERNAL_SERVER_ERROR);
}
#[tokio::test]
async fn test_get_audit_logs_error_on_team_branch() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let mock = Arc::new(MockAuditService::failing());
let auth_state = make_admin_auth_state();
let query = AuditLogsQuery {
limit: Some(10),
offset: Some(0),
api_key_id: None,
team_id: Some(crate::domain::id::Id::generate()),
};
let response = get_audit_logs(
Extension(mock),
Extension(auth_state),
Extension(test_locale()),
Extension(test_bundle()),
Query(query),
)
.await
.into_response();
assert_eq!(response.status(), StatusCode::INTERNAL_SERVER_ERROR);
}
#[tokio::test]
async fn test_get_audit_logs_error_on_fallback_branch() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let mock = Arc::new(MockAuditService::failing());
let auth_state = make_auth_state();
let query = AuditLogsQuery {
limit: None,
offset: None,
api_key_id: None,
team_id: None,
};
let response = get_audit_logs(
Extension(mock),
Extension(auth_state),
Extension(test_locale()),
Extension(test_bundle()),
Query(query),
)
.await
.into_response();
assert_eq!(response.status(), StatusCode::INTERNAL_SERVER_ERROR);
}
#[tokio::test]
async fn test_get_audit_logs_empty_logs() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let mock = Arc::new(MockAuditService::new(vec![]));
let auth_state = make_admin_auth_state();
let query = AuditLogsQuery {
limit: Some(10),
offset: Some(0),
api_key_id: Some(crate::domain::id::Id::generate()),
team_id: None,
};
let response = get_audit_logs(
Extension(mock),
Extension(auth_state),
Extension(test_locale()),
Extension(test_bundle()),
Query(query),
)
.await
.into_response();
assert_eq!(response.status(), StatusCode::OK);
}
#[tokio::test]
async fn test_get_audit_logs_limit_clamped_to_max() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let logs = vec![sample_entry("search", AuditDecision::Allow)];
let mock = Arc::new(MockAuditService::new(logs));
let auth_state = make_admin_auth_state();
let query = AuditLogsQuery {
limit: Some(50000),
offset: Some(0),
api_key_id: Some(crate::domain::id::Id::generate()),
team_id: None,
};
let response = get_audit_logs(
Extension(mock),
Extension(auth_state),
Extension(test_locale()),
Extension(test_bundle()),
Query(query),
)
.await
.into_response();
assert_eq!(response.status(), StatusCode::OK);
}
#[tokio::test]
async fn test_get_audit_logs_idor_blocks_other_api_key_id() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let logs = vec![sample_entry("search", AuditDecision::Allow)];
let mock = Arc::new(MockAuditService::new(logs));
let auth_state = make_auth_state();
let query = AuditLogsQuery {
limit: Some(10),
offset: Some(0),
api_key_id: Some(crate::domain::id::Id::generate()),
team_id: None,
};
let response = get_audit_logs(
Extension(mock),
Extension(auth_state),
Extension(test_locale()),
Extension(test_bundle()),
Query(query),
)
.await
.into_response();
assert_eq!(response.status(), StatusCode::FORBIDDEN);
}
#[tokio::test]
async fn test_get_audit_logs_idor_blocks_other_team_id() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let logs = vec![sample_entry("crawl", AuditDecision::Allow)];
let mock = Arc::new(MockAuditService::new(logs));
let auth_state = make_auth_state();
let query = AuditLogsQuery {
limit: Some(10),
offset: Some(0),
api_key_id: None,
team_id: Some(crate::domain::id::Id::generate()),
};
let response = get_audit_logs(
Extension(mock),
Extension(auth_state),
Extension(test_locale()),
Extension(test_bundle()),
Query(query),
)
.await
.into_response();
assert_eq!(response.status(), StatusCode::FORBIDDEN);
}
#[tokio::test]
async fn test_get_audit_logs_non_admin_can_query_own_api_key_id() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let logs = vec![sample_entry("search", AuditDecision::Allow)];
let mock = Arc::new(MockAuditService::new(logs));
let api_key_id = crate::domain::id::Id::generate();
let auth_state = make_auth_state_with_key(api_key_id);
let query = AuditLogsQuery {
limit: Some(10),
offset: Some(0),
api_key_id: Some(api_key_id),
team_id: None,
};
let response = get_audit_logs(
Extension(mock),
Extension(auth_state),
Extension(test_locale()),
Extension(test_bundle()),
Query(query),
)
.await
.into_response();
assert_eq!(response.status(), StatusCode::OK);
}
#[tokio::test]
async fn test_get_audit_logs_non_admin_can_query_own_team_id() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let logs = vec![sample_entry("crawl", AuditDecision::Allow)];
let mock = Arc::new(MockAuditService::new(logs));
let team_id = crate::domain::id::Id::generate();
let auth_state = make_auth_state_with_team(team_id);
let query = AuditLogsQuery {
limit: Some(10),
offset: Some(0),
api_key_id: None,
team_id: Some(team_id),
};
let response = get_audit_logs(
Extension(mock),
Extension(auth_state),
Extension(test_locale()),
Extension(test_bundle()),
Query(query),
)
.await
.into_response();
assert_eq!(response.status(), StatusCode::OK);
}
#[tokio::test]
async fn test_get_audit_logs_admin_can_query_other_api_key_id() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let logs = vec![sample_entry("search", AuditDecision::Allow)];
let mock = Arc::new(MockAuditService::new(logs));
let auth_state = make_admin_auth_state();
let query = AuditLogsQuery {
limit: Some(10),
offset: Some(0),
api_key_id: Some(crate::domain::id::Id::generate()),
team_id: None,
};
let response = get_audit_logs(
Extension(mock),
Extension(auth_state),
Extension(test_locale()),
Extension(test_bundle()),
Query(query),
)
.await
.into_response();
assert_eq!(response.status(), StatusCode::OK);
}
#[tokio::test]
async fn test_get_audit_logs_admin_can_query_other_team_id() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let logs = vec![sample_entry("crawl", AuditDecision::Allow)];
let mock = Arc::new(MockAuditService::new(logs));
let auth_state = make_admin_auth_state();
let query = AuditLogsQuery {
limit: Some(10),
offset: Some(0),
api_key_id: None,
team_id: Some(crate::domain::id::Id::generate()),
};
let response = get_audit_logs(
Extension(mock),
Extension(auth_state),
Extension(test_locale()),
Extension(test_bundle()),
Query(query),
)
.await
.into_response();
assert_eq!(response.status(), StatusCode::OK);
}
#[tokio::test]
async fn test_get_audit_logs_idor_combo_own_key_other_team() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let logs = vec![sample_entry("search", AuditDecision::Allow)];
let mock = Arc::new(MockAuditService::new(logs));
let api_key_id = crate::domain::id::Id::generate();
let auth_state = make_auth_state_with_key(api_key_id);
let query = AuditLogsQuery {
limit: Some(10),
offset: Some(0),
api_key_id: Some(api_key_id),
team_id: Some(crate::domain::id::Id::generate()),
};
let response = get_audit_logs(
Extension(mock),
Extension(auth_state),
Extension(test_locale()),
Extension(test_bundle()),
Query(query),
)
.await
.into_response();
assert_eq!(response.status(), StatusCode::FORBIDDEN);
}
#[tokio::test]
async fn test_get_denied_requests_success() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let denied = vec![
sample_entry("search", AuditDecision::Deny),
sample_entry("scrape", AuditDecision::Deny),
];
let mock = Arc::new(MockAuditService::new(denied));
let auth_state = make_auth_state();
let query = DeniedRequestsQuery { limit: Some(10) };
let response = get_denied_requests(Extension(mock), Extension(auth_state), Query(query))
.await
.into_response();
assert_eq!(response.status(), StatusCode::OK);
}
#[tokio::test]
async fn test_get_denied_requests_error_returns_internal_server_error() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let mock = Arc::new(MockAuditService::failing());
let auth_state = make_auth_state();
let query = DeniedRequestsQuery { limit: Some(10) };
let response = get_denied_requests(Extension(mock), Extension(auth_state), Query(query))
.await
.into_response();
assert_eq!(response.status(), StatusCode::INTERNAL_SERVER_ERROR);
}
#[tokio::test]
async fn test_get_denied_requests_empty() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let mock = Arc::new(MockAuditService::new(vec![]));
let auth_state = make_auth_state();
let query = DeniedRequestsQuery { limit: Some(10) };
let response = get_denied_requests(Extension(mock), Extension(auth_state), Query(query))
.await
.into_response();
assert_eq!(response.status(), StatusCode::OK);
}
#[tokio::test]
async fn test_get_denied_requests_limit_clamped() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let denied = vec![sample_entry("search", AuditDecision::Deny)];
let mock = Arc::new(MockAuditService::new(denied));
let auth_state = make_auth_state();
let query = DeniedRequestsQuery { limit: Some(99999) };
let response = get_denied_requests(Extension(mock), Extension(auth_state), Query(query))
.await
.into_response();
assert_eq!(response.status(), StatusCode::OK);
}
#[tokio::test]
async fn test_get_denied_requests_uses_auth_state_api_key_id() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let api_key_id = crate::domain::id::Id::generate();
let denied = vec![sample_entry("search", AuditDecision::Deny)];
let mock = Arc::new(MockAuditService::new(denied));
let auth_state = make_auth_state_with_key(api_key_id);
let query = DeniedRequestsQuery { limit: Some(10) };
let response = get_denied_requests(Extension(mock), Extension(auth_state), Query(query))
.await
.into_response();
assert_eq!(response.status(), StatusCode::OK);
}
#[tokio::test]
async fn test_get_denied_requests_with_allow_entries_filters() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let entries = vec![
sample_entry("search", AuditDecision::Deny),
sample_entry("search", AuditDecision::Allow),
sample_entry("crawl", AuditDecision::Deny),
];
let mock = Arc::new(MockAuditService::new(entries));
let auth_state = make_auth_state();
let query = DeniedRequestsQuery { limit: Some(10) };
let response = get_denied_requests(Extension(mock), Extension(auth_state), Query(query))
.await
.into_response();
assert_eq!(response.status(), StatusCode::OK);
}
}