mini-static 0.20.0

A secure, async static file server with streaming, traversal protection, and connection limits.
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
147
148
149
150
151
152
153

use super::*;

#[test]
fn reload_event_frame_formats_css_correctly() {
    let frame = reload_event_frame(&ChangeType::Css);
    let s = String::from_utf8(frame.to_vec()).unwrap();
    assert_eq!(s, "event: css\ndata: {\"type\":\"css\"}\n\n");
}

#[test]
fn reload_event_frame_formats_script_correctly() {
    let frame = reload_event_frame(&ChangeType::Script);
    let s = String::from_utf8(frame.to_vec()).unwrap();
    assert_eq!(s, "event: script\ndata: {\"type\":\"script\"}\n\n");
}

#[test]
fn reload_event_frame_formats_html_correctly() {
    let frame = reload_event_frame(&ChangeType::Html);
    let s = String::from_utf8(frame.to_vec()).unwrap();
    assert_eq!(s, "event: html\ndata: {\"type\":\"html\"}\n\n");
}

#[test]
fn reload_event_frame_formats_other_correctly() {
    let frame = reload_event_frame(&ChangeType::Other);
    let s = String::from_utf8(frame.to_vec()).unwrap();
    assert_eq!(s, "event: other\ndata: {\"type\":\"other\"}\n\n");
}

#[test]
fn change_type_from_path_css() {
    assert_eq!(
        ChangeType::from_path(Path::new("style.css")),
        ChangeType::Css
    );
    assert_eq!(
        ChangeType::from_path(Path::new("dir/main.css")),
        ChangeType::Css
    );
}

#[test]
fn change_type_from_path_script() {
    assert_eq!(
        ChangeType::from_path(Path::new("app.js")),
        ChangeType::Script
    );
    assert_eq!(
        ChangeType::from_path(Path::new("mod.mjs")),
        ChangeType::Script
    );
    assert_eq!(
        ChangeType::from_path(Path::new("dir/lib.js")),
        ChangeType::Script
    );
}

#[test]
fn change_type_from_path_html() {
    assert_eq!(
        ChangeType::from_path(Path::new("index.html")),
        ChangeType::Html
    );
    assert_eq!(
        ChangeType::from_path(Path::new("page.htm")),
        ChangeType::Html
    );
    assert_eq!(
        ChangeType::from_path(Path::new("dir/file.html")),
        ChangeType::Html
    );
}

#[test]
fn change_type_from_path_other() {
    assert_eq!(
        ChangeType::from_path(Path::new("image.png")),
        ChangeType::Other
    );
    assert_eq!(
        ChangeType::from_path(Path::new("data.json")),
        ChangeType::Other
    );
    assert_eq!(
        ChangeType::from_path(Path::new("README")),
        ChangeType::Other
    );
}

#[test]
fn reload_script_tag_embeds_the_live_reload_path() {
    // Disproves hardcoding a divergent path literal in the script: if someone edits
    // `LIVE_RELOAD_PATH` without updating `reload_script_tag()`, the injected client
    // would open an `EventSource` to a path the server never serves.
    assert!(reload_script_tag().contains(LIVE_RELOAD_PATH));
}

#[test]
fn inject_reload_script_inserts_before_closing_body_tag() {
    let mut html = b"<html><body><h1>hi</h1></body></html>".to_vec();
    inject_reload_script(&mut html);
    let s = String::from_utf8(html).unwrap();

    assert!(s.starts_with("<html><body><h1>hi</h1>"));
    assert!(s.ends_with("</body></html>"));
    assert!(s.contains(LIVE_RELOAD_PATH));
    // The script must land strictly before the closing tag, not after it.
    assert!(s.find("<script>").unwrap() < s.find("</body>").unwrap());
}

#[test]
fn inject_reload_script_handles_uppercase_closing_tag() {
    let mut html = b"<HTML><BODY>hi</BODY></HTML>".to_vec();
    inject_reload_script(&mut html);
    let s = String::from_utf8(html).unwrap();

    assert!(s.find("<script>").unwrap() < s.find("</BODY>").unwrap());
}

#[test]
fn inject_reload_script_appends_when_no_body_tag_present() {
    let mut html = b"<h1>fragment, no body tag</h1>".to_vec();
    inject_reload_script(&mut html);
    let s = String::from_utf8(html).unwrap();

    assert!(s.starts_with("<h1>fragment, no body tag</h1>"));
    assert!(s.ends_with("</script>"));
}

#[tokio::test]
async fn sse_body_yields_a_frame_per_broadcast_event() {
    use crate::watcher::Broadcaster;
    use http_body_util::BodyExt;
    use std::path::PathBuf;

    let broadcaster = Broadcaster::new();
    let rx = broadcaster.subscribe();
    let mut body = SseBody::new(rx);

    broadcaster.broadcast(ChangeEvent {
        path: PathBuf::from("style.css"),
        change_type: ChangeType::Css,
    });

    let frame = body
        .frame()
        .await
        .expect("stream ended early")
        .expect("frame error");
    let data = frame.into_data().unwrap();
    assert_eq!(&data[..], b"event: css\ndata: {\"type\":\"css\"}\n\n");
}