Extract get_router and add simple test.

This PR extracts the logic from `run_server` that creates a new Router
into a helper function named `get_router` to make it easier to test
without needing to start the full server.

This also adds a simple test that verifies current behavior for
returning a br compressed wasm.wasm file.

This change is in preparation for adding support dynamically change the
available compression.

Author: heisencoder

Cargo.toml

@@ -25,3 +25,7 @@ tower = "0.4"
 fastrand = "1.5"
 brotli = { version = "3", default-features = false, features = ["std"]}
 rcgen = { version = "0.9", default-features = false }
+
+[dev-dependencies]
+tokio-test = "0.4"
+axum-test-helper = "0.1"

src/server.rs

@@ -2,7 +2,7 @@ use std::collections::HashMap;
 use std::net::SocketAddr;
 
 use axum::headers::HeaderName;
-use axum::http::{HeaderValue, StatusCode, Uri};
+use axum::http::{HeaderMap, HeaderValue, StatusCode, Uri};
 use axum::response::{Html, IntoResponse, Response};
 use axum::routing::{get, get_service};
 use axum::Router;
@@ -29,6 +29,36 @@ pub struct Options {
 }
 
 pub async fn run_server(options: Options, output: WasmBindgenOutput) -> Result<()> {
+    let app = get_router(&options, output);
+    let mut address_string = options.address;
+    if !address_string.contains(":") {
+        address_string +=
+            &(":".to_owned() + &pick_port::pick_free_port(1334, 10).unwrap_or(1334).to_string());
+    }
+    let addr: SocketAddr = address_string.parse().expect("Couldn't parse address");
+
+    if options.https {
+        let certificate = rcgen::generate_simple_self_signed([String::from("localhost")])?;
+        let config = RustlsConfig::from_der(
+            vec![certificate.serialize_der()?],
+            certificate.serialize_private_key_der(),
+        )
+        .await?;
+
+        tracing::info!("starting webserver at https://{}", addr);
+        axum_server_dual_protocol::bind_dual_protocol(addr, config)
+            .set_upgrade(true)
+            .serve(app.into_make_service())
+            .await?;
+    } else {
+        tracing::info!("starting webserver at http://{}", addr);
+        axum_server::bind(addr).serve(app.into_make_service()).await?;
+    }
+
+    Ok(())
+}
+
+fn get_router(options: &Options, output: WasmBindgenOutput) -> Router {
     let WasmBindgenOutput { js, compressed_wasm, snippets, local_modules } = output;
 
     let middleware_stack = ServiceBuilder::new()
@@ -53,13 +83,14 @@ pub async fn run_server(options: Options, output: WasmBindgenOutput) -> Result<(
     let html = html.replace("{{ TITLE }}", &options.title);
 
     let serve_dir =
-        get_service(ServeDir::new(options.directory)).handle_error(internal_server_error);
+        get_service(ServeDir::new(options.directory.clone())).handle_error(internal_server_error);
 
-    let serve_wasm = || async move {
+    let serve_wasm = |headers: HeaderMap| async move {
+        println!(" request headers: {:?}", headers);
         ([("content-encoding", "br")], WithContentType("application/wasm", compressed_wasm))
     };
 
-    let app = Router::new()
+    Router::new()
         .route("/", get(move || async { Html(html) }))
         .route("/api/wasm.js", get(|| async { WithContentType("application/javascript", js) }))
         .route("/api/wasm.wasm", get(serve_wasm))
@@ -77,34 +108,7 @@ pub async fn run_server(options: Options, output: WasmBindgenOutput) -> Result<(
             }),
         )
         .fallback(serve_dir)
-        .layer(middleware_stack);
-
-    let mut address_string = options.address;
-    if !address_string.contains(":") {
-        address_string +=
-            &(":".to_owned() + &pick_port::pick_free_port(1334, 10).unwrap_or(1334).to_string());
-    }
-    let addr: SocketAddr = address_string.parse().expect("Couldn't parse address");
-
-    if options.https {
-        let certificate = rcgen::generate_simple_self_signed([String::from("localhost")])?;
-        let config = RustlsConfig::from_der(
-            vec![certificate.serialize_der()?],
-            certificate.serialize_private_key_der(),
-        )
-        .await?;
-
-        tracing::info!("starting webserver at https://{}", addr);
-        axum_server_dual_protocol::bind_dual_protocol(addr, config)
-            .set_upgrade(true)
-            .serve(app.into_make_service())
-            .await?;
-    } else {
-        tracing::info!("starting webserver at http://{}", addr);
-        axum_server::bind(addr).serve(app.into_make_service()).await?;
-    }
-
-    Ok(())
+        .layer(middleware_stack)
 }
 
 fn get_snippet_source(
@@ -165,3 +169,75 @@ mod pick_port {
             .or_else(ask_free_tcp_port)
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use crate::server::get_router;
+    use crate::wasm_bindgen;
+    use crate::Options;
+    use axum::body::Bytes;
+    use axum::http::StatusCode;
+    use axum_test_helper::TestClient;
+    use std::path::Path;
+
+    /// Headers for requests from 127.0.0.1 and local IP:
+    ///
+    /// In this request, br is missing from the "accept-encoding" header
+    ///
+    /// request headers: {"host": "192.168.68.107:1334", "connection": "keep-alive",
+    /// "user-agent": "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/107.0.0.0 Safari/537.36",
+    /// "accept": "*/*", "referer": "http://192.168.68.107:1334/",
+    /// "accept-encoding": "gzip, deflate", "accept-language": "en-US,en;q=0.9"}
+
+    /// request headers: {"host": "127.0.0.1:1334", "connection": "keep-alive",
+    /// "sec-ch-ua": "\"Google Chrome\";v=\"107\", \"Chromium\";v=\"107\", \"Not=A?Brand\";v=\"24\"",
+    /// "sec-ch-ua-mobile": "?0",
+    /// "user-agent": "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/107.0.0.0 Safari/537.36",
+    /// "sec-ch-ua-platform": "\"Linux\"", "accept": "*/*", "sec-fetch-site": "same-origin",
+    /// "sec-fetch-mode": "cors", "sec-fetch-dest": "empty", "referer": "http://127.0.0.1:1334/",
+    /// "accept-encoding": "gzip, deflate, br", "accept-language": "en-US,en;q=0.9"}
+
+    /// To run this test, it is necessary to first create `example-project.wasm` by these commands:
+    ///   cd example-project
+    ///   cargo build
+    #[tokio::test]
+    async fn test_router() {
+        let options = Options {
+            title: "title".to_string(),
+            address: "127.0.0.1:0".to_string(),
+            directory: ".".to_string(),
+            https: false,
+            no_module: false,
+        };
+
+        let wasm_file =
+            Path::new("example-project/target/wasm32-unknown-unknown/debug/example-project.wasm");
+        let output = wasm_bindgen::generate(&options, wasm_file).unwrap();
+        let router = get_router(&options, output);
+        println!("{:?}", &router);
+        let client = TestClient::new(router);
+
+        // Test with br compression requested
+        let mut res = client
+            .get("/api/wasm.wasm")
+            .header("accept-encoding", "gzip, deflate, br")
+            .send()
+            .await;
+        assert_eq!(res.status(), StatusCode::OK);
+        let result = res.chunk().await.unwrap();
+        assert_ne!(result[0..3], Bytes::from(vec![0x1f, 0x8b, 0x08]));
+
+        // Test without br compression
+        // let mut res = client
+        //     .get("/api/wasm.wasm")
+        //     .header("accept-encoding", "gzip, deflate")
+        //     .send()
+        //     .await;
+        // assert_eq!(res.status(), StatusCode::OK);
+        // let result = res.chunk().await.unwrap();
+        // // This is the gzip 3-byte file header
+        // assert_eq!(result[0..3], Bytes::from(vec![0x1f, 0x8b, 0x08]));
+
+        //tokio_test::block_on(server).unwrap();
+    }
+}