mini-static 0.18.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
154

//! End-to-end tests against the real `lightningcss`/`esbuild` binaries.
//!
//! Not part of the default `cargo test` run — every test here is `#[ignore]`d because
//! it depends on external tools this crate does not install or manage. Run with:
//!
//! ```sh
//! npm install -g lightningcss-cli esbuild
//! cargo test -p mini-static --test real_tools -- --ignored
//! ```

use std::fs;
use std::time::Duration;

use mini_static::{CssOptions, CssTool, JsOptions, JsTool, Server};
use tempfile::TempDir;

#[tokio::test]
#[ignore = "requires lightningcss on PATH"]
async fn css_bundle_and_minify_produces_minified_concatenated_output() {
    let src = TempDir::new().unwrap();
    let out = TempDir::new().unwrap();
    fs::write(
        src.path().join("reset.css"),
        "* {\n  margin: 0;\n  padding: 0;\n}\n",
    )
    .unwrap();
    fs::write(
        src.path().join("theme.css"),
        "body {\n  background: white;\n}\n",
    )
    .unwrap();

    let server = Server::new(out.path())
        .unwrap()
        .with_source_folder(src.path())
        .unwrap()
        .with_css_tool(
            CssTool::LightningCss,
            CssOptions::new().bundle(true).minify(true),
        );
    let (_port, handle) = server.run_ephemeral().await.unwrap();

    tokio::time::sleep(Duration::from_millis(300)).await;

    let content = fs::read_to_string(out.path().join("styles.css")).unwrap();
    assert!(content.contains("margin"), "expected reset CSS in bundle");
    assert!(
        content.contains("background"),
        "expected theme CSS in bundle"
    );
    assert!(
        !content.contains('\n'),
        "minified output should not contain source formatting newlines, got: {content}"
    );

    handle.shutdown().await;
}

#[tokio::test]
#[ignore = "requires lightningcss on PATH"]
async fn prune_output_removes_stale_css_bundle_when_no_css_sources_remain() {
    let src = TempDir::new().unwrap();
    let out = TempDir::new().unwrap();
    fs::write(out.path().join("styles.css"), "/* stale */").unwrap();

    let server = Server::new(out.path())
        .unwrap()
        .with_source_folder(src.path())
        .unwrap()
        .with_css_tool(CssTool::LightningCss, CssOptions::new().bundle(true))
        .with_prune_output();
    let (_port, handle) = server.run_ephemeral().await.unwrap();

    tokio::time::sleep(Duration::from_millis(200)).await;

    assert!(
        !out.path().join("styles.css").exists(),
        "prune is opt-in: with_prune_output should delete the stale bundle produced by no css sources"
    );

    handle.shutdown().await;
}

#[tokio::test]
#[ignore = "requires esbuild on PATH"]
async fn js_bundle_and_minify_resolves_the_entrys_module_graph() {
    let src = TempDir::new().unwrap();
    let out = TempDir::new().unwrap();
    fs::write(
        src.path().join("util.js"),
        "export function greet(name) { return 'hello ' + name; }\n",
    )
    .unwrap();
    let entry = src.path().join("main.js");
    fs::write(
        &entry,
        "import { greet } from './util.js';\nconsole.log(greet('world'));\n",
    )
    .unwrap();

    let server = Server::new(out.path())
        .unwrap()
        .with_source_folder(src.path())
        .unwrap()
        .with_js_tool(
            JsTool::Esbuild,
            JsOptions::new()
                .bundle_entry(&entry, "bundle.js")
                .minify(true),
        )
        .unwrap();
    let (_port, handle) = server.run_ephemeral().await.unwrap();

    tokio::time::sleep(Duration::from_millis(300)).await;

    let content = fs::read_to_string(out.path().join("bundle.js")).unwrap();
    assert!(
        content.contains("hello"),
        "bundle should inline the imported module's code, got: {content}"
    );
    assert!(
        !content.contains("import "),
        "a bundled entry should have no remaining import statements, got: {content}"
    );

    handle.shutdown().await;
}

#[tokio::test]
#[ignore = "requires esbuild on PATH"]
async fn malformed_js_source_degrades_to_raw_output() {
    let src = TempDir::new().unwrap();
    let out = TempDir::new().unwrap();
    let malformed = b"function( {{{ !!!";
    fs::write(src.path().join("broken.js"), malformed).unwrap();

    let server = Server::new(out.path())
        .unwrap()
        .with_source_folder(src.path())
        .unwrap()
        .with_js_tool(JsTool::Esbuild, JsOptions::new().minify(true))
        .unwrap();
    let (_port, handle) = server.run_ephemeral().await.unwrap();

    tokio::time::sleep(Duration::from_millis(300)).await;

    let out_js = fs::read(out.path().join("broken.js")).unwrap();
    assert_eq!(
        out_js, malformed,
        "a file esbuild cannot parse must still be mirrored (raw) so the page stays in sync"
    );

    handle.shutdown().await;
}