use std::{
sync::{
Arc,
atomic::{AtomicBool, AtomicUsize, Ordering},
},
time::Duration,
};
use axum::{
Router,
body::{Body, to_bytes},
http::{
HeaderMap, HeaderName, HeaderValue, Method, Request, StatusCode,
header::{ACCEPT_ENCODING, AUTHORIZATION, CACHE_CONTROL, CONTENT_ENCODING, CONTENT_TYPE},
},
routing::post,
};
use tower::ServiceExt;
use super::{
CorsMode, CorsSettings, ForwardedHeadersSettings, HttpIdempotencySettings,
HttpMiddlewareSettings, HttpRateLimitSettings, HttpRequestPolicySettings,
HttpRouteRuleSettings, RateLimitKeySourceSettings, RequestBodyLimitSettings,
RouteMatcherSettings, SecurityHeadersSettings, StrictTransportSecuritySettings,
};
use super::{
CorsPolicy, DEFAULT_HSTS_MAX_AGE, DEFAULT_HTTP_REQUEST_BODY_LIMIT, DEFAULT_HTTP_TIMEOUT,
ForwardedHeadersPolicy, HttpMiddlewareConfig, HttpMiddlewareError, HttpMiddlewareStack,
HttpRequestPolicy, HttpRouteRule, RequestBodyLimitPolicy, RouteMatcher, SecurityHeadersConfig,
};
use crate::http::{
EndpointAuth, EndpointContract, EndpointMethod, EndpointPathPattern, EndpointPermissions,
EndpointRouter, HttpAuthenticationHook, HttpAuthorizationHook, IdempotencyRequestPolicy,
IdempotencyScope, MemoryIdempotencyStore, RateLimitKeySource, RateLimitRequestPolicy,
TokenBucketRateLimiter, VerifiedAuthentication,
};
use crate::net::IpNetworkSet;
#[derive(Debug)]
struct HeaderAuthentication;
struct FramedBody {
frames: std::collections::VecDeque<http_body::Frame<axum::body::Bytes>>,
polls: Arc<AtomicUsize>,
}
impl http_body::Body for FramedBody {
type Data = axum::body::Bytes;
type Error = std::convert::Infallible;
fn poll_frame(
mut self: std::pin::Pin<&mut Self>,
_: &mut std::task::Context<'_>,
) -> std::task::Poll<Option<Result<http_body::Frame<Self::Data>, Self::Error>>> {
self.polls.fetch_add(1, Ordering::SeqCst);
std::task::Poll::Ready(self.frames.pop_front().map(Ok))
}
}
#[tokio::test]
async fn body_limit_preserves_trailers_and_does_not_read_ignored_streams() {
use http_body_util::BodyExt;
let app = HttpMiddlewareStack::builder(HttpMiddlewareConfig::standard())
.build()
.unwrap()
.apply(
Router::new()
.route("/ignore", post(|| async { "ok" }))
.route(
"/trailer",
post(|mut body: Body| async move {
while let Some(frame) = body.frame().await {
if let Some(trailers) = frame.unwrap().trailers_ref() {
return trailers["x-checksum"].to_str().unwrap().to_owned();
}
}
"missing".into()
}),
),
);
for path in ["/ignore", "/trailer"] {
let polls = Arc::new(AtomicUsize::new(0));
let mut trailers = HeaderMap::new();
trailers.insert("x-checksum", HeaderValue::from_static("expected"));
let body = FramedBody {
frames: [
http_body::Frame::data(axum::body::Bytes::from_static(b"abc")),
http_body::Frame::trailers(trailers),
]
.into(),
polls: polls.clone(),
};
let response = app
.clone()
.oneshot(Request::post(path).body(Body::new(body)).unwrap())
.await
.unwrap();
if path == "/ignore" {
assert_eq!(polls.load(Ordering::SeqCst), 0);
} else {
assert_eq!(
to_bytes(response.into_body(), 100).await.unwrap(),
"expected"
);
}
}
}
#[tokio::test]
async fn chunked_body_limits_propagate_through_extractors_and_idempotency() {
for idempotency in [false, true] {
let config = HttpMiddlewareSettings::new()
.with_request_body_limit(Some(4))
.with_idempotency(HttpIdempotencySettings::default().with_enabled(idempotency))
.build()
.unwrap();
let stack = HttpMiddlewareStack::builder(config)
.with_idempotency_store(Arc::new(MemoryIdempotencyStore::default()))
.build()
.unwrap();
let app =
stack.apply(Router::new().route("/body", post(|body: String| async move { body })));
let body = FramedBody {
frames: [
http_body::Frame::data(axum::body::Bytes::from_static(b"123")),
http_body::Frame::data(axum::body::Bytes::from_static(b"45")),
]
.into(),
polls: Arc::new(AtomicUsize::new(0)),
};
let response = app
.oneshot(
Request::post("/body")
.header(crate::http::IDEMPOTENCY_KEY_HEADER_NAME, "chunked")
.body(Body::new(body))
.unwrap(),
)
.await
.unwrap();
assert_eq!(
response.status(),
StatusCode::PAYLOAD_TOO_LARGE,
"idempotency={idempotency}"
);
}
}
#[tokio::test]
async fn disabled_body_policy_is_the_runtime_source_of_truth() {
let config = HttpMiddlewareSettings::new()
.with_request_body_limit(Some(4))
.with_request_policy(HttpRequestPolicySettings::disabled())
.build()
.unwrap();
assert_eq!(config.request_body_limit(), None);
let app = HttpMiddlewareStack::builder(config)
.build()
.unwrap()
.apply(Router::new().route("/body", post(|body: String| async move { body })));
let response = app
.oneshot(Request::post("/body").body(Body::from("12345")).unwrap())
.await
.unwrap();
assert_eq!(response.status(), StatusCode::OK);
}
#[tokio::test]
async fn temporary_rate_limit_rejections_do_not_enter_the_idempotency_cache() {
let config = HttpMiddlewareSettings::new()
.with_rate_limit(
HttpRateLimitSettings::default()
.with_enabled(true)
.with_capacity(1)
.with_refill_tokens(1)
.with_refill_interval(Duration::from_millis(200))
.with_key_source(RateLimitKeySourceSettings::Fixed("global".into())),
)
.with_idempotency(HttpIdempotencySettings::default().with_enabled(true))
.build()
.unwrap();
let limiter = config.rate_limit().unwrap().limiter_config();
let app = HttpMiddlewareStack::builder(config)
.with_rate_limit_store(Arc::new(TokenBucketRateLimiter::new(limiter)))
.with_idempotency_store(Arc::new(MemoryIdempotencyStore::default()))
.build()
.unwrap()
.apply(Router::new().route("/orders", post(|| async { "created" })));
let request = |key| {
Request::post("/orders")
.header(crate::http::IDEMPOTENCY_KEY_HEADER_NAME, key)
.body(Body::empty())
.unwrap()
};
assert_eq!(
app.clone()
.oneshot(request("first"))
.await
.unwrap()
.status(),
StatusCode::OK
);
let rejected = app.clone().oneshot(request("retry")).await.unwrap();
assert_eq!(rejected.status(), StatusCode::TOO_MANY_REQUESTS);
assert!(
!rejected
.headers()
.contains_key(crate::http::IDEMPOTENCY_REPLAYED_HEADER_NAME)
);
tokio::time::sleep(Duration::from_millis(250)).await;
let retried = app.oneshot(request("retry")).await.unwrap();
assert_eq!(retried.status(), StatusCode::OK);
assert!(
!retried
.headers()
.contains_key(crate::http::IDEMPOTENCY_REPLAYED_HEADER_NAME)
);
}
#[async_trait::async_trait]
impl HttpAuthenticationHook for HeaderAuthentication {
async fn authenticate(
&self,
request: &axum::http::request::Parts,
) -> Result<Option<VerifiedAuthentication>, crate::http::ApiProblem> {
let Some(identifier) = request
.headers
.get(AUTHORIZATION)
.and_then(|value| value.to_str().ok())
.and_then(|value| value.strip_prefix("Bearer "))
else {
return Ok(None);
};
let principal = crate::auth::Principal::user(identifier)
.expect("test authentication accepts valid static identifiers");
let scope = IdempotencyScope::namespaced(b"test-principal", identifier.as_bytes());
Ok(Some(VerifiedAuthentication::new(principal, scope)))
}
}
struct AdminAuthorization {
allowed: AtomicBool,
checks: AtomicUsize,
}
#[async_trait::async_trait]
impl HttpAuthorizationHook for AdminAuthorization {
async fn authorize(
&self,
request: &axum::http::request::Parts,
) -> Result<(), crate::http::ApiProblem> {
use crate::http::{ApiProblem, ProblemCode, RequestContext};
self.checks.fetch_add(1, Ordering::SeqCst);
assert_eq!(
request
.extensions
.get::<axum::extract::MatchedPath>()
.unwrap()
.as_str(),
"/orders"
);
let principal = request
.extensions
.get::<RequestContext>()
.and_then(RequestContext::principal)
.ok_or_else(|| {
ApiProblem::unauthorized(ProblemCode::UNAUTHENTICATED, "authentication is required")
})?;
assert_eq!(principal.id(), "usr_1");
if !self.allowed.load(Ordering::SeqCst) {
return Err(ApiProblem::forbidden(
ProblemCode::FORBIDDEN,
"permission denied",
));
}
Ok(())
}
}
#[tokio::test]
async fn authorization_precedes_replays_and_denials_do_not_enter_the_cache() {
let protected =
EndpointContract::new(EndpointMethod::Post, EndpointPathPattern::exact("/orders"))
.with_rate_limit(RateLimitRequestPolicy::Disabled)
.with_idempotency(IdempotencyRequestPolicy::Required);
for contract in [
protected.clone().with_auth(EndpointAuth::Admin),
protected
.with_auth(EndpointAuth::Authenticated)
.with_permissions(EndpointPermissions::One("admin")),
] {
let config = HttpMiddlewareSettings::new()
.with_idempotency(HttpIdempotencySettings::default().with_enabled(true))
.with_request_policy(
HttpRequestPolicy::disabled()
.with_default_idempotency(IdempotencyRequestPolicy::Required)
.into(),
)
.build()
.unwrap();
let stack = HttpMiddlewareStack::builder(config)
.with_authentication_hook(Arc::new(HeaderAuthentication))
.with_idempotency_store(Arc::new(MemoryIdempotencyStore::default()));
let calls = Arc::new(AtomicUsize::new(0));
let handler_calls = calls.clone();
let routes = EndpointRouter::new()
.route(contract, move || {
handler_calls.fetch_add(1, Ordering::SeqCst);
async { "sensitive result" }
})
.unwrap();
assert!(matches!(
routes.clone().into_router(stack.clone().build().unwrap()),
Err(HttpMiddlewareError::EndpointContractAuthorizationRequired { .. })
));
let authorization = Arc::new(AdminAuthorization {
allowed: AtomicBool::new(true),
checks: AtomicUsize::new(0),
});
let app = routes
.into_router(
stack
.with_authorization_hook(authorization.clone())
.build()
.unwrap(),
)
.unwrap();
let request = |key| {
Request::post("/orders")
.header(AUTHORIZATION, "Bearer usr_1")
.header(crate::http::IDEMPOTENCY_KEY_HEADER_NAME, key)
.header(crate::http::REQUEST_ID_HEADER_NAME, "req_access")
.body(Body::empty())
.unwrap()
};
let initial = app.clone().oneshot(request("completed")).await.unwrap();
assert_eq!(initial.status(), StatusCode::OK);
assert_eq!(calls.load(Ordering::SeqCst), 1);
authorization.allowed.store(false, Ordering::SeqCst);
for key in ["completed", "denied"] {
let response = app.clone().oneshot(request(key)).await.unwrap();
assert_eq!(response.status(), StatusCode::FORBIDDEN);
assert!(
!response
.headers()
.contains_key(crate::http::IDEMPOTENCY_REPLAYED_HEADER_NAME)
);
let problem: serde_json::Value =
serde_json::from_slice(&to_bytes(response.into_body(), 4096).await.unwrap())
.unwrap();
assert_eq!(problem["request_id"], "req_access");
assert_eq!(calls.load(Ordering::SeqCst), 1);
}
authorization.allowed.store(true, Ordering::SeqCst);
let replayed = app.clone().oneshot(request("completed")).await.unwrap();
assert_eq!(replayed.status(), StatusCode::OK);
assert!(
replayed
.headers()
.contains_key(crate::http::IDEMPOTENCY_REPLAYED_HEADER_NAME)
);
assert_eq!(calls.load(Ordering::SeqCst), 1);
let admitted = app.clone().oneshot(request("denied")).await.unwrap();
assert_eq!(admitted.status(), StatusCode::OK);
assert!(
!admitted
.headers()
.contains_key(crate::http::IDEMPOTENCY_REPLAYED_HEADER_NAME)
);
assert_eq!(calls.load(Ordering::SeqCst), 2);
let anonymous = app
.oneshot(Request::post("/orders").body(Body::empty()).unwrap())
.await
.unwrap();
assert_eq!(anonymous.status(), StatusCode::UNAUTHORIZED);
assert_eq!(authorization.checks.load(Ordering::SeqCst), 6);
assert_eq!(calls.load(Ordering::SeqCst), 2);
}
}
#[test]
fn replayable_identity_categories_require_authorization_but_plain_identity_does_not() {
let config = HttpMiddlewareSettings::new()
.with_idempotency(HttpIdempotencySettings::default().with_enabled(true))
.build()
.unwrap();
let stack = HttpMiddlewareStack::builder(config)
.with_authentication_hook(Arc::new(HeaderAuthentication))
.with_idempotency_store(Arc::new(MemoryIdempotencyStore::default()))
.build()
.unwrap();
for auth in [
EndpointAuth::Public,
EndpointAuth::Authenticated,
EndpointAuth::User,
EndpointAuth::Client,
EndpointAuth::Admin,
EndpointAuth::Service,
] {
let contract: EndpointContract =
EndpointContract::new(EndpointMethod::Post, EndpointPathPattern::exact("/orders"))
.with_auth(auth)
.with_rate_limit(RateLimitRequestPolicy::Disabled)
.with_idempotency(IdempotencyRequestPolicy::HeaderOptional);
let routes = EndpointRouter::<()>::new()
.route(contract, || async { "ok" })
.unwrap();
let result = routes.into_router(stack.clone());
match auth {
EndpointAuth::Public | EndpointAuth::Authenticated => assert!(result.is_ok()),
_ => assert!(
matches!(
result,
Err(HttpMiddlewareError::EndpointContractAuthorizationRequired { .. })
),
"{auth:?}"
),
}
}
}
#[tokio::test]
async fn permissive_cors_preflight_allows_authorization_without_credentials() {
let config = HttpMiddlewareSettings::new()
.with_cors(CorsSettings::permissive())
.build()
.unwrap();
let app = HttpMiddlewareStack::builder(config)
.build()
.unwrap()
.apply(Router::new().route("/orders", post(|| async { "created" })));
let requested_headers = "authorization,content-type,x-application-header";
let response = app
.oneshot(
Request::builder()
.method(Method::OPTIONS)
.uri("/orders")
.header("origin", "https://console.example.com")
.header("access-control-request-method", "POST")
.header("access-control-request-headers", requested_headers)
.body(Body::empty())
.unwrap(),
)
.await
.unwrap();
assert_eq!(response.status(), StatusCode::OK);
assert_eq!(response.headers()["access-control-allow-origin"], "*");
assert_eq!(
response.headers()["access-control-allow-headers"],
requested_headers
);
assert!(
!response
.headers()
.contains_key("access-control-allow-credentials")
);
}
#[tokio::test]
async fn restricted_cors_defaults_support_idempotency_and_client_context() {
let config = HttpMiddlewareSettings::new()
.with_cors(CorsSettings::restricted(["https://console.example.com"]))
.with_idempotency(HttpIdempotencySettings::default().with_enabled(true))
.build()
.unwrap();
let app = HttpMiddlewareStack::builder(config)
.with_idempotency_store(Arc::new(MemoryIdempotencyStore::default()))
.build()
.unwrap()
.apply(Router::new().route(
"/orders",
post(|context: crate::http::RequestContext| async move {
format!(
"{} {}",
context.locale().unwrap(),
context.time_zone().unwrap()
)
}),
));
let requested_headers = [
"content-type",
"accept-language",
"user-agent",
"idempotency-key",
"x-request-id",
"traceparent",
"x-locale",
"x-time-zone",
"x-utc-offset",
"x-client-id",
"x-session-id",
];
let preflight = app
.clone()
.oneshot(
Request::builder()
.method(Method::OPTIONS)
.uri("/orders")
.header("origin", "https://console.example.com")
.header("access-control-request-method", "POST")
.header(
"access-control-request-headers",
requested_headers.join(","),
)
.body(Body::empty())
.unwrap(),
)
.await
.unwrap();
assert_eq!(preflight.status(), StatusCode::OK);
assert_eq!(
preflight.headers()["access-control-allow-origin"],
"https://console.example.com"
);
let allowed: Vec<_> = preflight.headers()["access-control-allow-headers"]
.to_str()
.unwrap()
.split(',')
.map(str::trim)
.collect();
for header in requested_headers {
assert!(allowed.contains(&header), "{header}");
}
for header in ["*", "x-forwarded-for", "x-real-ip"] {
assert!(!allowed.contains(&header), "{header}");
}
for replayed in [false, true] {
let response = app
.clone()
.oneshot(
Request::post("/orders")
.header("origin", "https://console.example.com")
.header("idempotency-key", "cors-order")
.header("x-locale", "zh-CN")
.header("x-time-zone", "Asia/Shanghai")
.body(Body::empty())
.unwrap(),
)
.await
.unwrap();
assert_eq!(response.status(), StatusCode::OK);
assert_eq!(
response.headers().contains_key("idempotency-replayed"),
replayed
);
let exposed: Vec<_> = response.headers()["access-control-expose-headers"]
.to_str()
.unwrap()
.split(',')
.map(str::trim)
.collect();
for header in ["x-request-id", "idempotency-replayed", "retry-after"] {
assert!(exposed.contains(&header), "{header}");
}
assert_eq!(
to_bytes(response.into_body(), 256).await.unwrap(),
"zh-CN Asia/Shanghai"
);
}
}
#[test]
fn restricted_cors_explicit_headers_replace_defaults() {
let mut settings = CorsSettings::restricted(["https://console.example.com"]);
settings.allowed_headers = vec!["content-type".to_owned()];
settings.exposed_headers = vec!["x-application-result".to_owned()];
let CorsPolicy::Restricted(config) = CorsPolicy::try_from(&settings).unwrap() else {
unreachable!()
};
assert_eq!(
config.allowed_headers(),
&[HeaderName::from_static("content-type")]
);
assert_eq!(
config.exposed_headers(),
&[HeaderName::from_static("x-application-result")]
);
}
#[test]
fn cors_validation_and_conversion_agree_on_inactive_fields() {
for mode in [
CorsMode::Disabled,
CorsMode::AnyOrigin,
CorsMode::Restricted,
] {
for credentials in [false, true] {
let cors = CorsSettings {
mode,
allow_credentials: credentials,
allowed_origins: vec!["invalid\norigin".into()],
allowed_methods: vec!["bad method".into()],
allowed_headers: vec!["bad header".into()],
exposed_headers: vec!["bad header".into()],
..CorsSettings::default()
};
let direct = CorsPolicy::try_from(&cors);
let settings = HttpMiddlewareSettings::new().with_cors(cors);
let valid = mode == CorsMode::Disabled;
assert_eq!(direct.is_ok(), valid, "{mode:?}, credentials={credentials}");
assert_eq!(settings.validate().is_ok(), valid);
let built = settings.build();
match (direct, built) {
(Ok(policy), Ok(config)) => assert_eq!(&policy, config.cors()),
(Err(direct), Err(built)) => assert_eq!(direct, built),
other => panic!("inconsistent CORS results: {other:?}"),
}
}
}
}
#[test]
fn restricted_cors_accepts_only_serialized_origins() {
for origin in [
"https://example.com",
"http://localhost:3000",
"https://[::1]:8443",
"https://xn--bcher-kva.example",
"null",
] {
assert!(
CorsPolicy::try_from(&CorsSettings::restricted([origin])).is_ok(),
"{origin}"
);
}
for origin in [
"",
"*",
"https://*.example.com",
"not an origin",
"example.com",
"https://example.com/",
"https://example.com/path",
"https://example.com?x=1",
"https://example.com#fragment",
"https://user:password@example.com",
"https://example.com:bad",
"https://[invalid]",
"https://EXAMPLE.com",
"https://example.com:443",
"file:///tmp/docs",
"https://bücher.example",
] {
let error = CorsPolicy::try_from(&CorsSettings::restricted([origin])).unwrap_err();
assert!(
error
.issues()
.iter()
.any(|issue| issue.path() == "http.cors.allowed_origins.0"),
"{origin}"
);
}
}
#[test]
fn restricted_cors_rejects_wildcards_in_settings_and_runtime_config() {
for credentials in [false, true] {
assert!(
HttpMiddlewareSettings::new()
.with_cors(CorsSettings::restricted(["*"]).with_credentials(credentials))
.build()
.is_err()
);
let cors = CorsSettings::restricted(["*"]).with_credentials(credentials);
assert!(CorsPolicy::try_from(&cors).is_err());
}
let config = HttpMiddlewareSettings::new()
.with_cors(CorsSettings {
mode: CorsMode::AnyOrigin,
..CorsSettings::default()
})
.build()
.unwrap();
let _: Router = HttpMiddlewareStack::builder(config)
.build()
.unwrap()
.apply(Router::new());
}
#[tokio::test]
async fn credentialed_cors_rejects_wildcards_before_router_assembly() {
for field in ["allowed_methods", "allowed_headers", "exposed_headers"] {
for credentials in [false, true] {
let mut cors = CorsSettings::restricted(["https://console.example.com"])
.with_credentials(credentials);
match field {
"allowed_methods" => cors.allowed_methods = vec!["*".to_owned()],
"allowed_headers" => cors.allowed_headers = vec!["*".to_owned()],
"exposed_headers" => cors.exposed_headers = vec!["*".to_owned()],
_ => unreachable!(),
}
assert_eq!(CorsPolicy::try_from(&cors).is_err(), credentials);
let config = HttpMiddlewareSettings::new().with_cors(cors).build();
if credentials {
let error = config.unwrap_err();
assert!(
error
.issues()
.iter()
.any(|issue| { issue.path() == format!("http.cors.{field}") })
);
} else {
let _: Router = HttpMiddlewareStack::builder(config.unwrap())
.build()
.unwrap()
.apply(Router::new());
}
}
}
let cors = CorsSettings::permissive().with_credentials(true);
assert!(CorsPolicy::try_from(&cors).is_err());
assert!(
HttpMiddlewareSettings::new()
.with_cors(cors)
.build()
.is_err()
);
}
#[tokio::test]
async fn body_limits_above_axum_default_and_disabled_limits_are_honored() {
for limit in [Some(4 * 1024 * 1024), None] {
let config = HttpMiddlewareSettings::new()
.with_request_policy(HttpRequestPolicySettings::disabled())
.with_request_body_limit(limit)
.build()
.unwrap();
let app =
HttpMiddlewareStack::builder(config).build().unwrap().apply(
Router::new()
.route(
"/string",
post(|body: String| async move { body.len().to_string() }),
)
.route(
"/json",
post(|axum::Json(body): axum::Json<String>| async move {
body.len().to_string()
}),
),
);
for path in ["/string", "/json"] {
let value = "a".repeat(3 * 1024 * 1024);
let body = if path == "/json" {
serde_json::to_string(&value).unwrap()
} else {
value
};
let response = app
.clone()
.oneshot(
Request::post(path)
.header(CONTENT_TYPE, "application/json")
.body(Body::from(body))
.unwrap(),
)
.await
.unwrap();
assert_eq!(response.status(), StatusCode::OK, "{path} limit={limit:?}");
}
let response = app
.oneshot(
Request::post("/string")
.body(Body::from("a".repeat(5 * 1024 * 1024)))
.unwrap(),
)
.await
.unwrap();
assert_eq!(
response.status(),
if limit.is_some() {
StatusCode::PAYLOAD_TOO_LARGE
} else {
StatusCode::OK
}
);
}
}
#[test]
fn identity_rate_limiting_accepts_public_exempt_routes() {
for key_source in [
RateLimitKeySourceSettings::Principal,
RateLimitKeySourceSettings::Tenant,
] {
let contracts = [
EndpointContract::new(EndpointMethod::Get, EndpointPathPattern::exact("/health"))
.with_rate_limit(RateLimitRequestPolicy::Disabled),
EndpointContract::new(EndpointMethod::Get, EndpointPathPattern::exact("/private"))
.with_rate_limit(RateLimitRequestPolicy::Enabled)
.with_auth(EndpointAuth::Authenticated)
.with_permissions(EndpointPermissions::One("private:read")),
];
let config = HttpMiddlewareSettings::new()
.with_rate_limit(
HttpRateLimitSettings::default()
.with_enabled(true)
.with_key_source(key_source),
)
.with_request_policy(HttpRequestPolicySettings::disabled().with_rule(
HttpRouteRuleSettings {
matcher: RouteMatcherSettings::Exact("/private".into()),
rate_limit: Some(RateLimitRequestPolicy::Enabled),
..HttpRouteRuleSettings::default()
},
))
.build()
.unwrap();
let store = Arc::new(TokenBucketRateLimiter::new(
config.rate_limit().unwrap().limiter_config(),
));
let build = |contracts: &[EndpointContract]| {
let stack = HttpMiddlewareStack::builder(config.clone())
.with_authentication_hook(Arc::new(HeaderAuthentication))
.with_rate_limit_store(store.clone())
.build()?;
let mut router = EndpointRouter::<()>::new();
for contract in contracts {
router = router.route(contract.clone(), || async { "ok" }).unwrap();
}
router.into_router(stack)
};
assert!(build(&contracts).is_ok());
let public_limited = [
contracts[0].clone(),
contracts[1]
.clone()
.with_auth(EndpointAuth::Public)
.with_permissions(EndpointPermissions::None),
];
assert!(matches!(
build(&public_limited),
Err(HttpMiddlewareError::PublicEndpointIdentityRateLimit { .. })
));
}
}
#[test]
fn builds_restricted_cors_config_from_origin_strings() {
let config = HttpMiddlewareSettings::default()
.with_cors(CorsSettings::restricted(["https://console.example.com"]).with_credentials(true))
.build()
.unwrap();
assert!(matches!(config.cors(), CorsPolicy::Restricted(_)));
let CorsPolicy::Restricted(restricted) = config.cors() else {
panic!("restricted CORS should be configured");
};
assert!(restricted.allowed_headers().contains(&CONTENT_TYPE));
assert!(restricted.allowed_headers().contains(&AUTHORIZATION));
assert!(
restricted
.exposed_headers()
.contains(&HeaderName::from_static("x-request-id"))
);
assert!(config.request_context_enabled());
assert!(!config.forwarded_headers_enabled());
assert!(config.trace_enabled());
assert!(config.compression_enabled());
}
#[tokio::test]
async fn compression_does_not_add_content_to_bodyless_statuses() {
for status in [
StatusCode::EARLY_HINTS,
StatusCode::NO_CONTENT,
StatusCode::RESET_CONTENT,
StatusCode::NOT_MODIFIED,
] {
let app = HttpMiddlewareStack::builder(HttpMiddlewareConfig::standard())
.build()
.unwrap()
.apply(Router::new().route(
"/",
axum::routing::get(move || async move {
(status, Body::from_stream(Body::empty().into_data_stream()))
}),
));
for encoding in ["gzip", "br, identity;q=0", "*;q=0"] {
let response = app
.clone()
.oneshot(
Request::get("/")
.header(ACCEPT_ENCODING, encoding)
.body(Body::empty())
.unwrap(),
)
.await
.unwrap();
assert_eq!(response.status(), status, "{encoding}");
assert!(!response.headers().contains_key(CONTENT_ENCODING));
assert!(!response.headers().contains_key("content-length"));
assert!(to_bytes(response.into_body(), 64).await.unwrap().is_empty());
}
}
}
#[tokio::test]
async fn compression_preserves_preencoded_streams_without_negotiating_again() {
const ENCODED: &[u8] = b"already encoded bytes";
const CACHE: &str = "public, max-age=31536000, immutable";
for status in [
StatusCode::OK,
StatusCode::NOT_FOUND,
StatusCode::INTERNAL_SERVER_ERROR,
] {
let polls = Arc::new(AtomicUsize::new(0));
let response_polls = polls.clone();
let app = HttpMiddlewareStack::builder(HttpMiddlewareConfig::standard())
.build()
.unwrap()
.apply(Router::new().route(
"/",
axum::routing::get(move || {
let polls = response_polls.clone();
async move {
(
status,
[(CONTENT_ENCODING, "br"), (CACHE_CONTROL, CACHE)],
Body::new(FramedBody {
frames: [http_body::Frame::data(axum::body::Bytes::from_static(
ENCODED,
))]
.into(),
polls,
}),
)
}
}),
));
let response = app
.oneshot(
Request::get("/")
.header(ACCEPT_ENCODING, "br, identity;q=0")
.body(Body::empty())
.unwrap(),
)
.await
.unwrap();
assert_eq!(response.status(), status);
assert_eq!(response.headers()[CONTENT_ENCODING], "br");
assert_eq!(response.headers()[CACHE_CONTROL], CACHE);
assert_eq!(polls.load(Ordering::SeqCst), 0);
assert_eq!(to_bytes(response.into_body(), 64).await.unwrap(), ENCODED);
assert!(polls.load(Ordering::SeqCst) > 0);
}
}
#[tokio::test]
async fn compression_negotiation_failure_does_not_inherit_immutable_caching() {
const CACHE: &str = "public, max-age=31536000, immutable";
let app = HttpMiddlewareStack::builder(HttpMiddlewareConfig::standard())
.build()
.unwrap()
.apply(Router::new().route(
"/",
axum::routing::get(|| async { ([(CACHE_CONTROL, CACHE)], "versioned asset") }),
));
for (encoding, status, cache) in [
("identity", StatusCode::OK, CACHE),
(
"identity;q=0, *;q=0",
StatusCode::NOT_ACCEPTABLE,
"no-store",
),
] {
let response = app
.clone()
.oneshot(
Request::get("/")
.header(ACCEPT_ENCODING, encoding)
.body(Body::empty())
.unwrap(),
)
.await
.unwrap();
assert_eq!(response.status(), status);
assert_eq!(response.headers()[CACHE_CONTROL], cache);
}
}
#[tokio::test]
async fn compression_preserves_other_application_error_cache_policies() {
let app = HttpMiddlewareStack::builder(HttpMiddlewareConfig::standard())
.build()
.unwrap()
.apply(Router::new().route(
"/",
axum::routing::get(|| async {
(
StatusCode::NOT_FOUND,
[(CACHE_CONTROL, "public, max-age=60")],
)
}),
));
let response = app
.oneshot(
Request::get("/")
.header(ACCEPT_ENCODING, "identity")
.body(Body::empty())
.unwrap(),
)
.await
.unwrap();
assert_eq!(response.status(), StatusCode::NOT_FOUND);
assert_eq!(response.headers()[CACHE_CONTROL], "public, max-age=60");
}
#[tokio::test]
async fn compression_negotiates_each_idempotent_replay_independently() {
let config = HttpMiddlewareSettings::default()
.with_idempotency(HttpIdempotencySettings::default().with_enabled(true))
.build()
.unwrap();
let store = MemoryIdempotencyStore::for_response_body_limit(
crate::http::DEFAULT_IDEMPOTENCY_MAX_BODY_BYTES,
)
.unwrap();
let app = HttpMiddlewareStack::builder(config)
.with_idempotency_store(Arc::new(store))
.build()
.unwrap()
.apply(Router::new().route("/", post(|| async { "compressible response ".repeat(100) })));
let first = app
.clone()
.oneshot(
Request::post("/")
.header(
crate::http::IDEMPOTENCY_KEY_HEADER_NAME,
"compression-replay",
)
.header(ACCEPT_ENCODING, "gzip")
.body(Body::empty())
.unwrap(),
)
.await
.unwrap();
assert_eq!(
first.headers().get(CONTENT_ENCODING),
Some(&HeaderValue::from_static("gzip"))
);
let _ = to_bytes(first.into_body(), usize::MAX).await.unwrap();
let replay = app
.oneshot(
Request::post("/")
.header(
crate::http::IDEMPOTENCY_KEY_HEADER_NAME,
"compression-replay",
)
.body(Body::empty())
.unwrap(),
)
.await
.unwrap();
assert!(replay.headers().get(CONTENT_ENCODING).is_none());
assert_eq!(
replay
.headers()
.get(crate::http::IDEMPOTENCY_REPLAYED_HEADER_NAME),
Some(&HeaderValue::from_static("true"))
);
assert_eq!(
to_bytes(replay.into_body(), usize::MAX)
.await
.unwrap()
.len(),
"compressible response ".len() * 100
);
}
#[test]
fn rejects_restricted_cors_without_origins() {
let settings = HttpMiddlewareSettings::default().with_cors(CorsSettings {
mode: CorsMode::Restricted,
..CorsSettings::default()
});
assert!(settings.build().is_err());
}
#[test]
fn rejects_cors_credentials_with_wildcard_origin() {
let settings = HttpMiddlewareSettings::default()
.with_cors(CorsSettings::restricted(["*"]).with_credentials(true));
assert!(settings.build().is_err());
}
#[test]
fn rejects_invalid_layer_limits() {
assert!(
HttpMiddlewareSettings::default()
.with_timeout(Some(Duration::ZERO))
.build()
.is_err()
);
assert!(
HttpMiddlewareSettings::default()
.with_request_body_limit(Some(0))
.build()
.is_err()
);
}
#[test]
fn settings_build_and_validation_report_all_invalid_sections() {
let settings = HttpMiddlewareSettings::default()
.with_timeout(Some(Duration::ZERO))
.with_cors(CorsSettings::restricted(["not an origin"]))
.with_forwarded_headers(ForwardedHeadersSettings::trusted_proxies(["not a CIDR"]))
.with_rate_limit(
HttpRateLimitSettings::default()
.with_enabled(true)
.with_capacity(0)
.with_refill_tokens(0),
)
.with_idempotency(
HttpIdempotencySettings::default()
.with_enabled(true)
.with_ttl(Duration::ZERO),
)
.with_request_body_limit(Some(0));
let validation = settings.validate().unwrap_err();
assert_eq!(settings.build().unwrap_err(), validation);
let paths: Vec<_> = validation
.issues()
.iter()
.map(|issue| issue.path())
.collect();
for expected in [
"http.timeout",
"http.cors.allowed_origins.0",
"http.forwarded_headers.trusted_proxy_cidrs",
"http.rate_limit.capacity",
"http.rate_limit.refill_tokens",
"http.idempotency.ttl",
"http.request_policy.default_request_body_limit",
] {
assert!(paths.contains(&expected), "missing {expected}: {paths:?}");
}
}
#[test]
fn idempotency_settings_reject_unrepresentable_expiry_and_response_capacity() {
let settings = HttpMiddlewareSettings::default().with_idempotency(
HttpIdempotencySettings::default()
.with_enabled(true)
.with_ttl(Duration::MAX)
.with_processing_ttl(Duration::MAX)
.with_max_response_body_bytes(usize::MAX),
);
let error = settings.validate_at("server.http").unwrap_err();
let paths: Vec<_> = error.issues().iter().map(|issue| issue.path()).collect();
assert_eq!(
paths,
[
"server.http.idempotency.ttl",
"server.http.idempotency.processing_ttl",
"server.http.idempotency.max_response_body_bytes",
]
);
assert!(settings.build().is_err());
}
#[test]
fn idempotency_processing_lease_must_outlive_request_timeout() {
let timeout = Duration::from_secs(30);
let invalid = HttpMiddlewareSettings::default()
.with_timeout(Some(timeout))
.with_idempotency(
HttpIdempotencySettings::default()
.with_enabled(true)
.with_processing_ttl(timeout),
);
assert!(invalid.build().is_err());
let valid = HttpMiddlewareSettings::default()
.with_timeout(Some(timeout))
.with_idempotency(
HttpIdempotencySettings::default()
.with_enabled(true)
.with_processing_ttl(timeout + Duration::from_secs(1)),
);
valid.build().unwrap();
}
#[test]
fn idempotency_requires_a_request_timeout() {
let error = HttpMiddlewareSettings::default()
.with_timeout(None)
.with_idempotency(HttpIdempotencySettings::default().with_enabled(true))
.build()
.unwrap_err();
assert!(
error
.issues()
.iter()
.any(|issue| issue.path() == "http.timeout")
);
HttpMiddlewareSettings::default()
.with_timeout(None)
.build()
.unwrap();
}
#[tokio::test]
async fn timed_out_idempotent_execution_is_not_repeated_after_processing_expiry() {
let clock = Arc::new(crate::clock::ManualClock::new());
let store = Arc::new(MemoryIdempotencyStore::with_clock(clock.clone()));
let calls = Arc::new(AtomicUsize::new(0));
let config = HttpMiddlewareSettings::default()
.with_timeout(Some(Duration::from_millis(5)))
.with_idempotency(
HttpIdempotencySettings::default()
.with_enabled(true)
.with_processing_ttl(Duration::from_secs(1)),
)
.build()
.unwrap();
let handler_calls = calls.clone();
let app = HttpMiddlewareStack::builder(config)
.with_idempotency_store(store.clone())
.build()
.unwrap()
.apply(Router::new().route(
"/",
post(move || {
let calls = handler_calls.clone();
async move {
calls.fetch_add(1, Ordering::SeqCst);
std::future::pending::<&'static str>().await
}
}),
));
let request = || {
Request::post("/")
.header("idempotency-key", "timeout-regression")
.body(Body::empty())
.unwrap()
};
let response = app.clone().oneshot(request()).await.unwrap();
assert_eq!(response.status(), StatusCode::REQUEST_TIMEOUT);
tokio::time::timeout(Duration::from_secs(1), async {
while store.stored_response_bytes().unwrap() == 0 {
tokio::task::yield_now().await;
}
})
.await
.unwrap();
clock.advance(Duration::from_secs(2)).unwrap();
let replay = app.oneshot(request()).await.unwrap();
assert_eq!(replay.status(), StatusCode::INTERNAL_SERVER_ERROR);
assert_eq!(replay.headers()["idempotency-replayed"], "true");
assert_eq!(calls.load(Ordering::SeqCst), 1);
}
#[test]
fn applies_api_security_headers() {
let mut headers = HeaderMap::new();
let security_headers = SecurityHeadersConfig::api_defaults()
.with_frame_options(None)
.with_content_type_options(Some(HeaderValue::from_static("nosniff")))
.with_content_security_policy(Some(HeaderValue::from_static("default-src 'self'")))
.with_permissions_policy(Some(HeaderValue::from_static("camera=()")));
security_headers.apply(&mut headers);
assert_eq!(
headers
.get("x-content-type-options")
.and_then(|value| value.to_str().ok()),
Some("nosniff")
);
assert!(headers.get("x-frame-options").is_none());
assert_eq!(
headers
.get("content-security-policy")
.and_then(|value| value.to_str().ok()),
Some("default-src 'self'")
);
assert_eq!(
headers
.get("permissions-policy")
.and_then(|value| value.to_str().ok()),
Some("camera=()")
);
assert_eq!(
security_headers
.content_type_options()
.and_then(|value| value.to_str().ok()),
Some("nosniff")
);
}
#[test]
fn builds_strict_transport_security_header() {
let mut headers = HeaderMap::new();
let security_headers = SecurityHeadersConfig::api_defaults()
.with_strict_transport_security(DEFAULT_HSTS_MAX_AGE, true, false)
.expect("hsts header should be valid");
security_headers.apply(&mut headers);
assert_eq!(
headers
.get("strict-transport-security")
.and_then(|value| value.to_str().ok()),
Some("max-age=31536000; includeSubDomains")
);
let revocation = SecurityHeadersConfig::api_defaults()
.with_strict_transport_security(Duration::ZERO, false, false)
.unwrap();
assert_eq!(revocation.strict_transport_security().unwrap(), "max-age=0");
}
#[test]
fn enabled_hsts_settings_require_at_least_one_second() {
for max_age in ["0s", "1ns", "500ms", "999ms"] {
let settings: HttpMiddlewareSettings = serde_json::from_value(serde_json::json!({
"security_headers": {
"strict_transport_security": {"enabled": true, "max_age": max_age}
}
}))
.unwrap();
let error = settings
.clone()
.build()
.expect_err("HSTS must retain a positive max-age");
assert_eq!(error, settings.validate().unwrap_err());
assert_eq!(
error.issues()[0].path(),
"http.security_headers.strict_transport_security.max_age"
);
}
let config = HttpMiddlewareSettings::default()
.with_security_headers(
SecurityHeadersSettings::default().with_strict_transport_security(
StrictTransportSecuritySettings::enabled(Duration::from_secs(1)),
),
)
.build()
.unwrap();
assert_eq!(
config
.security_headers()
.unwrap()
.strict_transport_security()
.unwrap(),
"max-age=1; includeSubDomains"
);
}
#[test]
fn disabled_hsts_settings_ignore_subsecond_max_age() {
for (headers_enabled, hsts_enabled) in [(false, true), (true, false)] {
let config = HttpMiddlewareSettings::default()
.with_security_headers(
SecurityHeadersSettings::default()
.with_enabled(headers_enabled)
.with_strict_transport_security(StrictTransportSecuritySettings::new(
hsts_enabled,
Duration::from_millis(500),
true,
false,
)),
)
.build()
.unwrap();
assert!(
config
.security_headers()
.and_then(SecurityHeadersConfig::strict_transport_security)
.is_none()
);
}
}
#[test]
fn standard_defaults_are_explicit_and_hsts_is_opt_in() {
let standard = HttpMiddlewareConfig::default();
assert_eq!(standard.timeout(), Some(DEFAULT_HTTP_TIMEOUT));
assert_eq!(
standard.request_body_limit(),
Some(DEFAULT_HTTP_REQUEST_BODY_LIMIT)
);
assert!(
standard
.security_headers()
.and_then(SecurityHeadersConfig::strict_transport_security)
.is_none()
);
let tls = HttpMiddlewareSettings::default()
.with_security_headers(SecurityHeadersSettings {
strict_transport_security: StrictTransportSecuritySettings::enabled(
DEFAULT_HSTS_MAX_AGE,
),
..SecurityHeadersSettings::default()
})
.build()
.unwrap();
assert_eq!(
tls.security_headers()
.and_then(SecurityHeadersConfig::strict_transport_security)
.and_then(|value| value.to_str().ok()),
Some("max-age=31536000; includeSubDomains")
);
}
#[test]
fn request_policy_overrides_matching_routes_in_order() {
let policy = HttpRequestPolicy::default()
.with_rule(
HttpRouteRule::prefix("/api/admin")
.unwrap()
.rate_limit(RateLimitRequestPolicy::Disabled)
.idempotency(IdempotencyRequestPolicy::Required),
)
.with_rule(
HttpRouteRule::exact("/api/admin/import")
.unwrap()
.methods([Method::POST])
.request_body_limit(RequestBodyLimitPolicy::bytes(1024).unwrap()),
);
let request = Request::post("/api/admin/import")
.body(Body::empty())
.expect("request should build");
let effective = policy.policy_for(&request);
assert_eq!(effective.rate_limit(), RateLimitRequestPolicy::Disabled);
assert_eq!(effective.idempotency(), IdempotencyRequestPolicy::Required);
assert_eq!(
effective.request_body_limit(),
RequestBodyLimitPolicy::bytes(1024).unwrap()
);
let sibling = Request::post("/api/administrator")
.body(Body::empty())
.expect("request should build");
let sibling_effective = policy.policy_for(&sibling);
assert_eq!(
sibling_effective.rate_limit(),
RateLimitRequestPolicy::Enabled
);
assert_eq!(
sibling_effective.idempotency(),
IdempotencyRequestPolicy::HeaderOptional
);
}
#[test]
fn partial_http_settings_preserve_defaults_and_explicit_nulls() {
let settings: HttpMiddlewareSettings = serde_json::from_value(serde_json::json!({
"timeout": null,
"rate_limit": {"capacity": 7},
"request_policy": {"default_idempotency": "required"},
"security_headers": {"cross_origin_opener_policy": null}
}))
.unwrap();
let mut expected = serde_json::to_value(HttpMiddlewareSettings::default()).unwrap();
expected["timeout"] = serde_json::Value::Null;
expected["rate_limit"]["capacity"] = 7.into();
expected["request_policy"]["default_idempotency"] = "required".into();
expected["security_headers"]["cross_origin_opener_policy"] = serde_json::Value::Null;
assert_eq!(serde_json::to_value(settings).unwrap(), expected);
}
#[test]
fn method_settings_use_the_same_validation_and_normalization() {
for (method, valid) in [
(" GET ", true),
("PATCH", true),
("X-CUSTOM", true),
(" ", false),
("G ET", false),
] {
let rule = HttpRouteRuleSettings {
methods: vec![method.to_owned()],
rate_limit: Some(RateLimitRequestPolicy::Disabled),
..Default::default()
};
assert_eq!(HttpRouteRule::try_from(&rule).is_ok(), valid, "{method:?}");
let settings = HttpMiddlewareSettings::default()
.with_request_policy(HttpRequestPolicySettings::default().with_rule(rule));
assert_eq!(settings.validate().is_ok(), valid, "{method:?}");
assert_eq!(settings.build().is_ok(), valid, "{method:?}");
let cors = CorsSettings {
mode: CorsMode::Restricted,
allowed_origins: vec!["https://example.com".to_owned()],
allowed_methods: vec![method.to_owned()],
..Default::default()
};
assert_eq!(CorsPolicy::try_from(&cors).is_ok(), valid, "{method:?}");
assert_eq!(
HttpMiddlewareSettings::default()
.with_cors(cors)
.build()
.is_ok(),
valid,
"{method:?}"
);
}
let rule = HttpRouteRuleSettings {
methods: vec![" GET ".to_owned()],
rate_limit: Some(RateLimitRequestPolicy::Disabled),
..Default::default()
};
let policy = HttpRequestPolicy::default().with_rule(HttpRouteRule::try_from(&rule).unwrap());
assert_eq!(
policy.policy_for_route(&Method::GET, "/").rate_limit(),
RateLimitRequestPolicy::Disabled
);
assert_eq!(
policy.policy_for_route(&Method::POST, "/").rate_limit(),
RateLimitRequestPolicy::Enabled
);
}
#[test]
fn modifying_a_cloned_request_policy_preserves_the_original() {
let original = HttpRequestPolicy::default().with_rule(
HttpRouteRule::prefix("/api")
.unwrap()
.rate_limit(RateLimitRequestPolicy::Disabled),
);
let changed = original
.clone()
.with_rules([HttpRouteRule::exact("/api/import")
.unwrap()
.rate_limit(RateLimitRequestPolicy::Enabled)])
.with_rule(
HttpRouteRule::exact("/api/import")
.unwrap()
.idempotency(IdempotencyRequestPolicy::Required),
);
let before = original.policy_for_route(&Method::POST, "/api/import");
let after = changed.policy_for_route(&Method::POST, "/api/import");
assert_eq!(before.rate_limit(), RateLimitRequestPolicy::Disabled);
assert_eq!(
before.idempotency(),
IdempotencyRequestPolicy::HeaderOptional
);
assert_eq!(after.rate_limit(), RateLimitRequestPolicy::Enabled);
assert_eq!(after.idempotency(), IdempotencyRequestPolicy::Required);
assert_eq!(original.rules().len(), 1);
}
#[test]
fn request_policy_enums_preserve_json_names_and_binary_indices() {
for (policy, name, index) in [
(
IdempotencyRequestPolicy::HeaderOptional,
"header_optional",
0,
),
(IdempotencyRequestPolicy::Required, "required", 1),
(IdempotencyRequestPolicy::Disabled, "disabled", 2),
] {
assert_eq!(policy.as_str(), name);
assert_eq!(serde_json::to_value(policy).unwrap(), name);
assert_eq!(postcard::to_allocvec(&policy).unwrap(), [index]);
assert_eq!(
postcard::from_bytes::<IdempotencyRequestPolicy>(&[index]).unwrap(),
policy
);
}
for (policy, name, index) in [
(RateLimitRequestPolicy::Enabled, "enabled", 0),
(RateLimitRequestPolicy::Disabled, "disabled", 1),
] {
assert_eq!(policy.as_str(), name);
assert_eq!(serde_json::to_value(policy).unwrap(), name);
assert_eq!(postcard::to_allocvec(&policy).unwrap(), [index]);
assert_eq!(
postcard::from_bytes::<RateLimitRequestPolicy>(&[index]).unwrap(),
policy
);
}
}
#[test]
fn request_policy_settings_adapt_to_route_policy() {
let settings = HttpRequestPolicySettings::default().with_rule(HttpRouteRuleSettings {
matcher: RouteMatcherSettings::Exact("/api/import".to_owned()),
methods: vec!["POST".to_owned()],
rate_limit: Some(RateLimitRequestPolicy::Disabled),
idempotency: Some(IdempotencyRequestPolicy::Required),
request_body_limit: Some(RequestBodyLimitSettings::Bytes(512)),
});
settings
.build_at("server.http.request_policy")
.expect("request policy settings should validate");
let policy = HttpRequestPolicy::try_from(&settings).expect("settings should adapt");
let request = Request::post("/api/import")
.body(Body::empty())
.expect("request should build");
let effective = policy.policy_for(&request);
assert_eq!(effective.rate_limit(), RateLimitRequestPolicy::Disabled);
assert_eq!(effective.idempotency(), IdempotencyRequestPolicy::Required);
assert_eq!(
effective.request_body_limit(),
RequestBodyLimitPolicy::bytes(512).unwrap()
);
}
#[test]
fn request_policy_settings_report_route_paths() {
let invalid_rule = HttpRouteRuleSettings {
matcher: RouteMatcherSettings::Prefix("api".to_owned()),
methods: vec!["not a method".to_owned()],
rate_limit: None,
idempotency: None,
request_body_limit: Some(RequestBodyLimitSettings::Bytes(0)),
};
let settings = HttpRequestPolicySettings::default()
.with_rule(invalid_rule.clone())
.with_rule(invalid_rule);
let error = settings
.build_at("server.http.request_policy")
.expect_err("invalid request policy settings should fail");
let paths = error
.issues()
.iter()
.map(|issue| issue.path())
.collect::<Vec<_>>();
assert!(paths.contains(&"server.http.request_policy.rules.0.matcher.value"));
assert!(paths.contains(&"server.http.request_policy.rules.0.methods.0"));
assert!(paths.contains(&"server.http.request_policy.rules.0.request_body_limit"));
assert!(paths.contains(&"server.http.request_policy.rules.1.matcher.value"));
assert!(paths.contains(&"server.http.request_policy.rules.1.methods.0"));
assert!(paths.contains(&"server.http.request_policy.rules.1.request_body_limit"));
assert_eq!(
HttpRequestPolicy::try_from(&settings).unwrap_err(),
settings.build_at("http.request_policy").unwrap_err(),
);
}
#[test]
fn route_matchers_and_settings_reject_unmatchable_paths() {
for (path, valid) in [
("", false),
("api", false),
("/orders\n", false),
("/a\0b", false),
("/a\tb", false),
("/a b", false),
("/a?query", false),
("/a#fragment", false),
("/a\\b", false),
("/用户", false),
("/", true),
("/api/", true),
("/users/{id}", true),
("/assets/{*path}", true),
("/%E7%94%A8%E6%88%B7", true),
] {
for result in [
RouteMatcher::exact(path),
RouteMatcher::prefix(path),
RouteMatcher::raw_prefix(path),
] {
assert_eq!(result.is_ok(), valid, "{path:?}");
}
for matcher in [
RouteMatcherSettings::Exact(path.into()),
RouteMatcherSettings::Prefix(path.into()),
RouteMatcherSettings::RawPrefix(path.into()),
] {
let rule = HttpRouteRuleSettings {
matcher,
..Default::default()
};
assert_eq!(HttpRouteRule::try_from(&rule).is_ok(), valid, "{path:?}");
let settings = HttpRequestPolicySettings::default().with_rule(rule);
let validation = settings.build_at("http.request_policy");
assert_eq!(validation.is_ok(), valid, "{path:?}");
if let Err(error) = validation {
assert_eq!(
error.issues()[0].path(),
"http.request_policy.rules.0.matcher.value"
);
}
}
}
}
#[test]
fn route_prefix_matches_path_segments_unless_raw_prefix_is_requested() {
let prefix = RouteMatcher::prefix("/api").unwrap();
assert!(prefix.matches("/api"));
assert!(prefix.matches("/api/users"));
assert!(!prefix.matches("/apiary"));
assert!(RouteMatcher::raw_prefix("/api").unwrap().matches("/apiary"));
}
#[test]
fn http_foundation_builder_assembles_validated_config() {
let config = HttpMiddlewareSettings::default()
.with_forwarded_headers(ForwardedHeadersSettings::always())
.with_request_body_limit(Some(4096))
.build()
.unwrap();
let foundation = HttpMiddlewareStack::builder(config).build().unwrap();
assert!(foundation.config().forwarded_headers_enabled());
assert_eq!(foundation.config().request_body_limit(), Some(4096));
assert!(foundation.config().security_headers().is_some());
}
#[test]
fn http_foundation_builder_requires_explicit_rate_limit_store() {
let config = HttpMiddlewareSettings::default()
.with_rate_limit(HttpRateLimitSettings::default().with_enabled(true))
.build()
.unwrap();
assert!(matches!(
HttpMiddlewareStack::builder(config.clone()).build(),
Err(HttpMiddlewareError::MissingRateLimitStore)
));
let limiter_config = config
.rate_limit()
.expect("rate limiting should be configured")
.limiter_config();
HttpMiddlewareStack::builder(config)
.with_rate_limit_store(Arc::new(TokenBucketRateLimiter::new(limiter_config)))
.build()
.expect("explicit rate-limit storage should complete assembly");
}
#[test]
fn http_foundation_builder_requires_explicit_idempotency_store() {
let config = HttpMiddlewareSettings::default()
.with_idempotency(HttpIdempotencySettings::default().with_enabled(true))
.build()
.unwrap();
assert!(matches!(
HttpMiddlewareStack::builder(config.clone()).build(),
Err(HttpMiddlewareError::MissingIdempotencyStore)
));
let policy = config
.idempotency()
.expect("idempotency should be configured");
let store = MemoryIdempotencyStore::for_response_body_limit(policy.max_response_body_bytes())
.expect("validated body limit should create an in-memory store");
HttpMiddlewareStack::builder(config)
.with_idempotency_store(Arc::new(store))
.build()
.expect("explicit idempotency storage should complete assembly");
}
#[test]
fn http_foundation_builder_accepts_trusted_proxy_policy() {
let proxies = IpNetworkSet::from_cidrs(["10.0.0.0/8"]).expect("CIDR should parse");
let config = HttpMiddlewareSettings::default()
.with_forwarded_headers(ForwardedHeadersSettings::trusted_proxies(["10.0.0.0/8"]))
.build()
.unwrap();
let foundation = HttpMiddlewareStack::builder(config).build().unwrap();
assert!(foundation.config().forwarded_headers_enabled());
assert_eq!(
foundation.config().forwarded_headers_policy(),
&ForwardedHeadersPolicy::TrustedProxies(proxies)
);
}
#[test]
fn forwarded_headers_conversion_enforces_trust_mode_constraints() {
for settings in [
ForwardedHeadersSettings::trusted_proxies(Vec::<String>::new()),
ForwardedHeadersSettings {
trusted_proxy_cidrs: vec!["10.0.0.0/8".into()],
..ForwardedHeadersSettings::disabled()
},
ForwardedHeadersSettings {
trusted_proxy_cidrs: vec!["10.0.0.0/8".into()],
..ForwardedHeadersSettings::always()
},
] {
let error = ForwardedHeadersPolicy::try_from(&settings).unwrap_err();
assert_eq!(error.issues().len(), 1);
assert_eq!(
error.issues()[0].path(),
"http.forwarded_headers.trusted_proxy_cidrs"
);
assert_eq!(
HttpMiddlewareSettings::default()
.with_forwarded_headers(settings)
.build()
.unwrap_err(),
error,
);
}
}
#[test]
fn http_foundation_settings_adapt_to_runtime_config() {
let settings = HttpMiddlewareSettings::new()
.with_forwarded_headers(ForwardedHeadersSettings::trusted_proxies(["10.0.0.0/8"]))
.with_cors(CorsSettings::restricted(["https://console.example.com"]))
.with_security_headers(SecurityHeadersSettings {
strict_transport_security: StrictTransportSecuritySettings {
enabled: true,
max_age: Duration::from_secs(3600),
include_subdomains: true,
preload: false,
},
..SecurityHeadersSettings::default()
})
.with_rate_limit(HttpRateLimitSettings::default().with_enabled(true))
.with_timeout(Some(Duration::from_secs(5)));
settings.validate().expect("settings should validate");
let config = settings.build().expect("settings should build");
assert!(config.forwarded_headers_enabled());
assert_eq!(config.timeout(), Some(Duration::from_secs(5)));
assert!(matches!(config.cors(), CorsPolicy::Restricted(_)));
assert!(config.rate_limit().is_some());
assert_eq!(
config
.security_headers()
.and_then(SecurityHeadersConfig::strict_transport_security)
.and_then(|value| value.to_str().ok()),
Some("max-age=3600; includeSubDomains")
);
}
#[test]
fn http_foundation_settings_report_config_paths() {
let settings = HttpMiddlewareSettings::default()
.with_timeout(Some(Duration::ZERO))
.with_cors(CorsSettings {
mode: CorsMode::Restricted,
..CorsSettings::default()
});
let error = settings
.validate_at("server.http")
.expect_err("invalid HTTP settings should report paths");
let paths = error
.issues()
.iter()
.map(|issue| issue.path())
.collect::<Vec<_>>();
assert!(paths.contains(&"server.http.timeout"));
assert!(paths.contains(&"server.http.cors.allowed_origins"));
}
#[test]
fn http_foundation_settings_report_short_idempotency_processing_lease() {
let timeout = Duration::from_secs(30);
let settings = HttpMiddlewareSettings::default()
.with_timeout(Some(timeout))
.with_idempotency(
HttpIdempotencySettings::default()
.with_enabled(true)
.with_processing_ttl(timeout),
);
let error = settings
.validate_at("server.http")
.expect_err("processing lease no longer than the request timeout should fail");
let paths = error
.issues()
.iter()
.map(|issue| issue.path())
.collect::<Vec<_>>();
assert!(paths.contains(&"server.http.idempotency.processing_ttl"));
}
#[test]
fn http_foundation_settings_report_nested_value_paths() {
let settings = HttpMiddlewareSettings::default()
.with_cors(CorsSettings {
mode: CorsMode::Restricted,
allowed_origins: vec![" ".to_owned()],
allowed_methods: vec!["not a method".to_owned()],
allowed_headers: vec!["bad header".to_owned()],
exposed_headers: vec!["bad header".to_owned()],
..CorsSettings::default()
})
.with_security_headers(
SecurityHeadersSettings::default()
.with_cross_origin_opener_policy(Some("bad\nheader"))
.with_content_security_policy(Some("bad\npolicy"))
.with_permissions_policy(Some("bad\npermissions")),
)
.with_rate_limit(
HttpRateLimitSettings::default()
.with_enabled(true)
.with_key_source(RateLimitKeySourceSettings::Fixed(" ".to_owned())),
);
let error = settings
.validate_at("server.http")
.expect_err("invalid nested HTTP settings should report paths");
let paths = error
.issues()
.iter()
.map(|issue| issue.path())
.collect::<Vec<_>>();
assert!(paths.contains(&"server.http.cors.allowed_origins.0"));
assert!(paths.contains(&"server.http.cors.allowed_methods.0"));
assert!(paths.contains(&"server.http.cors.allowed_headers.0"));
assert!(paths.contains(&"server.http.cors.exposed_headers.0"));
assert!(paths.contains(&"server.http.security_headers.content_security_policy"));
assert!(paths.contains(&"server.http.security_headers.permissions_policy"));
assert!(paths.contains(&"server.http.security_headers.cross_origin_opener_policy"));
assert!(paths.contains(&"server.http.rate_limit.key_source.value"));
}
#[test]
fn rate_limit_key_source_settings_reject_empty_fixed_key() {
let error = crate::http::RateLimitKeySource::try_from(&RateLimitKeySourceSettings::Fixed(
" ".to_owned(),
))
.expect_err("empty fixed rate limit key should fail");
assert!(matches!(
error,
HttpMiddlewareError::InvalidRateLimitKeySource {
field: "rate_limit.key_source"
}
));
}
#[test]
fn rate_limit_settings_reject_rotatable_request_and_plain_header_keys() {
assert!(
serde_json::from_value::<RateLimitKeySourceSettings>(serde_json::json!({
"type": "request_id"
}))
.is_err()
);
assert!(
serde_json::from_value::<RateLimitKeySourceSettings>(serde_json::json!({
"type": "header",
"value": "x-account-id"
}))
.is_err()
);
let trusted = serde_json::from_value::<RateLimitKeySourceSettings>(serde_json::json!({
"type": "trusted_header",
"value": "x-account-id"
}))
.expect("trusted header must be explicit in serialized configuration");
let config = HttpMiddlewareSettings::default()
.with_rate_limit(
HttpRateLimitSettings::default()
.with_enabled(true)
.with_key_source(trusted),
)
.build()
.expect("explicit trusted-header configuration should build");
assert!(matches!(
config.rate_limit().map(|policy| policy.key_source()),
Some(RateLimitKeySource::TrustedHeader(_))
));
}
#[test]
fn http_layer_debug_redacts_invalid_values_and_fixed_keys() {
let private_value = "private-http-config-value";
let error = RateLimitKeySource::try_from(&RateLimitKeySourceSettings::TrustedHeader(format!(
"{private_value}\ninvalid"
)))
.unwrap_err();
let settings = RateLimitKeySourceSettings::Fixed(private_value.to_owned());
let output = format!("{error:?} {error} {settings:?}");
assert!(output.contains("http_invalid_header_name"));
assert!(output.contains("[REDACTED]"));
assert!(!output.contains(private_value));
}
#[tokio::test]
async fn route_request_body_limit_rejects_oversized_matching_requests() {
let config = HttpMiddlewareSettings::default()
.with_request_policy(HttpRequestPolicySettings::disabled().with_rule(
HttpRouteRuleSettings {
matcher: RouteMatcherSettings::Exact("/uploads".to_owned()),
methods: vec!["POST".to_owned()],
request_body_limit: Some(RequestBodyLimitSettings::Bytes(4)),
..HttpRouteRuleSettings::default()
},
))
.build()
.unwrap();
let app = HttpMiddlewareStack::builder(config)
.build()
.unwrap()
.apply(Router::new().route("/uploads", post(|| async { "ok" })));
let response = app
.oneshot(
Request::post("/uploads")
.body(Body::from("too-large"))
.expect("request should build"),
)
.await
.expect("request should complete");
assert_eq!(response.status(), StatusCode::PAYLOAD_TOO_LARGE);
}
#[tokio::test]
async fn route_request_body_limit_can_raise_or_disable_global_limit() {
let config = HttpMiddlewareSettings::default()
.with_request_policy(
HttpRequestPolicySettings::disabled()
.with_rule(HttpRouteRuleSettings {
matcher: RouteMatcherSettings::Exact("/larger".to_owned()),
methods: vec!["POST".to_owned()],
request_body_limit: Some(RequestBodyLimitSettings::Bytes(4 * 1024 * 1024)),
..HttpRouteRuleSettings::default()
})
.with_rule(HttpRouteRuleSettings {
matcher: RouteMatcherSettings::Exact("/unlimited".to_owned()),
methods: vec!["POST".to_owned()],
request_body_limit: Some(RequestBodyLimitSettings::Disabled),
..HttpRouteRuleSettings::default()
}),
)
.with_request_body_limit(Some(4))
.build()
.unwrap();
let app = HttpMiddlewareStack::builder(config).build().unwrap().apply(
Router::new()
.route("/default", post(|body: String| async move { body }))
.route("/larger", post(|body: String| async move { body }))
.route("/unlimited", post(|body: String| async move { body })),
);
let default_response = app
.clone()
.oneshot(
Request::post("/default")
.body(Body::from("eight123"))
.expect("request should build"),
)
.await
.expect("request should complete");
assert_eq!(default_response.status(), StatusCode::PAYLOAD_TOO_LARGE);
for path in ["/larger", "/unlimited"] {
let response = app
.clone()
.oneshot(
Request::post(path)
.body(Body::from("a".repeat(3 * 1024 * 1024)))
.expect("request should build"),
)
.await
.expect("request should complete");
assert_eq!(response.status(), StatusCode::OK);
}
}
#[test]
fn identity_rate_limiting_requires_ordered_authentication_hook() {
for key_source in [
RateLimitKeySourceSettings::Principal,
RateLimitKeySourceSettings::Tenant,
] {
let config = HttpMiddlewareSettings::default()
.with_rate_limit(
HttpRateLimitSettings::default()
.with_enabled(true)
.with_key_source(key_source),
)
.build()
.unwrap();
assert!(matches!(
HttpMiddlewareStack::builder(config).build(),
Err(HttpMiddlewareError::MissingAuthenticationHook)
));
}
}
#[tokio::test]
async fn tenant_rate_limiting_uses_authenticated_identity_and_one_shared_bucket() {
struct TenantAuthentication;
#[async_trait::async_trait]
impl HttpAuthenticationHook for TenantAuthentication {
async fn authenticate(
&self,
request: &axum::http::request::Parts,
) -> Result<Option<VerifiedAuthentication>, crate::http::ApiProblem> {
use crate::auth::Principal;
let principal = match request
.headers
.get(AUTHORIZATION)
.and_then(|value| value.to_str().ok())
{
Some("alice") => Principal::user("alice")
.unwrap()
.with_tenant_id("tenant-a")
.unwrap(),
Some("automation") => Principal::client("automation")
.unwrap()
.with_tenant_id("tenant-a")
.unwrap(),
Some("bob") => Principal::user("bob")
.unwrap()
.with_tenant_id("tenant-b")
.unwrap(),
Some("tenantless") => Principal::user("tenantless").unwrap(),
_ => return Ok(None),
};
Ok(Some(VerifiedAuthentication::new(
principal,
IdempotencyScope::new("test"),
)))
}
}
let settings: HttpRateLimitSettings = serde_json::from_value(serde_json::json!({
"enabled": true,
"capacity": 1,
"key_source": { "type": "tenant" },
}))
.unwrap();
assert_eq!(
serde_json::to_value(&settings).unwrap()["key_source"]["type"],
"tenant"
);
let config = HttpMiddlewareSettings::new()
.with_rate_limit(settings)
.build()
.unwrap();
let store = Arc::new(TokenBucketRateLimiter::new(
config.rate_limit().unwrap().limiter_config(),
));
let app = HttpMiddlewareStack::builder(config)
.with_authentication_hook(Arc::new(TenantAuthentication))
.with_rate_limit_store(store)
.build()
.unwrap()
.apply(Router::new().route("/orders", post(|| async { StatusCode::CREATED })));
for (credential, expected) in [
("alice", StatusCode::CREATED),
("automation", StatusCode::TOO_MANY_REQUESTS),
("bob", StatusCode::CREATED),
("tenantless", StatusCode::SERVICE_UNAVAILABLE),
("anonymous", StatusCode::SERVICE_UNAVAILABLE),
] {
let response = app
.clone()
.oneshot(
Request::post("/orders")
.header(AUTHORIZATION, credential)
.header("x-tenant-id", "spoofed")
.body(Body::empty())
.unwrap(),
)
.await
.unwrap();
assert_eq!(response.status(), expected, "{credential}");
}
}
#[tokio::test]
async fn anonymous_authentication_clears_existing_identity_and_scope() {
for config in [
HttpMiddlewareConfig::minimal(),
HttpMiddlewareConfig::standard(),
] {
let app =
HttpMiddlewareStack::builder(config)
.with_authentication_hook(Arc::new(HeaderAuthentication))
.build()
.unwrap()
.apply(Router::new().route(
"/identity",
post(
|principal: Option<crate::http::CurrentPrincipal>,
request: Request<Body>| async move {
assert!(principal.is_none());
assert!(request.extensions().get::<IdempotencyScope>().is_none());
let context = request
.extensions()
.get::<crate::http::RequestContext>()
.unwrap();
assert!(context.principal().is_none());
assert_eq!(context.request_id().as_str(), "preserved-request-id");
"anonymous"
},
),
));
let mut request = Request::post("/identity")
.header("x-request-id", "preserved-request-id")
.body(Body::empty())
.unwrap();
VerifiedAuthentication::new(
crate::auth::Principal::user("previous-user").unwrap(),
IdempotencyScope::namespaced(b"test", b"previous-user"),
)
.install(&mut request);
let response = app.oneshot(request).await.unwrap();
assert_eq!(response.status(), StatusCode::OK);
assert_eq!(
to_bytes(response.into_body(), 100).await.unwrap(),
"anonymous"
);
}
}
#[test]
fn resolved_request_policy_tracks_policy_and_route_changes() {
let policy = HttpRequestPolicy::disabled().with_rule(
HttpRouteRule::exact("/orders")
.unwrap()
.methods([Method::POST])
.idempotency(IdempotencyRequestPolicy::Required),
);
let mut request = Request::post("/orders").body(()).unwrap();
assert_eq!(
policy.resolve(&mut request).idempotency(),
IdempotencyRequestPolicy::Required
);
assert_eq!(
policy.clone().resolve(&mut request),
policy.policy_for(&request)
);
*request.method_mut() = Method::GET;
assert_eq!(
policy.resolve(&mut request).idempotency(),
IdempotencyRequestPolicy::Disabled
);
*request.method_mut() = Method::POST;
*request.uri_mut() = "/other".parse().unwrap();
assert_eq!(
policy.resolve(&mut request).idempotency(),
IdempotencyRequestPolicy::Disabled
);
let different_defaults = policy
.clone()
.with_default_rate_limit(RateLimitRequestPolicy::Enabled);
assert_eq!(
different_defaults.resolve(&mut request).rate_limit(),
RateLimitRequestPolicy::Enabled
);
let different_rules = policy
.clone()
.with_rule(HttpRouteRule::any().idempotency(IdempotencyRequestPolicy::Required));
assert_eq!(
different_rules.resolve(&mut request).idempotency(),
IdempotencyRequestPolicy::Required
);
assert_eq!(
policy.resolve(&mut request).idempotency(),
IdempotencyRequestPolicy::Disabled
);
}
#[tokio::test]
async fn authentication_installs_principal_and_idempotency_scope_before_policies() {
let request_policy =
HttpRequestPolicy::default().with_default_idempotency(IdempotencyRequestPolicy::Required);
let config = HttpMiddlewareSettings::default()
.with_rate_limit(
HttpRateLimitSettings::default()
.with_enabled(true)
.with_capacity(2)
.with_refill_tokens(1)
.with_refill_interval(Duration::from_secs(60))
.with_key_source(RateLimitKeySourceSettings::Principal),
)
.with_idempotency(HttpIdempotencySettings::default().with_enabled(true))
.with_request_policy(HttpRequestPolicySettings::from(request_policy))
.build()
.unwrap();
let limiter_config = config.rate_limit().unwrap().limiter_config();
let idempotency = config.idempotency().unwrap();
let idempotency_store =
MemoryIdempotencyStore::for_response_body_limit(idempotency.max_response_body_bytes())
.unwrap();
let calls = Arc::new(AtomicUsize::new(0));
let handler_calls = calls.clone();
let app = HttpMiddlewareStack::builder(config)
.with_authentication_hook(Arc::new(HeaderAuthentication))
.with_rate_limit_store(Arc::new(TokenBucketRateLimiter::new(limiter_config)))
.with_idempotency_store(Arc::new(idempotency_store))
.build()
.unwrap()
.apply(Router::new().route(
"/orders",
post(move |principal: crate::http::CurrentPrincipal| {
let handler_calls = handler_calls.clone();
async move {
handler_calls.fetch_add(1, Ordering::SeqCst);
principal.id().to_owned()
}
}),
));
let request = |principal: &'static str, key: &'static str| {
Request::post("/orders")
.header(AUTHORIZATION, format!("Bearer {principal}"))
.header(crate::http::IDEMPOTENCY_KEY_HEADER_NAME, key)
.body(Body::empty())
.unwrap()
};
let first = app
.clone()
.oneshot(request("user-a", "shared-key"))
.await
.unwrap();
assert_eq!(first.status(), StatusCode::OK);
let isolated = app
.clone()
.oneshot(request("user-b", "shared-key"))
.await
.unwrap();
assert_eq!(isolated.status(), StatusCode::OK);
let replay = app
.clone()
.oneshot(request("user-a", "shared-key"))
.await
.unwrap();
assert_eq!(replay.status(), StatusCode::OK);
assert_eq!(
replay
.headers()
.get(crate::http::IDEMPOTENCY_REPLAYED_HEADER_NAME),
Some(&HeaderValue::from_static("true"))
);
let exhausted = app
.oneshot(request("user-a", "different-key"))
.await
.unwrap();
assert_eq!(exhausted.status(), StatusCode::TOO_MANY_REQUESTS);
assert_eq!(calls.load(Ordering::SeqCst), 2);
}
#[tokio::test]
async fn foundation_metrics_cover_policy_rejections_and_timeout() {
let registry = Arc::new(crate::observability::MetricRegistry::new());
let body_limited = HttpMiddlewareStack::builder(
HttpMiddlewareSettings::default()
.with_request_body_limit(Some(4))
.build()
.unwrap(),
)
.with_metrics(registry.clone())
.build()
.unwrap()
.apply(Router::new().route("/body", post(|| async { "ok" })));
let response = body_limited
.oneshot(
Request::post("/body")
.body(Body::from("too-large"))
.unwrap(),
)
.await
.unwrap();
assert_eq!(response.status(), StatusCode::PAYLOAD_TOO_LARGE);
let rate_config = HttpMiddlewareSettings::default()
.with_rate_limit(
HttpRateLimitSettings::default()
.with_enabled(true)
.with_capacity(1)
.with_key_source(RateLimitKeySourceSettings::Fixed("all".to_owned())),
)
.build()
.unwrap();
let limiter_config = rate_config.rate_limit().unwrap().limiter_config();
let rate_limited = HttpMiddlewareStack::builder(rate_config)
.with_rate_limit_store(Arc::new(TokenBucketRateLimiter::new(limiter_config)))
.with_metrics(registry.clone())
.build()
.unwrap()
.apply(Router::new().route("/rate", post(|| async { "ok" })));
for expected in [StatusCode::OK, StatusCode::TOO_MANY_REQUESTS] {
let response = rate_limited
.clone()
.oneshot(Request::post("/rate").body(Body::empty()).unwrap())
.await
.unwrap();
assert_eq!(response.status(), expected);
}
let idempotency_policy =
HttpRequestPolicy::default().with_default_idempotency(IdempotencyRequestPolicy::Required);
let idempotency_config = HttpMiddlewareSettings::default()
.with_idempotency(HttpIdempotencySettings::default().with_enabled(true))
.with_request_policy(HttpRequestPolicySettings::from(idempotency_policy))
.build()
.unwrap();
let max_response_body_bytes = idempotency_config
.idempotency()
.unwrap()
.max_response_body_bytes();
let idempotency_rejected = HttpMiddlewareStack::builder(idempotency_config)
.with_idempotency_store(Arc::new(
MemoryIdempotencyStore::for_response_body_limit(max_response_body_bytes).unwrap(),
))
.with_metrics(registry.clone())
.build()
.unwrap()
.apply(Router::new().route("/idempotency", post(|| async { "ok" })));
let response = idempotency_rejected
.oneshot(Request::post("/idempotency").body(Body::empty()).unwrap())
.await
.unwrap();
assert_eq!(response.status(), StatusCode::BAD_REQUEST);
let timed_out = HttpMiddlewareStack::builder(
HttpMiddlewareSettings::default()
.with_timeout(Some(Duration::from_millis(1)))
.build()
.unwrap(),
)
.with_metrics(registry.clone())
.build()
.unwrap()
.apply(Router::new().route(
"/timeout",
post(|| async {
tokio::time::sleep(Duration::from_millis(25)).await;
"late"
}),
));
let response = timed_out
.oneshot(Request::post("/timeout").body(Body::empty()).unwrap())
.await
.unwrap();
assert_eq!(response.status(), StatusCode::REQUEST_TIMEOUT);
let snapshot = registry.snapshot().unwrap();
for status in [413_u16, 429, 400, 408] {
let status = status.to_string();
assert!(snapshot.samples().iter().any(|sample| {
sample.name() == crate::observability::metric_names::HTTP_SERVER_REQUESTS_TOTAL
&& sample.labels().iter().any(|(name, value)| {
name == crate::observability::metric_labels::STATUS && value == &status
})
}));
}
}
#[test]
fn registered_contracts_validate_policies_in_both_directions() {
let contract: EndpointContract =
EndpointContract::new(EndpointMethod::Post, EndpointPathPattern::exact("/orders"))
.with_rate_limit(RateLimitRequestPolicy::Enabled);
let config = HttpMiddlewareSettings::new()
.with_rate_limit(
HttpRateLimitSettings::default()
.with_enabled(true)
.with_key_source(RateLimitKeySourceSettings::Fixed("orders".into())),
)
.with_request_policy(
HttpRequestPolicy::disabled()
.with_default_rate_limit(RateLimitRequestPolicy::Enabled)
.into(),
)
.build()
.unwrap();
let build = |contract, config: HttpMiddlewareConfig| {
let mut stack = HttpMiddlewareStack::builder(config.clone());
if let Some(policy) = config.rate_limit() {
stack = stack.with_rate_limit_store(Arc::new(TokenBucketRateLimiter::new(
policy.limiter_config(),
)));
}
EndpointRouter::<()>::new()
.route(contract, || async { "ok" })
.unwrap()
.into_router(stack.build().unwrap())
};
assert!(build(contract.clone(), config.clone()).is_ok());
let exempt = contract
.clone()
.with_rate_limit(RateLimitRequestPolicy::Disabled);
assert!(matches!(
build(exempt.clone(), config),
Err(HttpMiddlewareError::EndpointContractRateLimitMismatch {
expected_enabled: false,
actual_enabled: true,
..
})
));
assert!(matches!(
build(contract, HttpMiddlewareConfig::minimal()),
Err(HttpMiddlewareError::EndpointContractRateLimitMismatch {
expected_enabled: true,
actual_enabled: false,
..
})
));
assert!(matches!(
build(
exempt
.clone()
.with_idempotency(IdempotencyRequestPolicy::Required),
HttpMiddlewareConfig::minimal()
),
Err(HttpMiddlewareError::EndpointContractIdempotencyMismatch { .. })
));
assert!(matches!(
build(
exempt.with_auth(EndpointAuth::Authenticated),
HttpMiddlewareConfig::minimal()
),
Err(HttpMiddlewareError::EndpointContractAuthenticationRequired { .. })
));
}
#[test]
fn get_contract_checks_implicit_head_unless_an_explicit_head_is_registered() {
let config = HttpMiddlewareSettings::new()
.with_rate_limit(
HttpRateLimitSettings::default()
.with_enabled(true)
.with_key_source(RateLimitKeySourceSettings::Fixed("health".into())),
)
.with_request_policy(
HttpRequestPolicy::disabled()
.with_rule(
HttpRouteRule::exact("/health")
.unwrap()
.methods([Method::GET])
.rate_limit(RateLimitRequestPolicy::Enabled),
)
.into(),
)
.build()
.unwrap();
let store = Arc::new(TokenBucketRateLimiter::new(
config.rate_limit().unwrap().limiter_config(),
));
let stack = HttpMiddlewareStack::builder(config)
.with_rate_limit_store(store)
.build()
.unwrap();
let get: EndpointContract =
EndpointContract::new(EndpointMethod::Get, EndpointPathPattern::exact("/health"))
.with_rate_limit(RateLimitRequestPolicy::Enabled);
let routes = EndpointRouter::<()>::new()
.route(get, || async { "ok" })
.unwrap();
assert!(matches!(
routes.clone().into_router(stack.clone()),
Err(HttpMiddlewareError::EndpointContractRateLimitMismatch {
method: EndpointMethod::Head,
..
})
));
let head = EndpointContract::new(EndpointMethod::Head, EndpointPathPattern::exact("/health"))
.with_rate_limit(RateLimitRequestPolicy::Disabled);
assert!(
routes
.route(head, || async {})
.unwrap()
.into_router(stack)
.is_ok()
);
}