autumn-web 0.2.0

An opinionated, convention-over-configuration web framework for Rust
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
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

//! Tests for static file serving.

use axum::Router;
use axum::body::Body;
use axum::http::{Request, StatusCode};
use tower::ServiceExt;
use tower_http::services::ServeDir;

#[tokio::test]
async fn serves_static_files_with_correct_mime_type() {
    let dir = tempfile::tempdir().unwrap();
    let css_dir = dir.path().join("css");
    std::fs::create_dir_all(&css_dir).unwrap();
    std::fs::write(css_dir.join("test.css"), "body { color: red; }").unwrap();

    let app = Router::new().nest_service("/static", ServeDir::new(dir.path()));

    let response = app
        .oneshot(
            Request::builder()
                .uri("/static/css/test.css")
                .body(Body::empty())
                .unwrap(),
        )
        .await
        .unwrap();

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

    let content_type = response
        .headers()
        .get("content-type")
        .unwrap()
        .to_str()
        .unwrap();
    assert!(
        content_type.contains("text/css"),
        "Expected text/css, got {content_type}"
    );

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

#[tokio::test]
async fn missing_file_returns_404() {
    let dir = tempfile::tempdir().unwrap();
    let app = Router::new().nest_service("/static", ServeDir::new(dir.path()));

    let response = app
        .oneshot(
            Request::builder()
                .uri("/static/nonexistent.txt")
                .body(Body::empty())
                .unwrap(),
        )
        .await
        .unwrap();

    assert_eq!(response.status(), StatusCode::NOT_FOUND);
}

#[tokio::test]
async fn serves_subdirectories() {
    let dir = tempfile::tempdir().unwrap();
    let img_dir = dir.path().join("images").join("icons");
    std::fs::create_dir_all(&img_dir).unwrap();
    std::fs::write(img_dir.join("favicon.ico"), [0u8; 10]).unwrap();

    let app = Router::new().nest_service("/static", ServeDir::new(dir.path()));

    let response = app
        .oneshot(
            Request::builder()
                .uri("/static/images/icons/favicon.ico")
                .body(Body::empty())
                .unwrap(),
        )
        .await
        .unwrap();

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

#[tokio::test]
async fn missing_static_directory_returns_404() {
    // ServeDir pointed at a non-existent directory should 404, not panic
    let app = Router::new().nest_service("/static", ServeDir::new("this_directory_does_not_exist"));

    let response = app
        .oneshot(
            Request::builder()
                .uri("/static/anything.txt")
                .body(Body::empty())
                .unwrap(),
        )
        .await
        .unwrap();

    assert_eq!(response.status(), StatusCode::NOT_FOUND);
}

#[tokio::test]
async fn explicit_route_takes_priority_over_serve_dir() {
    // Simulate the htmx route priority: an explicit route at the same path
    // as a file on disk should win.
    let dir = tempfile::tempdir().unwrap();
    let js_dir = dir.path().join("js");
    std::fs::create_dir_all(&js_dir).unwrap();
    std::fs::write(js_dir.join("htmx.min.js"), b"// disk version").unwrap();

    let embedded: &[u8] = b"// embedded version";

    let app = Router::new()
        .route(
            "/static/js/htmx.min.js",
            axum::routing::get(move || async move {
                (
                    [(http::header::CONTENT_TYPE, "application/javascript")],
                    embedded,
                )
            }),
        )
        .nest_service("/static", ServeDir::new(dir.path()));

    let response = app
        .oneshot(
            Request::builder()
                .uri("/static/js/htmx.min.js")
                .body(Body::empty())
                .unwrap(),
        )
        .await
        .unwrap();

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

    let body = axum::body::to_bytes(response.into_body(), usize::MAX)
        .await
        .unwrap();

    // Explicit route wins over disk file
    assert_eq!(&body[..], b"// embedded version");
}