use axum::{
http::StatusCode,
response::{IntoResponse, Response},
Json,
};
use serde::{Deserialize, Serialize};
use std::sync::Arc;
use crate::i18n::{I18nBundle, Locale};
#[derive(Debug, Serialize, Deserialize)]
pub struct ApiResponse<T> {
pub success: bool,
pub data: Option<T>,
#[serde(skip_serializing_if = "Option::is_none")]
pub error: Option<ApiError>,
#[serde(skip_serializing_if = "Option::is_none")]
pub meta: Option<PaginationMeta>,
#[serde(skip_serializing_if = "Option::is_none")]
pub timestamp: Option<String>,
}
impl<T> ApiResponse<T> {
pub fn success(data: T) -> Self {
Self {
success: true,
data: Some(data),
error: None,
meta: None,
timestamp: Some(chrono::Utc::now().to_rfc3339()),
}
}
pub fn success_with_meta(data: T, meta: PaginationMeta) -> Self {
Self {
success: true,
data: Some(data),
error: None,
meta: Some(meta),
timestamp: Some(chrono::Utc::now().to_rfc3339()),
}
}
pub fn error(code: impl Into<String>, message: impl Into<String>) -> Self {
Self {
success: false,
data: None,
error: Some(ApiError {
code: code.into(),
message: message.into(),
}),
meta: None,
timestamp: Some(chrono::Utc::now().to_rfc3339()),
}
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PaginationMeta {
pub page: u32,
pub per_page: u32,
pub total_items: u64,
pub total_pages: u32,
pub has_next: bool,
pub has_previous: bool,
}
impl PaginationMeta {
pub fn new(page: u32, per_page: u32, total_items: u64) -> Self {
let total_pages = if total_items == 0 {
0
} else {
total_items.div_ceil(per_page as u64) as u32
};
Self {
page,
per_page,
total_items,
total_pages,
has_next: page < total_pages,
has_previous: page > 1,
}
}
pub fn offset(&self) -> u64 {
((self.page - 1) * self.per_page) as u64
}
pub fn limit(&self) -> u32 {
self.per_page
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ApiError {
pub code: String,
pub message: String,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RateLimitErrorResponse {
pub success: bool,
pub error: ApiError,
pub retry_after_seconds: u64,
#[serde(skip_serializing_if = "Option::is_none")]
pub timestamp: Option<String>,
}
impl RateLimitErrorResponse {
pub fn new(message: impl Into<String>, retry_after_seconds: u64) -> Self {
Self {
success: false,
error: ApiError {
code: error_codes::RATE_LIMITED.to_string(),
message: message.into(),
},
retry_after_seconds,
timestamp: Some(chrono::Utc::now().to_rfc3339()),
}
}
}
impl<T: Serialize> IntoResponse for ApiResponse<T> {
fn into_response(self) -> Response {
let status = if self.success {
StatusCode::OK
} else {
match self.error.as_ref().map(|e| e.code.as_str()) {
Some("VALIDATION_ERROR") => StatusCode::BAD_REQUEST,
Some("NOT_FOUND") => StatusCode::NOT_FOUND,
Some("UNAUTHORIZED") => StatusCode::UNAUTHORIZED,
Some("FORBIDDEN") => StatusCode::FORBIDDEN,
Some("RATE_LIMITED") => StatusCode::TOO_MANY_REQUESTS,
Some("CONFLICT") => StatusCode::CONFLICT,
Some("PRECONDITION_FAILED") => StatusCode::PRECONDITION_FAILED,
Some("UNPROCESSABLE_ENTITY") => StatusCode::UNPROCESSABLE_ENTITY,
_ => StatusCode::INTERNAL_SERVER_ERROR,
}
};
(status, Json(self)).into_response()
}
}
#[inline]
pub fn error_response(status: StatusCode, message: impl Into<String>) -> Response {
let code = match status {
StatusCode::BAD_REQUEST => error_codes::VALIDATION_ERROR,
StatusCode::NOT_FOUND => error_codes::NOT_FOUND,
StatusCode::UNAUTHORIZED => error_codes::UNAUTHORIZED,
StatusCode::FORBIDDEN => error_codes::FORBIDDEN,
StatusCode::TOO_MANY_REQUESTS => error_codes::RATE_LIMITED,
StatusCode::CONFLICT => error_codes::CONFLICT,
StatusCode::PRECONDITION_FAILED => error_codes::PRECONDITION_FAILED,
StatusCode::UNPROCESSABLE_ENTITY => error_codes::UNPROCESSABLE_ENTITY,
StatusCode::SERVICE_UNAVAILABLE => error_codes::SERVICE_UNAVAILABLE,
StatusCode::PAYMENT_REQUIRED => error_codes::QUOTA_EXCEEDED,
_ => error_codes::INTERNAL_ERROR,
};
let response: ApiResponse<()> = ApiResponse::error(code, message);
(status, Json(response)).into_response()
}
#[inline]
pub fn error_response_with_code(
status: StatusCode,
code: impl Into<String>,
message: impl Into<String>,
) -> Response {
let response: ApiResponse<()> = ApiResponse::error(code, message);
(status, Json(response)).into_response()
}
#[inline]
pub fn success_response<T: serde::Serialize>(status: StatusCode, data: T) -> Response {
(status, Json(ApiResponse::success(data))).into_response()
}
#[inline]
pub fn success_response_with_meta<T: serde::Serialize>(
status: StatusCode,
data: T,
meta: PaginationMeta,
) -> Response {
(status, Json(ApiResponse::success_with_meta(data, meta))).into_response()
}
pub mod errors {
use super::*;
#[inline]
pub fn internal_server_error(message: impl Into<String>) -> Response {
error_response(StatusCode::INTERNAL_SERVER_ERROR, message)
}
#[inline]
pub fn bad_request(message: impl Into<String>) -> Response {
error_response(StatusCode::BAD_REQUEST, message)
}
#[inline]
pub fn not_found(message: impl Into<String>) -> Response {
error_response(StatusCode::NOT_FOUND, message)
}
#[inline]
pub fn forbidden(message: impl Into<String>) -> Response {
error_response(StatusCode::FORBIDDEN, message)
}
#[inline]
pub fn unauthorized(message: impl Into<String>) -> Response {
error_response(StatusCode::UNAUTHORIZED, message)
}
#[inline]
pub fn too_many_requests(message: impl Into<String>) -> Response {
error_response(StatusCode::TOO_MANY_REQUESTS, message)
}
#[inline]
pub fn too_many_requests_with_retry(
message: impl Into<String>,
retry_after_seconds: u64,
) -> Response {
(
StatusCode::TOO_MANY_REQUESTS,
Json(RateLimitErrorResponse::new(message, retry_after_seconds)),
)
.into_response()
}
#[inline]
pub fn unprocessable_entity(message: impl Into<String>) -> Response {
error_response(StatusCode::UNPROCESSABLE_ENTITY, message)
}
#[inline]
pub fn service_unavailable(message: impl Into<String>) -> Response {
error_response(StatusCode::SERVICE_UNAVAILABLE, message)
}
#[inline]
pub fn payment_required(message: impl Into<String>) -> Response {
error_response(StatusCode::PAYMENT_REQUIRED, message)
}
}
#[inline]
pub fn validation_error(message: impl Into<String>) -> Response {
error_response(
StatusCode::BAD_REQUEST,
format!("Validation error: {}", message.into()),
)
}
pub fn json_rejection_response(rejection: &axum::extract::rejection::JsonRejection) -> Response {
use axum::extract::rejection::JsonRejection;
match rejection {
JsonRejection::JsonDataError(err) => error_response_with_code(
StatusCode::UNPROCESSABLE_ENTITY,
error_codes::UNPROCESSABLE_ENTITY,
err.body_text(),
),
JsonRejection::JsonSyntaxError(err) => error_response_with_code(
StatusCode::BAD_REQUEST,
error_codes::VALIDATION_ERROR,
err.body_text(),
),
JsonRejection::MissingJsonContentType(err) => (
StatusCode::UNSUPPORTED_MEDIA_TYPE,
Json(ApiResponse::<()>::error(
error_codes::VALIDATION_ERROR,
err.body_text(),
)),
)
.into_response(),
_ => error_response_with_code(
StatusCode::BAD_REQUEST,
error_codes::VALIDATION_ERROR,
rejection.body_text(),
),
}
}
pub fn json_rejection_error(
rejection: axum::extract::rejection::JsonRejection,
) -> crate::common::error::CrawlRsError {
use axum::extract::rejection::JsonRejection;
match rejection {
JsonRejection::JsonDataError(err) => {
crate::common::error::CrawlRsError::Unprocessable(err.body_text())
}
_ => crate::common::error::CrawlRsError::Validation(rejection.body_text()),
}
}
#[inline]
pub fn resource_not_found(resource: impl Into<String>) -> Response {
errors::not_found(format!("{} not found", resource.into()))
}
#[inline]
pub fn access_denied() -> Response {
errors::forbidden("Access denied")
}
#[inline]
pub fn error_response_locale(
status: StatusCode,
locale: &Locale,
bundle: &Arc<I18nBundle>,
key: &str,
) -> Response {
let message = crate::i18n::t(locale, bundle, key);
error_response(status, message)
}
#[inline]
pub fn error_response_locale_with_args(
status: StatusCode,
locale: &Locale,
bundle: &Arc<I18nBundle>,
key: &str,
args: &[(&str, String)],
) -> Response {
let message = crate::i18n::t_with_args(locale, bundle, key, args);
error_response(status, message)
}
pub mod errors_locale {
use super::*;
#[inline]
pub fn forbidden(locale: &Locale, bundle: &Arc<I18nBundle>, key: &str) -> Response {
let message = crate::i18n::t(locale, bundle, key);
errors::forbidden(message)
}
#[inline]
pub fn not_found(locale: &Locale, bundle: &Arc<I18nBundle>, key: &str) -> Response {
let message = crate::i18n::t(locale, bundle, key);
errors::not_found(message)
}
#[inline]
pub fn internal_server_error(locale: &Locale, bundle: &Arc<I18nBundle>, key: &str) -> Response {
let message = crate::i18n::t(locale, bundle, key);
errors::internal_server_error(message)
}
#[inline]
pub fn too_many_requests(locale: &Locale, bundle: &Arc<I18nBundle>, key: &str) -> Response {
let message = crate::i18n::t(locale, bundle, key);
errors::too_many_requests(message)
}
#[inline]
pub fn bad_request(locale: &Locale, bundle: &Arc<I18nBundle>, key: &str) -> Response {
let message = crate::i18n::t(locale, bundle, key);
errors::bad_request(message)
}
}
pub mod error_codes {
pub const VALIDATION_ERROR: &str = "VALIDATION_ERROR";
pub const NOT_FOUND: &str = "NOT_FOUND";
pub const UNAUTHORIZED: &str = "UNAUTHORIZED";
pub const FORBIDDEN: &str = "FORBIDDEN";
pub const RATE_LIMITED: &str = "RATE_LIMITED";
pub const CONFLICT: &str = "CONFLICT";
pub const PRECONDITION_FAILED: &str = "PRECONDITION_FAILED";
pub const UNPROCESSABLE_ENTITY: &str = "UNPROCESSABLE_ENTITY";
pub const INTERNAL_ERROR: &str = "INTERNAL_ERROR";
pub const SERVICE_UNAVAILABLE: &str = "SERVICE_UNAVAILABLE";
pub const DATABASE_ERROR: &str = "DATABASE_ERROR";
pub const CACHE_ERROR: &str = "CACHE_ERROR";
pub const EXTERNAL_SERVICE_ERROR: &str = "EXTERNAL_SERVICE_ERROR";
pub const TIMEOUT: &str = "TIMEOUT";
pub const QUOTA_EXCEEDED: &str = "QUOTA_EXCEEDED";
pub const FEATURE_DISABLED: &str = "FEATURE_DISABLED";
}
pub fn validation_error_message(errors: &sdforge::validator::ValidationErrors) -> String {
let mut parts: Vec<String> = Vec::new();
for (field, errs) in errors.field_errors() {
let codes: Vec<String> = errs.iter().map(|e| e.code.to_string()).collect();
if codes.is_empty() {
parts.push(field.to_string());
} else {
parts.push(format!("{} ({})", field, codes.join(",")));
}
}
parts.sort();
if parts.is_empty() {
"Validation failed".to_string()
} else {
format!("Validation failed - {}", parts.join("; "))
}
}
#[cfg(test)]
mod tests {
use super::*;
use chrono::DateTime as ChronoDateTime;
#[test]
fn test_api_response_success_has_timestamp() {
let response = ApiResponse::success("test data");
assert!(response.success);
assert_eq!(response.data, Some("test data"));
assert!(response.timestamp.is_some());
let ts = response.timestamp.unwrap();
assert!(ts.contains('-'));
assert!(ts.contains(':'));
}
#[test]
fn test_api_response_error_has_timestamp() {
let response: ApiResponse<()> = ApiResponse::error("TEST_ERROR", "Test error message");
assert!(!response.success);
assert!(response.error.is_some());
assert_eq!(response.error.as_ref().unwrap().code, "TEST_ERROR");
assert!(response.timestamp.is_some());
}
#[test]
fn test_api_response_success_with_meta_has_timestamp() {
let meta = PaginationMeta::new(1, 10, 100);
let response = ApiResponse::success_with_meta("data", meta);
assert!(response.success);
assert!(response.meta.is_some());
assert!(response.timestamp.is_some());
}
#[test]
fn test_timestamp_is_recent() {
use chrono::Utc;
let response = ApiResponse::success("test");
let ts_str = response.timestamp.unwrap();
let parsed = ChronoDateTime::parse_from_rfc3339(&ts_str).unwrap();
let now = Utc::now();
let diff = (now.timestamp() - parsed.timestamp()).abs();
assert!(diff < 2);
}
#[test]
fn test_pagination_meta_new_with_zero_items() {
let meta = PaginationMeta::new(1, 10, 0);
assert_eq!(meta.page, 1);
assert_eq!(meta.per_page, 10);
assert_eq!(meta.total_items, 0);
assert_eq!(meta.total_pages, 0);
assert!(!meta.has_next);
assert!(!meta.has_previous);
}
#[test]
fn test_pagination_meta_new_exact_pages() {
let meta = PaginationMeta::new(1, 10, 100);
assert_eq!(meta.total_pages, 10);
assert!(meta.has_next);
assert!(!meta.has_previous);
}
#[test]
fn test_pagination_meta_new_partial_last_page() {
let meta = PaginationMeta::new(1, 10, 95);
assert_eq!(meta.total_pages, 10);
}
#[test]
fn test_pagination_meta_has_next_false_on_last_page() {
let meta = PaginationMeta::new(10, 10, 100);
assert_eq!(meta.total_pages, 10);
assert!(!meta.has_next);
assert!(meta.has_previous);
}
#[test]
fn test_pagination_meta_has_previous_false_on_first_page() {
let meta = PaginationMeta::new(1, 10, 100);
assert!(!meta.has_previous);
}
#[test]
fn test_pagination_meta_has_previous_true_on_page_two() {
let meta = PaginationMeta::new(2, 10, 100);
assert!(meta.has_previous);
}
#[test]
fn test_pagination_meta_offset_first_page() {
let meta = PaginationMeta::new(1, 10, 100);
assert_eq!(meta.offset(), 0);
}
#[test]
fn test_pagination_meta_offset_second_page() {
let meta = PaginationMeta::new(2, 10, 100);
assert_eq!(meta.offset(), 10);
}
#[test]
fn test_pagination_meta_offset_third_page() {
let meta = PaginationMeta::new(3, 20, 100);
assert_eq!(meta.offset(), 40);
}
#[test]
fn test_pagination_meta_limit_equals_per_page() {
let meta = PaginationMeta::new(1, 25, 100);
assert_eq!(meta.limit(), 25);
}
#[test]
fn test_pagination_meta_div_ceil_one_item_one_per_page() {
let meta = PaginationMeta::new(1, 1, 1);
assert_eq!(meta.total_pages, 1);
assert!(!meta.has_next);
}
#[tokio::test]
async fn test_into_response_success_returns_200() {
let response = ApiResponse::success("data");
let http_response = response.into_response();
assert_eq!(http_response.status(), StatusCode::OK);
}
#[tokio::test]
async fn test_into_response_validation_error_returns_400() {
let response: ApiResponse<()> = ApiResponse::error("VALIDATION_ERROR", "bad input");
let http_response = response.into_response();
assert_eq!(http_response.status(), StatusCode::BAD_REQUEST);
}
#[tokio::test]
async fn test_into_response_not_found_returns_404() {
let response: ApiResponse<()> = ApiResponse::error("NOT_FOUND", "missing");
let http_response = response.into_response();
assert_eq!(http_response.status(), StatusCode::NOT_FOUND);
}
#[tokio::test]
async fn test_into_response_unauthorized_returns_401() {
let response: ApiResponse<()> = ApiResponse::error("UNAUTHORIZED", "no auth");
let http_response = response.into_response();
assert_eq!(http_response.status(), StatusCode::UNAUTHORIZED);
}
#[tokio::test]
async fn test_into_response_forbidden_returns_403() {
let response: ApiResponse<()> = ApiResponse::error("FORBIDDEN", "denied");
let http_response = response.into_response();
assert_eq!(http_response.status(), StatusCode::FORBIDDEN);
}
#[tokio::test]
async fn test_into_response_rate_limited_returns_429() {
let response: ApiResponse<()> = ApiResponse::error("RATE_LIMITED", "slow down");
let http_response = response.into_response();
assert_eq!(http_response.status(), StatusCode::TOO_MANY_REQUESTS);
}
#[tokio::test]
async fn test_into_response_conflict_returns_409() {
let response: ApiResponse<()> = ApiResponse::error("CONFLICT", "dup");
let http_response = response.into_response();
assert_eq!(http_response.status(), StatusCode::CONFLICT);
}
#[tokio::test]
async fn test_into_response_precondition_failed_returns_412() {
let response: ApiResponse<()> = ApiResponse::error("PRECONDITION_FAILED", "precond");
let http_response = response.into_response();
assert_eq!(http_response.status(), StatusCode::PRECONDITION_FAILED);
}
#[tokio::test]
async fn test_into_response_unprocessable_entity_returns_422() {
let response: ApiResponse<()> = ApiResponse::error("UNPROCESSABLE_ENTITY", "unprocessable");
let http_response = response.into_response();
assert_eq!(http_response.status(), StatusCode::UNPROCESSABLE_ENTITY);
}
#[tokio::test]
async fn test_into_response_unknown_code_returns_500() {
let response: ApiResponse<()> = ApiResponse::error("UNKNOWN_CODE", "oops");
let http_response = response.into_response();
assert_eq!(http_response.status(), StatusCode::INTERNAL_SERVER_ERROR);
}
#[tokio::test]
async fn test_into_response_error_no_error_field_returns_500() {
let response: ApiResponse<()> = ApiResponse {
success: false,
data: None,
error: None,
meta: None,
timestamp: Some(chrono::Utc::now().to_rfc3339()),
};
let http_response = response.into_response();
assert_eq!(http_response.status(), StatusCode::INTERNAL_SERVER_ERROR);
}
#[tokio::test]
async fn test_success_response_json_structure() {
let response = ApiResponse::success("hello");
let http_response = response.into_response();
let bytes = axum::body::to_bytes(http_response.into_body(), usize::MAX)
.await
.unwrap();
let json: serde_json::Value = serde_json::from_slice(&bytes).unwrap();
assert_eq!(json["success"], serde_json::Value::Bool(true));
assert_eq!(json["data"], serde_json::Value::String("hello".to_string()));
assert!(json.get("error").is_none() || json["error"].is_null());
assert!(json.get("meta").is_none() || json["meta"].is_null());
assert!(json["timestamp"].is_string());
}
#[tokio::test]
async fn test_error_response_json_structure() {
let response: ApiResponse<()> = ApiResponse::error("NOT_FOUND", "not here");
let http_response = response.into_response();
let bytes = axum::body::to_bytes(http_response.into_body(), usize::MAX)
.await
.unwrap();
let json: serde_json::Value = serde_json::from_slice(&bytes).unwrap();
assert_eq!(json["success"], serde_json::Value::Bool(false));
assert!(json.get("data").is_none() || json["data"].is_null());
assert_eq!(json["error"]["code"], "NOT_FOUND");
assert_eq!(json["error"]["message"], "not here");
}
#[tokio::test]
async fn test_success_with_meta_json_includes_meta() {
let meta = PaginationMeta::new(2, 10, 55);
let response = ApiResponse::success_with_meta(vec!["a", "b"], meta);
let http_response = response.into_response();
let bytes = axum::body::to_bytes(http_response.into_body(), usize::MAX)
.await
.unwrap();
let json: serde_json::Value = serde_json::from_slice(&bytes).unwrap();
assert_eq!(json["meta"]["page"], 2);
assert_eq!(json["meta"]["per_page"], 10);
assert_eq!(json["meta"]["total_items"], 55);
assert_eq!(json["meta"]["total_pages"], 6);
assert_eq!(json["meta"]["has_next"], true);
assert_eq!(json["meta"]["has_previous"], true);
}
#[tokio::test]
async fn test_error_response_bad_request() {
let response = error_response(StatusCode::BAD_REQUEST, "bad data");
assert_eq!(response.status(), StatusCode::BAD_REQUEST);
let bytes = axum::body::to_bytes(response.into_body(), usize::MAX)
.await
.unwrap();
let json: serde_json::Value = serde_json::from_slice(&bytes).unwrap();
assert_eq!(json["success"], false);
assert_eq!(json["error"]["code"], "VALIDATION_ERROR");
assert_eq!(json["error"]["message"], "bad data");
}
#[tokio::test]
async fn test_error_response_not_found() {
let response = error_response(StatusCode::NOT_FOUND, "missing");
assert_eq!(response.status(), StatusCode::NOT_FOUND);
let bytes = axum::body::to_bytes(response.into_body(), usize::MAX)
.await
.unwrap();
let json: serde_json::Value = serde_json::from_slice(&bytes).unwrap();
assert_eq!(json["error"]["code"], "NOT_FOUND");
}
#[tokio::test]
async fn test_error_response_unauthorized() {
let response = error_response(StatusCode::UNAUTHORIZED, "no token");
assert_eq!(response.status(), StatusCode::UNAUTHORIZED);
let bytes = axum::body::to_bytes(response.into_body(), usize::MAX)
.await
.unwrap();
let json: serde_json::Value = serde_json::from_slice(&bytes).unwrap();
assert_eq!(json["error"]["code"], "UNAUTHORIZED");
}
#[tokio::test]
async fn test_error_response_forbidden() {
let response = error_response(StatusCode::FORBIDDEN, "denied");
assert_eq!(response.status(), StatusCode::FORBIDDEN);
let bytes = axum::body::to_bytes(response.into_body(), usize::MAX)
.await
.unwrap();
let json: serde_json::Value = serde_json::from_slice(&bytes).unwrap();
assert_eq!(json["error"]["code"], "FORBIDDEN");
}
#[tokio::test]
async fn test_error_response_too_many_requests() {
let response = error_response(StatusCode::TOO_MANY_REQUESTS, "slow");
assert_eq!(response.status(), StatusCode::TOO_MANY_REQUESTS);
let bytes = axum::body::to_bytes(response.into_body(), usize::MAX)
.await
.unwrap();
let json: serde_json::Value = serde_json::from_slice(&bytes).unwrap();
assert_eq!(json["error"]["code"], "RATE_LIMITED");
}
#[tokio::test]
async fn test_error_response_conflict() {
let response = error_response(StatusCode::CONFLICT, "dup");
assert_eq!(response.status(), StatusCode::CONFLICT);
let bytes = axum::body::to_bytes(response.into_body(), usize::MAX)
.await
.unwrap();
let json: serde_json::Value = serde_json::from_slice(&bytes).unwrap();
assert_eq!(json["error"]["code"], "CONFLICT");
}
#[tokio::test]
async fn test_error_response_precondition_failed() {
let response = error_response(StatusCode::PRECONDITION_FAILED, "precond");
assert_eq!(response.status(), StatusCode::PRECONDITION_FAILED);
let bytes = axum::body::to_bytes(response.into_body(), usize::MAX)
.await
.unwrap();
let json: serde_json::Value = serde_json::from_slice(&bytes).unwrap();
assert_eq!(json["error"]["code"], "PRECONDITION_FAILED");
}
#[tokio::test]
async fn test_error_response_unprocessable_entity() {
let response = error_response(StatusCode::UNPROCESSABLE_ENTITY, "unprocessable");
assert_eq!(response.status(), StatusCode::UNPROCESSABLE_ENTITY);
let bytes = axum::body::to_bytes(response.into_body(), usize::MAX)
.await
.unwrap();
let json: serde_json::Value = serde_json::from_slice(&bytes).unwrap();
assert_eq!(json["error"]["code"], "UNPROCESSABLE_ENTITY");
}
#[tokio::test]
async fn test_error_response_service_unavailable() {
let response = error_response(StatusCode::SERVICE_UNAVAILABLE, "down");
assert_eq!(response.status(), StatusCode::SERVICE_UNAVAILABLE);
let bytes = axum::body::to_bytes(response.into_body(), usize::MAX)
.await
.unwrap();
let json: serde_json::Value = serde_json::from_slice(&bytes).unwrap();
assert_eq!(json["error"]["code"], "SERVICE_UNAVAILABLE");
}
#[tokio::test]
async fn test_error_response_payment_required() {
let response = error_response(StatusCode::PAYMENT_REQUIRED, "pay up");
assert_eq!(response.status(), StatusCode::PAYMENT_REQUIRED);
let bytes = axum::body::to_bytes(response.into_body(), usize::MAX)
.await
.unwrap();
let json: serde_json::Value = serde_json::from_slice(&bytes).unwrap();
assert_eq!(json["error"]["code"], "QUOTA_EXCEEDED");
}
#[tokio::test]
async fn test_error_response_internal_error_default() {
let response = error_response(StatusCode::INTERNAL_SERVER_ERROR, "boom");
assert_eq!(response.status(), StatusCode::INTERNAL_SERVER_ERROR);
let bytes = axum::body::to_bytes(response.into_body(), usize::MAX)
.await
.unwrap();
let json: serde_json::Value = serde_json::from_slice(&bytes).unwrap();
assert_eq!(json["error"]["code"], "INTERNAL_ERROR");
}
#[tokio::test]
async fn test_error_response_with_code_custom() {
let response =
error_response_with_code(StatusCode::BAD_REQUEST, "CUSTOM_CODE", "custom msg");
assert_eq!(response.status(), StatusCode::BAD_REQUEST);
let bytes = axum::body::to_bytes(response.into_body(), usize::MAX)
.await
.unwrap();
let json: serde_json::Value = serde_json::from_slice(&bytes).unwrap();
assert_eq!(json["error"]["code"], "CUSTOM_CODE");
assert_eq!(json["error"]["message"], "custom msg");
}
#[tokio::test]
async fn test_error_response_with_code_preserves_status() {
let response =
error_response_with_code(StatusCode::NOT_FOUND, "CUSTOM_404", "not found custom");
assert_eq!(response.status(), StatusCode::NOT_FOUND);
}
#[tokio::test]
async fn test_success_response_with_data() {
let response = success_response(StatusCode::OK, vec!["a", "b"]);
assert_eq!(response.status(), StatusCode::OK);
let bytes = axum::body::to_bytes(response.into_body(), usize::MAX)
.await
.unwrap();
let json: serde_json::Value = serde_json::from_slice(&bytes).unwrap();
assert_eq!(json["success"], true);
assert_eq!(json["data"], serde_json::json!(["a", "b"]));
}
#[tokio::test]
async fn test_success_response_with_created_status() {
let response = success_response(StatusCode::CREATED, "created");
assert_eq!(response.status(), StatusCode::CREATED);
let bytes = axum::body::to_bytes(response.into_body(), usize::MAX)
.await
.unwrap();
let json: serde_json::Value = serde_json::from_slice(&bytes).unwrap();
assert_eq!(json["data"], "created");
}
#[tokio::test]
async fn test_success_response_with_meta_includes_pagination() {
let meta = PaginationMeta::new(1, 5, 12);
let response = success_response_with_meta(StatusCode::OK, vec![1, 2, 3, 4, 5], meta);
assert_eq!(response.status(), StatusCode::OK);
let bytes = axum::body::to_bytes(response.into_body(), usize::MAX)
.await
.unwrap();
let json: serde_json::Value = serde_json::from_slice(&bytes).unwrap();
assert_eq!(json["meta"]["total_pages"], 3);
assert_eq!(json["meta"]["has_next"], true);
assert_eq!(json["data"], serde_json::json!([1, 2, 3, 4, 5]));
}
#[tokio::test]
async fn test_errors_internal_server_error() {
let response = errors::internal_server_error("internal");
assert_eq!(response.status(), StatusCode::INTERNAL_SERVER_ERROR);
let bytes = axum::body::to_bytes(response.into_body(), usize::MAX)
.await
.unwrap();
let json: serde_json::Value = serde_json::from_slice(&bytes).unwrap();
assert_eq!(json["error"]["code"], "INTERNAL_ERROR");
assert_eq!(json["error"]["message"], "internal");
}
#[tokio::test]
async fn test_errors_bad_request() {
let response = errors::bad_request("bad");
assert_eq!(response.status(), StatusCode::BAD_REQUEST);
let bytes = axum::body::to_bytes(response.into_body(), usize::MAX)
.await
.unwrap();
let json: serde_json::Value = serde_json::from_slice(&bytes).unwrap();
assert_eq!(json["error"]["code"], "VALIDATION_ERROR");
}
#[tokio::test]
async fn test_errors_not_found() {
let response = errors::not_found("absent");
assert_eq!(response.status(), StatusCode::NOT_FOUND);
let bytes = axum::body::to_bytes(response.into_body(), usize::MAX)
.await
.unwrap();
let json: serde_json::Value = serde_json::from_slice(&bytes).unwrap();
assert_eq!(json["error"]["code"], "NOT_FOUND");
assert_eq!(json["error"]["message"], "absent");
}
#[tokio::test]
async fn test_errors_forbidden() {
let response = errors::forbidden("no access");
assert_eq!(response.status(), StatusCode::FORBIDDEN);
let bytes = axum::body::to_bytes(response.into_body(), usize::MAX)
.await
.unwrap();
let json: serde_json::Value = serde_json::from_slice(&bytes).unwrap();
assert_eq!(json["error"]["code"], "FORBIDDEN");
}
#[tokio::test]
async fn test_errors_unauthorized() {
let response = errors::unauthorized("no auth");
assert_eq!(response.status(), StatusCode::UNAUTHORIZED);
let bytes = axum::body::to_bytes(response.into_body(), usize::MAX)
.await
.unwrap();
let json: serde_json::Value = serde_json::from_slice(&bytes).unwrap();
assert_eq!(json["error"]["code"], "UNAUTHORIZED");
}
#[tokio::test]
async fn test_errors_too_many_requests() {
let response = errors::too_many_requests("slow down");
assert_eq!(response.status(), StatusCode::TOO_MANY_REQUESTS);
let bytes = axum::body::to_bytes(response.into_body(), usize::MAX)
.await
.unwrap();
let json: serde_json::Value = serde_json::from_slice(&bytes).unwrap();
assert_eq!(json["error"]["code"], "RATE_LIMITED");
}
#[tokio::test]
async fn test_errors_too_many_requests_with_retry() {
let response = errors::too_many_requests_with_retry("rate limited", 60);
assert_eq!(response.status(), StatusCode::TOO_MANY_REQUESTS);
let bytes = axum::body::to_bytes(response.into_body(), usize::MAX)
.await
.unwrap();
let json: serde_json::Value = serde_json::from_slice(&bytes).unwrap();
assert_eq!(json["success"], false);
assert_eq!(json["error"]["code"], "RATE_LIMITED");
assert_eq!(json["error"]["message"], "rate limited");
assert_eq!(json["retry_after_seconds"], 60);
assert!(json["timestamp"].is_string());
}
#[tokio::test]
async fn test_errors_unprocessable_entity() {
let response = errors::unprocessable_entity("cannot process");
assert_eq!(response.status(), StatusCode::UNPROCESSABLE_ENTITY);
let bytes = axum::body::to_bytes(response.into_body(), usize::MAX)
.await
.unwrap();
let json: serde_json::Value = serde_json::from_slice(&bytes).unwrap();
assert_eq!(json["error"]["code"], "UNPROCESSABLE_ENTITY");
}
#[tokio::test]
async fn test_errors_payment_required() {
let response = errors::payment_required("pay up");
assert_eq!(response.status(), StatusCode::PAYMENT_REQUIRED);
let bytes = axum::body::to_bytes(response.into_body(), usize::MAX)
.await
.unwrap();
let json: serde_json::Value = serde_json::from_slice(&bytes).unwrap();
assert_eq!(json["error"]["code"], "QUOTA_EXCEEDED");
}
#[tokio::test]
async fn test_validation_error_prepends_prefix() {
let response = validation_error("field required");
assert_eq!(response.status(), StatusCode::BAD_REQUEST);
let bytes = axum::body::to_bytes(response.into_body(), usize::MAX)
.await
.unwrap();
let json: serde_json::Value = serde_json::from_slice(&bytes).unwrap();
assert_eq!(json["error"]["code"], "VALIDATION_ERROR");
assert_eq!(json["error"]["message"], "Validation error: field required");
}
#[tokio::test]
async fn test_resource_not_found_appends_suffix() {
let response = resource_not_found("Task");
assert_eq!(response.status(), StatusCode::NOT_FOUND);
let bytes = axum::body::to_bytes(response.into_body(), usize::MAX)
.await
.unwrap();
let json: serde_json::Value = serde_json::from_slice(&bytes).unwrap();
assert_eq!(json["error"]["code"], "NOT_FOUND");
assert_eq!(json["error"]["message"], "Task not found");
}
#[tokio::test]
async fn test_access_denied_returns_forbidden() {
let response = access_denied();
assert_eq!(response.status(), StatusCode::FORBIDDEN);
let bytes = axum::body::to_bytes(response.into_body(), usize::MAX)
.await
.unwrap();
let json: serde_json::Value = serde_json::from_slice(&bytes).unwrap();
assert_eq!(json["error"]["code"], "FORBIDDEN");
assert_eq!(json["error"]["message"], "Access denied");
}
#[test]
fn test_rate_limit_error_response_fields() {
let resp = RateLimitErrorResponse::new("too many", 30);
assert!(!resp.success);
assert_eq!(resp.error.code, "RATE_LIMITED");
assert_eq!(resp.error.message, "too many");
assert_eq!(resp.retry_after_seconds, 30);
assert!(resp.timestamp.is_some());
}
#[tokio::test]
async fn test_rate_limit_error_response_serialization() {
let resp = RateLimitErrorResponse::new("limited", 120);
let json_str = serde_json::to_string(&resp).unwrap();
let json: serde_json::Value = serde_json::from_str(&json_str).unwrap();
assert_eq!(json["success"], false);
assert_eq!(json["error"]["code"], "RATE_LIMITED");
assert_eq!(json["retry_after_seconds"], 120);
}
#[test]
fn test_api_error_serialization() {
let err = ApiError {
code: "TEST_CODE".to_string(),
message: "test message".to_string(),
};
let json = serde_json::to_string(&err).unwrap();
assert!(json.contains("TEST_CODE"));
assert!(json.contains("test message"));
}
#[test]
fn test_api_error_deserialization() {
let json = r#"{"code":"ERR","message":"msg"}"#;
let err: ApiError = serde_json::from_str(json).unwrap();
assert_eq!(err.code, "ERR");
assert_eq!(err.message, "msg");
}
#[test]
fn test_api_response_round_trip_success() {
let original = ApiResponse::success(vec![1, 2, 3]);
let json = serde_json::to_string(&original).unwrap();
let deserialized: ApiResponse<Vec<i32>> = serde_json::from_str(&json).unwrap();
assert!(deserialized.success);
assert_eq!(deserialized.data, Some(vec![1, 2, 3]));
}
#[test]
fn test_pagination_meta_round_trip() {
let original = PaginationMeta::new(3, 15, 42);
let json = serde_json::to_string(&original).unwrap();
let deserialized: PaginationMeta = serde_json::from_str(&json).unwrap();
assert_eq!(deserialized.page, original.page);
assert_eq!(deserialized.per_page, original.per_page);
assert_eq!(deserialized.total_items, original.total_items);
assert_eq!(deserialized.total_pages, original.total_pages);
assert_eq!(deserialized.has_next, original.has_next);
assert_eq!(deserialized.has_previous, original.has_previous);
}
#[test]
fn test_rate_limit_error_response_deserialization() {
let json = r#"{"success":false,"error":{"code":"RATE_LIMITED","message":"slow down"},"retry_after_seconds":45,"timestamp":"2025-01-01T00:00:00Z"}"#;
let resp: RateLimitErrorResponse = serde_json::from_str(json).unwrap();
assert!(!resp.success);
assert_eq!(resp.error.code, "RATE_LIMITED");
assert_eq!(resp.error.message, "slow down");
assert_eq!(resp.retry_after_seconds, 45);
assert!(resp.timestamp.is_some());
}
}