#![cfg(feature = "http-stack")]
use std::time::Duration;
use axum::{
Router,
body::{Body, to_bytes},
http::{Method, Request, StatusCode, header},
routing::get,
};
use footing::{
http::{
HttpIdempotencySettings, HttpMiddlewareSettings, HttpMiddlewareStack, HttpRequestPolicy,
HttpRequestPolicySettings, HttpRouteRule, IdempotencyRequestPolicy, ProblemDetails,
REQUEST_ID_HEADER_NAME, RequestBodyLimitPolicy, ResponseTimeout,
},
settings::SettingsValidationError,
};
use serde_json::json;
use tower::ServiceExt;
fn settings(policy: HttpRequestPolicy) -> HttpMiddlewareSettings {
HttpMiddlewareSettings::default()
.with_trace(false)
.with_compression(false)
.with_request_policy(policy.into())
}
fn apply(policy: HttpRequestPolicy, router: Router) -> Router {
HttpMiddlewareStack::builder(settings(policy).build().unwrap())
.build()
.unwrap()
.apply(router)
}
fn after(seconds: u64) -> ResponseTimeout {
ResponseTimeout::After(Duration::from_secs(seconds))
}
fn paths(result: Result<(), SettingsValidationError>) -> Vec<String> {
result
.unwrap_err()
.issues()
.iter()
.map(|issue| issue.path().to_owned())
.collect()
}
async fn delayed_response() -> &'static str {
tokio::time::sleep(Duration::from_secs(7)).await;
"completed"
}
#[tokio::test(start_paused = true)]
async fn route_deadlines_override_the_default_in_both_directions_or_disable_it() {
let policy = HttpRequestPolicy::default()
.with_default_timeout(after(5))
.with_rule(HttpRouteRule::exact("/short").unwrap().timeout(after(1)))
.with_rule(HttpRouteRule::exact("/long").unwrap().timeout(after(10)))
.with_rule(
HttpRouteRule::exact("/unbounded")
.unwrap()
.timeout(ResponseTimeout::Disabled),
);
let app = apply(
policy,
Router::new()
.route("/default", get(delayed_response))
.route("/short", get(delayed_response))
.route("/long", get(delayed_response))
.route("/unbounded", get(delayed_response)),
);
for (path, expected_status, elapsed_seconds) in [
("/default", StatusCode::SERVICE_UNAVAILABLE, 5),
("/short", StatusCode::SERVICE_UNAVAILABLE, 1),
("/long", StatusCode::OK, 7),
("/unbounded", StatusCode::OK, 7),
] {
let started = tokio::time::Instant::now();
let response = app
.clone()
.oneshot(
Request::get(path)
.header(REQUEST_ID_HEADER_NAME, "route-timeout-request")
.body(Body::empty())
.unwrap(),
)
.await
.unwrap();
assert_eq!(response.status(), expected_status, "{path}");
assert!(started.elapsed() >= Duration::from_secs(elapsed_seconds));
assert!(started.elapsed() < Duration::from_secs(elapsed_seconds + 1));
if expected_status == StatusCode::SERVICE_UNAVAILABLE {
assert_eq!(response.headers()[header::CACHE_CONTROL], "no-store");
assert_eq!(
response.headers()[REQUEST_ID_HEADER_NAME],
"route-timeout-request"
);
let problem: ProblemDetails =
serde_json::from_slice(&to_bytes(response.into_body(), 4096).await.unwrap())
.unwrap();
assert_eq!(problem.code(), "response_timeout");
assert_eq!(problem.request_id(), Some("route-timeout-request"));
} else {
assert_eq!(
to_bytes(response.into_body(), 4096).await.unwrap(),
"completed"
);
}
}
}
#[tokio::test(start_paused = true)]
async fn a_route_can_enable_a_deadline_when_the_default_is_disabled() {
let app = apply(
HttpRequestPolicy::disabled()
.with_rule(HttpRouteRule::exact("/bounded").unwrap().timeout(after(1))),
Router::new()
.route("/bounded", get(delayed_response))
.route("/unbounded", get(delayed_response)),
);
for (path, expected) in [
("/bounded", StatusCode::SERVICE_UNAVAILABLE),
("/unbounded", StatusCode::OK),
] {
let response = app
.clone()
.oneshot(Request::get(path).body(Body::empty()).unwrap())
.await
.unwrap();
assert_eq!(response.status(), expected);
}
}
#[tokio::test(start_paused = true)]
async fn timeout_rules_use_matched_route_templates_and_method_filters() {
let app = apply(
HttpRequestPolicy::default()
.with_default_timeout(after(10))
.with_rule(
HttpRouteRule::exact("/reports/{report_id}")
.unwrap()
.methods([Method::GET])
.timeout(after(1)),
),
Router::new().route(
"/reports/{report_id}",
get(delayed_response).post(delayed_response),
),
);
for (method, expected) in [
(Method::GET, StatusCode::SERVICE_UNAVAILABLE),
(Method::POST, StatusCode::OK),
] {
let response = app
.clone()
.oneshot(
Request::builder()
.method(method)
.uri("/reports/42?format=csv")
.body(Body::empty())
.unwrap(),
)
.await
.unwrap();
assert_eq!(response.status(), expected);
}
}
#[tokio::test(start_paused = true)]
async fn the_last_matching_rule_inherits_only_global_defaults() {
let app = apply(
HttpRequestPolicy::default()
.with_default_timeout(after(10))
.with_rule(HttpRouteRule::prefix("/api").unwrap().timeout(after(1)))
.with_rule(
HttpRouteRule::exact("/api/upload")
.unwrap()
.request_body_limit(RequestBodyLimitPolicy::bytes(64).unwrap()),
),
Router::new()
.route("/api/upload", get(delayed_response))
.route("/api/query", get(delayed_response)),
);
for (path, expected) in [
("/api/upload", StatusCode::OK),
("/api/query", StatusCode::SERVICE_UNAVAILABLE),
] {
let response = app
.clone()
.oneshot(Request::get(path).body(Body::empty()).unwrap())
.await
.unwrap();
assert_eq!(response.status(), expected);
}
}
fn idempotent_settings(policy: HttpRequestPolicy) -> HttpMiddlewareSettings {
settings(policy).with_idempotency(
HttpIdempotencySettings::default()
.with_enabled(true)
.with_processing_ttl(Duration::from_secs(5)),
)
}
#[test]
fn idempotent_defaults_and_routes_require_deadlines_strictly_inside_the_lease() {
for timeout in [ResponseTimeout::Disabled, after(5), after(6)] {
assert_eq!(
paths(
idempotent_settings(HttpRequestPolicy::default().with_default_timeout(timeout))
.validate()
),
["http.request_policy.default_timeout"]
);
let policy = HttpRequestPolicy::default()
.with_default_timeout(after(4))
.with_rule(HttpRouteRule::exact("/orders").unwrap().timeout(timeout));
assert_eq!(
paths(idempotent_settings(policy).validate_at("server")),
["server.request_policy.rules.0.timeout"]
);
}
let policy = HttpRequestPolicy::default()
.with_default_timeout(after(4))
.with_rule(HttpRouteRule::exact("/orders").unwrap().timeout(after(1)))
.with_rule(HttpRouteRule::exact("/orders/inherit").unwrap());
assert!(idempotent_settings(policy).build().is_ok());
}
#[test]
fn routes_without_idempotency_can_disable_or_extend_the_response_deadline() {
let policy = HttpRequestPolicy::default()
.with_default_timeout(after(4))
.with_rule(
HttpRouteRule::exact("/stream")
.unwrap()
.idempotency(IdempotencyRequestPolicy::Disabled)
.timeout(ResponseTimeout::Disabled),
)
.with_rule(
HttpRouteRule::exact("/export")
.unwrap()
.idempotency(IdempotencyRequestPolicy::Disabled)
.timeout(after(60)),
);
assert!(idempotent_settings(policy).build().is_ok());
let policy = HttpRequestPolicy::disabled().with_rule(
HttpRouteRule::exact("/orders")
.unwrap()
.idempotency(IdempotencyRequestPolicy::Required)
.timeout(after(4)),
);
assert!(idempotent_settings(policy).build().is_ok());
assert_eq!(
paths(
idempotent_settings(
HttpRequestPolicy::disabled().with_rule(
HttpRouteRule::exact("/orders")
.unwrap()
.idempotency(IdempotencyRequestPolicy::Required)
)
)
.validate()
),
["http.request_policy.rules.0.timeout"]
);
}
#[test]
fn overlapping_rules_cannot_disable_idempotency_to_bypass_lease_validation() {
let policy = HttpRequestPolicy::default()
.with_default_timeout(after(4))
.with_rule(
HttpRouteRule::prefix("/api")
.unwrap()
.idempotency(IdempotencyRequestPolicy::Disabled)
.timeout(ResponseTimeout::Disabled),
)
.with_rule(
HttpRouteRule::exact("/api/orders")
.unwrap()
.timeout(after(60)),
);
assert_eq!(
paths(idempotent_settings(policy).validate()),
["http.request_policy.rules.1.timeout"]
);
}
#[test]
fn timeout_settings_preserve_inherit_disabled_and_duration_values() {
let settings: HttpRequestPolicySettings = serde_json::from_value(json!({
"default_timeout": {"mode": "after", "duration": "1m 30s"},
"rules": [
{"matcher": {"type": "exact", "value": "/inherit"}},
{"matcher": {"type": "exact", "value": "/unbounded"}, "timeout": {"mode": "disabled"}},
{"matcher": {"type": "exact", "value": "/short"}, "timeout": {"mode": "after", "duration": "250ms"}}
]
}))
.unwrap();
let serialized = serde_json::to_value(&settings).unwrap();
assert_eq!(
serialized["default_timeout"],
json!({"mode": "after", "duration": "90s"})
);
assert_eq!(serialized["rules"][0]["timeout"], serde_json::Value::Null);
assert_eq!(
serialized["rules"][1]["timeout"],
json!({"mode": "disabled"})
);
assert_eq!(
serde_json::from_value::<HttpRequestPolicySettings>(serialized).unwrap(),
settings
);
let policy = HttpRequestPolicy::try_from(&settings).unwrap();
for (path, timeout) in [
("/inherit", after(90)),
("/unbounded", ResponseTimeout::Disabled),
("/short", ResponseTimeout::After(Duration::from_millis(250))),
] {
assert_eq!(
policy.policy_for_route(&Method::GET, path).timeout(),
timeout
);
}
for invalid in [
json!({"mode": "after"}),
json!({"mode": "after", "duration": 1}),
json!({"mode": "after", "duration": "1 fortnight"}),
json!({"mode": "disabled", "duraton": "1s"}),
] {
assert!(serde_json::from_value::<ResponseTimeout>(invalid).is_err());
}
}
#[test]
fn invalid_deadlines_report_default_and_route_field_locations() {
for duration in [Duration::ZERO, Duration::MAX] {
let policy = HttpRequestPolicy::default()
.with_default_timeout(ResponseTimeout::After(duration))
.with_rule(HttpRouteRule::any().timeout(ResponseTimeout::After(duration)));
assert_eq!(
paths(settings(policy).validate_at("server.http")),
[
"server.http.request_policy.default_timeout",
"server.http.request_policy.rules.0.timeout",
]
);
}
}