doido-controller 0.0.13

Action Controller + routing + Tower middleware for Doido: handlers, Context, responses, filters, routes! DSL, sessions, and middleware stacks.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86

use axum::{routing::get, Router};
use doido_controller::{CookieSessionStore, MiddlewareStack, SessionStore};
use http::{Request, StatusCode};
use tower::ServiceExt;

#[tokio::test]
async fn test_middleware_stack_processes_request() {
    let app = MiddlewareStack::new().apply(Router::new().route("/", get(|| async { "ok" })));
    let req = Request::builder()
        .uri("/")
        .body(axum::body::Body::empty())
        .unwrap();
    let resp = app.oneshot(req).await.unwrap();
    assert_eq!(resp.status(), StatusCode::OK);
}

#[tokio::test]
async fn test_logging_middleware_passes_response_through_unchanged() {
    // The request/response logging middleware must be transparent: the handler's
    // status and body reach the client untouched while the exchange is logged.
    let handler = || async { (StatusCode::IM_A_TEAPOT, "brewing") };
    let app = MiddlewareStack::new().apply(Router::new().route("/", get(handler)));
    let req = Request::builder()
        .uri("/")
        .body(axum::body::Body::empty())
        .unwrap();

    let resp = app.oneshot(req).await.unwrap();
    assert_eq!(resp.status(), StatusCode::IM_A_TEAPOT);

    let body = axum::body::to_bytes(resp.into_body(), usize::MAX)
        .await
        .unwrap();
    assert_eq!(&body[..], b"brewing");
}

#[tokio::test]
async fn test_logging_middleware_sets_request_id_header() {
    // With no inbound id, the middleware generates one and echoes it back so the
    // request and response log lines can be correlated by the same value.
    let app = MiddlewareStack::new().apply(Router::new().route("/", get(|| async { "ok" })));
    let req = Request::builder()
        .uri("/")
        .body(axum::body::Body::empty())
        .unwrap();

    let resp = app.oneshot(req).await.unwrap();
    let id = resp
        .headers()
        .get("x-request-id")
        .expect("x-request-id header present");
    assert!(!id.to_str().unwrap().is_empty());
}

#[tokio::test]
async fn test_logging_middleware_preserves_inbound_request_id() {
    // An upstream proxy's id must survive end to end.
    let app = MiddlewareStack::new().apply(Router::new().route("/", get(|| async { "ok" })));
    let req = Request::builder()
        .uri("/")
        .header("x-request-id", "upstream-123")
        .body(axum::body::Body::empty())
        .unwrap();

    let resp = app.oneshot(req).await.unwrap();
    let id = resp
        .headers()
        .get("x-request-id")
        .unwrap()
        .to_str()
        .unwrap();
    assert_eq!(id, "upstream-123");
}

#[tokio::test]
async fn test_cookie_session_store_load_returns_none() {
    let store = CookieSessionStore::default();
    // A bare, unsigned id is not a valid signed cookie, so it does not decode.
    assert!(store.load("any-id").await.unwrap().is_none());
}

#[tokio::test]
async fn test_session_store_is_object_safe() {
    let store: Box<dyn SessionStore> = Box::new(CookieSessionStore::default());
    assert!(store.load("x").await.unwrap().is_none());
}