use axum::{http::StatusCode, response::IntoResponse};
use serde_json::json;
use super::{
ApiErrorBoundary, ApiProblem, ApiProblemStatusError, PROBLEM_JSON_MEDIA_TYPE, ProblemCode,
ProblemIdentifierError, ProblemType, PublicError,
};
use crate::http::{RequestContext, RequestId};
use crate::result::{ClassifyError, ErrorCode, ErrorDescriptor, ErrorKind};
fn code(value: &'static str) -> ProblemCode {
ProblemCode::try_new(value).expect("test problem code should be valid")
}
#[test]
fn validates_problem_code() {
let code = ProblemCode::try_new(" invalid_query ").expect("problem code should be valid");
assert_eq!(code.as_str(), "invalid_query");
assert!(matches!(
ProblemCode::try_new("invalid query"),
Err(ProblemIdentifierError::InvalidCharacters)
));
assert!(matches!(
ProblemCode::try_new("invalid query"),
Err(ProblemIdentifierError::InvalidCharacters)
));
}
#[test]
fn validates_problem_type() {
let problem_type = ProblemType::try_new(" https://example.com/problems/invalid-query ")
.expect("problem type should be valid");
assert_eq!(
problem_type.as_str(),
"https://example.com/problems/invalid-query"
);
assert!(matches!(
ProblemType::try_new("bad type"),
Err(ProblemIdentifierError::InvalidCharacters)
));
assert!(matches!(
ProblemType::try_new("bad type"),
Err(ProblemIdentifierError::InvalidCharacters)
));
}
#[test]
fn problem_identifiers_deserialize_with_constructor_validation() {
let code: ProblemCode =
serde_json::from_value(json!(" invalid_query ")).expect("code should deserialize");
assert_eq!(code.as_str(), "invalid_query");
assert!(serde_json::from_value::<ProblemCode>(json!("invalid query")).is_err());
let problem_type: ProblemType =
serde_json::from_value(json!(" https://example.com/problems/invalid-query "))
.expect("type should deserialize");
assert_eq!(
problem_type.as_str(),
"https://example.com/problems/invalid-query"
);
assert!(serde_json::from_value::<ProblemType>(json!("bad type")).is_err());
}
#[test]
fn problem_identifier_errors_are_classified_as_validation_failures() {
let error = ProblemCode::try_new("bad code").expect_err("problem code should be invalid");
let descriptor = error.error_descriptor();
assert_eq!(descriptor.kind(), ErrorKind::Validation);
assert_eq!(
descriptor.code().as_str(),
"problem_identifier_invalid_characters"
);
}
#[test]
fn problem_body_carries_status_and_request_id() {
let problem = ApiProblem::bad_request(code("invalid_query"), "invalid query")
.with_request_id(&RequestId::new("req_test").expect("request id should be valid"));
assert_eq!(problem.status(), StatusCode::BAD_REQUEST);
assert_eq!(problem.body().status, 400);
assert_eq!(problem.body().title, "Bad Request");
assert_eq!(problem.body().detail, "invalid query");
assert_eq!(problem.body().request_id.as_deref(), Some("req_test"));
}
#[test]
fn problem_debug_redacts_arbitrary_payloads_without_changing_wire_data() {
let detail = "private-public-detail";
let instance = "https://example.com/problem?token=private-instance";
let details = "private-details";
let problem = ApiProblem::bad_request(code("invalid_query"), detail)
.with_instance(instance)
.with_details(json!({ "credential": details }));
let debug = format!("{problem:?}");
let display = problem.to_string();
assert!(debug.contains("invalid_query"));
assert!(debug.contains("[REDACTED]"));
for sensitive in [detail, instance, details] {
assert!(!debug.contains(sensitive));
assert!(!display.contains(sensitive));
}
assert_eq!(display, "HTTP problem invalid_query (400)");
let wire = serde_json::to_value(problem.body()).expect("problem should serialize");
assert_eq!(wire["detail"], detail);
assert_eq!(wire["instance"], instance);
assert_eq!(wire["details"]["credential"], details);
assert!(wire.get("context").is_none());
let public_error = PublicError::validation(code("invalid_query"), detail)
.with_details(json!({ "credential": details }));
let debug = format!("{public_error:?}");
assert!(!debug.contains(detail));
assert!(!debug.contains(details));
}
#[test]
fn request_context_exposes_only_safe_correlation_identifiers() {
let context = RequestContext::new(
RequestId::new("req_test").expect("request id should be valid"),
Some("00-4bf92f3577b34da6a3ce929d0e0e4736-00f067aa0ba902b7-01".to_owned()),
)
.with_client_ip("198.51.100.10")
.with_locale("en-US")
.with_time_zone("UTC")
.with_utc_offset_minutes(0)
.with_client_id("opsline")
.with_session_id("sess_private");
let problem = ApiProblem::bad_request(code("invalid_query"), "invalid query")
.with_request_context(&context)
.into_body();
assert_eq!(problem.request_id.as_deref(), Some("req_test"));
assert_eq!(
problem.trace_id.as_deref(),
Some("4bf92f3577b34da6a3ce929d0e0e4736")
);
let serialized = serde_json::to_value(problem).expect("problem should serialize");
assert!(serialized.get("context").is_none());
assert!(!serialized.to_string().contains("sess_private"));
}
#[test]
fn api_error_boundary_maps_classified_errors_to_problem_details() {
let descriptor = ErrorDescriptor::new(
ErrorKind::Dependency,
ErrorCode::try_new("database_unavailable").expect("error code should be valid"),
"database connection failed",
);
let context = RequestContext::new(
RequestId::new("req_test").expect("request id should be valid"),
None,
);
let problem = ApiErrorBoundary::http_api()
.problem(&descriptor, &context)
.into_body();
assert_eq!(problem.status, 503);
assert_eq!(problem.code, "database_unavailable");
assert_eq!(problem.detail, "service is unavailable");
assert_eq!(problem.request_id.as_deref(), Some("req_test"));
}
#[test]
fn problem_status_must_be_error_status() {
let error =
ApiProblem::try_new(StatusCode::OK, code("ok"), "ok").expect_err("status is not an error");
assert!(matches!(
error,
ApiProblemStatusError::InvalidStatus { status: 200 }
));
assert_eq!(
error.error_descriptor().code().as_str(),
"api_problem_invalid_status"
);
assert!(ApiProblem::new(StatusCode::OK, code("ok"), "ok").is_err());
}
#[test]
fn response_uses_problem_json_content_type() {
let response = ApiProblem::bad_request(code("invalid_query"), "invalid query").into_response();
let content_type = response
.headers()
.get(axum::http::header::CONTENT_TYPE)
.and_then(|value| value.to_str().ok());
assert_eq!(content_type, Some(PROBLEM_JSON_MEDIA_TYPE));
}