cheers 0.1.0-alpha.1

Fullstack hypermedia framework for Rust.
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
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150

use axum::{
    body::Body,
    middleware::Next,
    response::{IntoResponse, Redirect},
};

pub async fn redirect_trailing_slash(
    req: axum::http::Request<Body>,
    next: Next,
) -> axum::response::Response {
    let uri = req.uri();
    let path = uri.path();

    if path == "/" || !path.ends_with('/') {
        return next.run(req).await;
    }

    let path = path.trim_end_matches('/');
    if path.is_empty() || path.starts_with("//") {
        return next.run(req).await;
    }

    let uri = if let Some(query) = uri.query() {
        format!("{}?{}", path, query)
    } else {
        path.to_owned()
    };
    Redirect::permanent(&uri).into_response()
}

#[cfg(test)]
mod tests {
    use axum::{Router, http::StatusCode, routing::get};
    use tower::ServiceExt;

    use super::*;

    const ROUTE: &str = "/api/v1/data";
    const RESPONSE: &str = "data";

    const ROOT_RESPONSE: &str = "root";

    fn app() -> Router {
        Router::new()
            .route("/", get(async || ROOT_RESPONSE))
            .route(ROUTE, get(async || RESPONSE))
            .layer(axum::middleware::from_fn(redirect_trailing_slash))
    }

    #[tokio::test]
    async fn no_trailing_slash_passes_through() {
        let app = app();

        let request = axum::http::Request::builder()
            .uri(ROUTE)
            .body(Body::empty())
            .expect("request should build");

        let response = app
            .clone()
            .oneshot(request)
            .await
            .expect("router should return a response");

        assert_eq!(response.status(), StatusCode::OK);

        let got = axum::body::to_bytes(response.into_body(), usize::MAX)
            .await
            .map(|b| String::from_utf8(b.into()))
            .expect("response body should be readable")
            .expect("response body should be valid UTF-8");
        assert_eq!(got, RESPONSE);
    }

    #[tokio::test]
    async fn trailing_slash_redirects_permanently() {
        let app = app();

        let request = axum::http::Request::builder()
            .uri(format!("{ROUTE}/"))
            .body(Body::empty())
            .expect("request should build");

        let response = app
            .clone()
            .oneshot(request)
            .await
            .expect("router should return a response");

        assert_eq!(response.status(), StatusCode::PERMANENT_REDIRECT);
        assert_eq!(
            response
                .headers()
                .get("location")
                .expect("redirect response should set location header"),
            ROUTE
        );
    }

    #[tokio::test]
    async fn trailing_slash_redirect_does_not_emit_scheme_relative_location() {
        let app = app();

        let request = axum::http::Request::builder()
            .uri("//evil.example/")
            .body(Body::empty())
            .expect("request should build");

        let response = app
            .clone()
            .oneshot(request)
            .await
            .expect("router should return a response");

        let location = response
            .headers()
            .get("location")
            .and_then(|value| value.to_str().ok())
            .unwrap_or_default();

        assert!(
            !location.starts_with("//"),
            "redirect Location must not be browser-interpreted as cross-origin: {location}"
        );
    }

    #[tokio::test]
    async fn can_access_root() {
        let app = app();

        let request = axum::http::Request::builder()
            .body(Body::empty())
            .expect("request should build");

        let response = app
            .clone()
            .oneshot(request)
            .await
            .expect("router should return a response");

        assert_eq!(response.status(), StatusCode::OK);

        let got = axum::body::to_bytes(response.into_body(), usize::MAX)
            .await
            .map(|b| String::from_utf8(b.into()))
            .expect("response body should be readable")
            .expect("response body should be valid UTF-8");
        assert_eq!(got, ROOT_RESPONSE);
    }
}