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

use super::*;
use tempfile::TempDir;

#[tokio::test]
async fn bundle_mode_concatenates_discovered_files_in_sorted_order() {
    let src = TempDir::new().unwrap();
    let out = TempDir::new().unwrap();
    let output = out.path().join("styles.css");

    fs::write(src.path().join("a.css"), "A").unwrap();
    fs::write(src.path().join("b.css"), "B").unwrap();

    let options = CssOptions::new().bundle(true).minify(true);
    build_css_bundle(
        CssTool::TestEcho,
        &options,
        &[src.path().to_path_buf()],
        &output,
    )
    .await
    .unwrap();

    let content = fs::read_to_string(&output).unwrap();
    assert_eq!(content, "AB", "files must concatenate in sorted path order");
}

#[tokio::test]
async fn bundle_false_minify_false_is_a_passthrough_copy() {
    let src = TempDir::new().unwrap();
    let out = TempDir::new().unwrap();
    let output = out.path().join("styles.css");

    fs::write(src.path().join("only.css"), "body{color:red}").unwrap();

    let options = CssOptions::new();
    build_css_bundle(
        CssTool::TestMissing,
        &options,
        &[src.path().to_path_buf()],
        &output,
    )
    .await
    .unwrap();

    assert_eq!(fs::read_to_string(&output).unwrap(), "body{color:red}");
}

#[tokio::test]
async fn no_css_files_is_an_error() {
    let src = TempDir::new().unwrap();
    let out = TempDir::new().unwrap();
    let output = out.path().join("styles.css");

    let result = build_css_bundle(
        CssTool::TestEcho,
        &CssOptions::new().bundle(true),
        &[src.path().to_path_buf()],
        &output,
    )
    .await;

    assert!(matches!(result, Err(CssError::NoFilesFound(_))));
}

#[tokio::test]
async fn a_failing_tool_leaves_previous_bundle_output_untouched() {
    let src = TempDir::new().unwrap();
    let out = TempDir::new().unwrap();
    let output = out.path().join("styles.css");
    fs::write(&output, "/* previous good build */").unwrap();
    fs::write(src.path().join("a.css"), "A").unwrap();

    let result = build_css_bundle(
        CssTool::TestMissing,
        &CssOptions::new().bundle(true).minify(true),
        &[src.path().to_path_buf()],
        &output,
    )
    .await;

    assert!(result.is_err());
    assert_eq!(
        fs::read_to_string(&output).unwrap(),
        "/* previous good build */",
        "a failed rebuild must not overwrite the previous good bundle"
    );
}

#[tokio::test]
async fn per_file_mode_with_minify_false_copies_through_unchanged() {
    let src = TempDir::new().unwrap();
    let out = TempDir::new().unwrap();
    let source = src.path().join("app.css");
    let output = out.path().join("app.css");
    fs::write(&source, "body{color:blue}").unwrap();

    build_css_file(CssTool::TestMissing, &CssOptions::new(), &source, &output)
        .await
        .unwrap();

    assert_eq!(fs::read_to_string(&output).unwrap(), "body{color:blue}");
}

#[tokio::test]
async fn per_file_mode_already_minified_skips_the_tool() {
    let src = TempDir::new().unwrap();
    let out = TempDir::new().unwrap();
    let source = src.path().join("app.min.css");
    let output = out.path().join("app.min.css");
    fs::write(&source, "body{color:blue}").unwrap();

    // TestMissing would error if invoked; success proves the tool was skipped.
    build_css_file(
        CssTool::TestMissing,
        &CssOptions::new().minify(true),
        &source,
        &output,
    )
    .await
    .unwrap();

    assert_eq!(fs::read_to_string(&output).unwrap(), "body{color:blue}");
}

#[tokio::test]
async fn per_file_mode_degrades_to_raw_copy_when_the_tool_fails() {
    let src = TempDir::new().unwrap();
    let out = TempDir::new().unwrap();
    let source = src.path().join("app.css");
    let output = out.path().join("app.css");
    fs::write(&source, "body{color:blue}").unwrap();

    build_css_file(
        CssTool::TestMissing,
        &CssOptions::new().minify(true),
        &source,
        &output,
    )
    .await
    .unwrap();

    assert_eq!(
        fs::read_to_string(&output).unwrap(),
        "body{color:blue}",
        "a failing tool must degrade to serving the raw source, not fail the pipeline"
    );
}