footing 0.6.6

Feature-gated foundations for Rust backend services
Documentation
#![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",
            ]
        );
    }
}