use std::{
sync::{
Arc,
atomic::{AtomicUsize, Ordering},
},
time::Duration,
};
use axum::{
Router,
body::{Body, to_bytes},
http::{
HeaderMap, HeaderName, HeaderValue, Method, Request, StatusCode,
header::{ACCEPT_ENCODING, AUTHORIZATION, CONTENT_ENCODING, CONTENT_TYPE},
},
routing::post,
};
use tower::ServiceExt;
#[cfg(feature = "settings")]
use super::{
CorsMode, CorsSettings, ForwardedHeadersSettings, HttpFoundationSettings,
HttpIdempotencySettings, HttpRateLimitSettings, HttpRequestPolicySettings,
HttpRouteRuleSettings, IdempotencyRequestPolicySettings, RateLimitKeySourceSettings,
RateLimitRequestPolicySettings, RequestBodyLimitSettings, RouteMatcherSettings,
SecurityHeadersSettings, StrictTransportSecuritySettings,
};
use super::{
CorsPolicy, DEFAULT_HSTS_MAX_AGE, DEFAULT_HTTP_REQUEST_BODY_LIMIT, DEFAULT_HTTP_TIMEOUT,
ForwardedHeadersPolicy, HttpFoundation, HttpLayerConfig, HttpLayerError, HttpRequestPolicy,
HttpRouteRule, RequestBodyLimitPolicy, RouteMatcher, SecurityHeadersConfig,
};
use crate::http::{
EndpointAuth, EndpointContract, EndpointContractRegistry, EndpointIdempotency, EndpointMethod,
EndpointPathPattern, EndpointPermissions, EndpointRateLimit, EndpointRouteRegistration,
HttpAuthenticationHook, IdempotencyRequestPolicy, IdempotencyScope, MemoryIdempotencyStore,
MemoryRateLimitStore, RateLimitKeySource, RateLimitRequestPolicy, TrustedProxyConfig,
VerifiedAuthentication,
};
#[derive(Debug)]
struct HeaderAuthentication;
#[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)))
}
}
#[test]
fn restricted_cors_rejects_wildcards_in_settings_and_runtime_config() {
for credentials in [false, true] {
assert!(
HttpFoundationSettings::new()
.with_cors(CorsSettings::restricted(["*"]).with_credentials(credentials))
.build()
.is_err()
);
let cors = super::CorsConfig::from_origin_strs(["*"])
.unwrap()
.allow_credentials(credentials);
assert!(cors.validate().is_err());
}
let config = HttpFoundationSettings::new()
.with_cors(CorsSettings {
mode: CorsMode::Permissive,
..CorsSettings::default()
})
.build()
.unwrap();
let _: Router = HttpFoundation::builder(config)
.build()
.unwrap()
.apply(Router::new());
}
#[tokio::test]
async fn body_limits_above_axum_default_and_disabled_limits_are_honored() {
for limit in [Some(4 * 1024 * 1024), None] {
let config = HttpFoundationSettings::new()
.with_request_body_limit(limit)
.with_request_policy(HttpRequestPolicySettings::disabled())
.build()
.unwrap();
let app =
HttpFoundation::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 principal_rate_limiting_accepts_public_exempt_routes() {
let contracts = [
EndpointContract::new(EndpointMethod::Get, EndpointPathPattern::Exact("/health"))
.with_rate_limit(EndpointRateLimit::Exempt),
EndpointContract::new(EndpointMethod::Get, EndpointPathPattern::Exact("/private"))
.with_auth(EndpointAuth::Authenticated)
.with_permissions(EndpointPermissions::one("private:read")),
];
let routes = [
EndpointRouteRegistration::new(EndpointMethod::Get, EndpointPathPattern::Exact("/health")),
EndpointRouteRegistration::new(EndpointMethod::Get, EndpointPathPattern::Exact("/private")),
];
let config = HttpFoundationSettings::new()
.with_rate_limit(
HttpRateLimitSettings::default()
.with_enabled(true)
.with_key_source(RateLimitKeySourceSettings::PrincipalId),
)
.with_request_policy(HttpRequestPolicySettings::disabled().with_rule(
HttpRouteRuleSettings {
matcher: RouteMatcherSettings::Exact("/private".into()),
rate_limit: Some(RateLimitRequestPolicySettings::Enabled),
..HttpRouteRuleSettings::default()
},
))
.build()
.unwrap();
let store = Arc::new(MemoryRateLimitStore::new(
config.rate_limit().unwrap().limiter(),
));
let build = |contracts: &[_]| {
HttpFoundation::builder(config.clone())
.with_authentication_hook(Arc::new(HeaderAuthentication))
.with_rate_limit_store(store.clone())
.reconcile_endpoint_contracts(&EndpointContractRegistry::new(contracts), &routes)
.unwrap()
.build()
};
assert!(build(&contracts).is_ok());
let public_limited = [
contracts[0],
contracts[1]
.with_auth(EndpointAuth::Public)
.with_permissions(EndpointPermissions::public()),
];
assert!(matches!(
build(&public_limited),
Err(HttpLayerError::PublicEndpointPrincipalRateLimit { .. })
));
}
#[test]
fn builds_restricted_cors_config_from_origin_strings() {
let config = HttpFoundationSettings::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_negotiates_each_idempotent_replay_independently() {
let config = HttpFoundationSettings::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 = HttpFoundation::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 = HttpFoundationSettings::default().with_cors(CorsSettings {
mode: CorsMode::Restricted,
..CorsSettings::default()
});
assert!(settings.build().is_err());
}
#[test]
fn rejects_cors_credentials_with_wildcard_origin() {
let settings = HttpFoundationSettings::default()
.with_cors(CorsSettings::restricted(["*"]).with_credentials(true));
assert!(settings.build().is_err());
}
#[test]
fn rejects_invalid_layer_limits() {
assert!(
HttpFoundationSettings::default()
.with_timeout(Some(Duration::ZERO))
.build()
.is_err()
);
assert!(
HttpFoundationSettings::default()
.with_request_body_limit(Some(0))
.build()
.is_err()
);
}
#[test]
fn idempotency_processing_lease_must_outlive_request_timeout() {
let timeout = Duration::from_secs(30);
let invalid = HttpFoundationSettings::default()
.with_timeout(Some(timeout))
.with_idempotency(
HttpIdempotencySettings::default()
.with_enabled(true)
.with_processing_ttl(timeout),
);
assert!(invalid.build().is_err());
let valid = HttpFoundationSettings::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 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")
);
}
#[test]
fn standard_defaults_are_explicit_and_hsts_is_opt_in() {
let standard = HttpLayerConfig::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 = HttpFoundationSettings::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
);
}
#[cfg(feature = "settings")]
#[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(RateLimitRequestPolicySettings::Disabled),
idempotency: Some(IdempotencyRequestPolicySettings::Required),
request_body_limit: Some(RequestBodyLimitSettings::Bytes(512)),
});
settings
.validate_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()
);
}
#[cfg(feature = "settings")]
#[test]
fn request_policy_settings_report_route_paths() {
let settings = HttpRequestPolicySettings::default().with_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 error = settings
.validate_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"));
}
#[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 = HttpFoundationSettings::default()
.with_forwarded_headers(ForwardedHeadersSettings::always())
.with_request_body_limit(Some(4096))
.build()
.unwrap();
let foundation = HttpFoundation::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 = HttpFoundationSettings::default()
.with_rate_limit(HttpRateLimitSettings::default().with_enabled(true))
.build()
.unwrap();
assert!(matches!(
HttpFoundation::builder(config.clone()).build(),
Err(HttpLayerError::MissingRateLimitStore)
));
let limiter = config
.rate_limit()
.expect("rate limiting should be configured")
.limiter();
HttpFoundation::builder(config)
.with_rate_limit_store(Arc::new(MemoryRateLimitStore::new(limiter)))
.build()
.expect("explicit rate-limit storage should complete assembly");
}
#[test]
fn http_foundation_builder_requires_explicit_idempotency_store() {
let config = HttpFoundationSettings::default()
.with_idempotency(HttpIdempotencySettings::default().with_enabled(true))
.build()
.unwrap();
assert!(matches!(
HttpFoundation::builder(config.clone()).build(),
Err(HttpLayerError::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");
HttpFoundation::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 = TrustedProxyConfig::from_cidrs(["10.0.0.0/8"]).expect("CIDR should parse");
let config = HttpFoundationSettings::default()
.with_forwarded_headers(ForwardedHeadersSettings::trusted_proxies(["10.0.0.0/8"]))
.build()
.unwrap();
let foundation = HttpFoundation::builder(config).build().unwrap();
assert!(foundation.config().forwarded_headers_enabled());
assert_eq!(
foundation.config().forwarded_headers_policy(),
&ForwardedHeadersPolicy::TrustedProxies(proxies)
);
}
#[cfg(feature = "settings")]
#[test]
fn http_foundation_settings_adapt_to_runtime_config() {
let settings = HttpFoundationSettings::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")
);
}
#[cfg(feature = "settings")]
#[test]
fn http_foundation_settings_report_config_paths() {
let settings = HttpFoundationSettings::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"));
}
#[cfg(feature = "settings")]
#[test]
fn http_foundation_settings_report_short_idempotency_processing_lease() {
let timeout = Duration::from_secs(30);
let settings = HttpFoundationSettings::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"));
}
#[cfg(feature = "settings")]
#[test]
fn http_foundation_settings_report_nested_value_paths() {
let settings = HttpFoundationSettings::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"));
}
#[cfg(feature = "settings")]
#[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,
HttpLayerError::InvalidRateLimitKeySource {
field: "rate_limit.key_source"
}
));
}
#[cfg(feature = "settings")]
#[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 = HttpFoundationSettings::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(_))
));
}
#[cfg(feature = "settings")]
#[test]
fn http_layer_debug_redacts_invalid_values_and_fixed_keys() {
let private_value = "private-http-config-value";
let error = HttpLayerError::InvalidTrustedProxyCidr {
reason: private_value.to_owned(),
};
let settings = RateLimitKeySourceSettings::Fixed(private_value.to_owned());
let output = format!("{error:?} {error} {settings:?}");
assert!(output.contains("http_invalid_trusted_proxy_cidr"));
assert!(output.contains("[REDACTED]"));
assert!(!output.contains(private_value));
}
#[tokio::test]
async fn route_request_body_limit_rejects_oversized_matching_requests() {
let config = HttpFoundationSettings::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 = HttpFoundation::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 = HttpFoundationSettings::default()
.with_request_body_limit(Some(4))
.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()
}),
)
.build()
.unwrap();
let app = HttpFoundation::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 principal_rate_limiting_requires_ordered_authentication_hook() {
let config = HttpFoundationSettings::default()
.with_rate_limit(
HttpRateLimitSettings::default()
.with_enabled(true)
.with_key_source(RateLimitKeySourceSettings::PrincipalId),
)
.build()
.unwrap();
assert!(matches!(
HttpFoundation::builder(config).build(),
Err(HttpLayerError::MissingAuthenticationHook)
));
}
#[tokio::test]
async fn authentication_installs_principal_and_idempotency_scope_before_policies() {
let request_policy =
HttpRequestPolicy::default().with_default_idempotency(IdempotencyRequestPolicy::Required);
let config = HttpFoundationSettings::default()
.with_rate_limit(
HttpRateLimitSettings::default()
.with_enabled(true)
.with_capacity(1)
.with_refill_tokens(1)
.with_refill_interval(Duration::from_secs(60))
.with_key_source(RateLimitKeySourceSettings::PrincipalId),
)
.with_idempotency(HttpIdempotencySettings::default().with_enabled(true))
.with_request_policy(HttpRequestPolicySettings::from(request_policy))
.build()
.unwrap();
let limiter = config.rate_limit().unwrap().limiter();
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 = HttpFoundation::builder(config)
.with_authentication_hook(Arc::new(HeaderAuthentication))
.with_rate_limit_store(Arc::new(MemoryRateLimitStore::new(limiter)))
.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 = HttpFoundation::builder(
HttpFoundationSettings::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 = HttpFoundationSettings::default()
.with_rate_limit(
HttpRateLimitSettings::default()
.with_enabled(true)
.with_capacity(1)
.with_key_source(RateLimitKeySourceSettings::Fixed("all".to_owned())),
)
.build()
.unwrap();
let limiter = rate_config.rate_limit().unwrap().limiter();
let rate_limited = HttpFoundation::builder(rate_config)
.with_rate_limit_store(Arc::new(MemoryRateLimitStore::new(limiter)))
.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 = HttpFoundationSettings::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 = HttpFoundation::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 = HttpFoundation::builder(
HttpFoundationSettings::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 reconciled_contracts_validate_policies_in_both_directions() {
let routes = [EndpointRouteRegistration::new(
EndpointMethod::Post,
EndpointPathPattern::Exact("/orders"),
)];
let enabled_contracts: [EndpointContract; 1] = [EndpointContract::new(
EndpointMethod::Post,
EndpointPathPattern::Exact("/orders"),
)];
let enabled_registry = EndpointContractRegistry::new(&enabled_contracts);
let request_policy =
HttpRequestPolicy::default().with_default_idempotency(IdempotencyRequestPolicy::Disabled);
let enabled_config = HttpFoundationSettings::default()
.with_rate_limit(
HttpRateLimitSettings::default()
.with_enabled(true)
.with_key_source(RateLimitKeySourceSettings::Fixed("orders".to_owned())),
)
.with_request_policy(HttpRequestPolicySettings::from(request_policy))
.build()
.unwrap();
let limiter = enabled_config.rate_limit().unwrap().limiter();
HttpFoundation::builder(enabled_config.clone())
.reconcile_endpoint_contracts(&enabled_registry, &routes)
.unwrap()
.with_rate_limit_store(Arc::new(MemoryRateLimitStore::new(limiter)))
.build()
.expect("matching route and policy should build");
let exempt_contracts: [EndpointContract; 1] =
[enabled_contracts[0].with_rate_limit(EndpointRateLimit::Exempt)];
let exempt_registry = EndpointContractRegistry::new(&exempt_contracts);
assert!(matches!(
HttpFoundation::builder(enabled_config)
.reconcile_endpoint_contracts(&exempt_registry, &routes)
.unwrap()
.build(),
Err(HttpLayerError::EndpointContractRateLimitMismatch {
expected_enabled: false,
actual_enabled: true,
..
})
));
assert!(matches!(
HttpFoundation::builder(HttpLayerConfig::minimal())
.reconcile_endpoint_contracts(&enabled_registry, &routes)
.unwrap()
.build(),
Err(HttpLayerError::EndpointContractRateLimitMismatch {
expected_enabled: true,
actual_enabled: false,
..
})
));
let idempotent_contracts: [EndpointContract; 1] =
[exempt_contracts[0].with_idempotency(EndpointIdempotency::Required)];
let idempotent_registry = EndpointContractRegistry::new(&idempotent_contracts);
assert!(matches!(
HttpFoundation::builder(HttpLayerConfig::minimal())
.reconcile_endpoint_contracts(&idempotent_registry, &routes)
.unwrap()
.build(),
Err(HttpLayerError::EndpointContractIdempotencyMismatch { .. })
));
}
#[test]
fn reconciled_identity_contract_requires_ordered_authentication() {
let contracts =
[
EndpointContract::new(EndpointMethod::Post, EndpointPathPattern::Exact("/orders"))
.with_auth(EndpointAuth::Authenticated)
.with_permissions(EndpointPermissions::one("orders:write"))
.with_rate_limit(EndpointRateLimit::Exempt),
];
let routes = [EndpointRouteRegistration::new(
EndpointMethod::Post,
EndpointPathPattern::Exact("/orders"),
)];
let registry = EndpointContractRegistry::new(&contracts);
assert!(matches!(
HttpFoundation::builder(HttpLayerConfig::minimal())
.reconcile_endpoint_contracts(®istry, &routes)
.unwrap()
.build(),
Err(HttpLayerError::EndpointContractAuthenticationRequired { .. })
));
}