Add an HTTP server test.

Author: sunfishcode

Cargo.toml

@@ -49,6 +49,7 @@ authors = [
 [workspace.dependencies]
 anyhow = "1"
 cargo_metadata = "0.18.1"
+clap = { version = "4.5.23", features = ["derive"] }
 futures-core = "0.3.19"
 futures-lite = "1.12.0"
 heck = "0.5"
@@ -62,8 +63,10 @@ syn = "2.0"
 test-log = { version = "0.2", features = ["trace"] }
 test-programs = { path = "test-programs" }
 test-programs-artifacts = { path = "test-programs/artifacts" }
+ureq = "2.12.1"
 wasi = "0.13.1"
 wasmtime = "26"
+wasmtime-cli = "26"
 wasmtime-wasi = "26"
 wasmtime-wasi-http = "26"
 wstd = { path = "." }

examples/http_server.rs

@@ -1,13 +1,15 @@
 use wstd::http::body::{BodyForthcoming, IncomingBody, OutgoingBody};
 use wstd::http::server::{Finished, Responder};
 use wstd::http::{IntoBody, Request, Response};
-use wstd::io::{copy, AsyncWrite};
+use wstd::io::{copy, empty, AsyncWrite};
 
 #[wstd::http_server]
 async fn main(request: Request<IncomingBody>, responder: Responder) -> Finished {
     match request.uri().path_and_query().unwrap().as_str() {
         "/wait" => http_wait(request, responder).await,
         "/echo" => http_echo(request, responder).await,
+        "/echo-headers" => http_echo_headers(request, responder).await,
+        "/echo-trailers" => http_echo_trailers(request, responder).await,
         "/fail" => http_fail(request, responder).await,
         "/bigfail" => http_bigfail(request, responder).await,
         "/" | _ => http_home(request, responder).await,
@@ -67,3 +69,19 @@ async fn http_bigfail(_request: Request<IncomingBody>, responder: Responder) ->
     let _ = write_body(&mut body).await;
     Finished::fail(body)
 }
+
+async fn http_echo_headers(request: Request<IncomingBody>, responder: Responder) -> Finished {
+    let mut response = Response::builder();
+    *response.headers_mut().unwrap() = request.headers().clone();
+    let response = response.body(empty()).unwrap();
+    responder.respond(response).await
+}
+
+async fn http_echo_trailers(request: Request<IncomingBody>, responder: Responder) -> Finished {
+    let body = responder.start_response(Response::new(BodyForthcoming));
+    let (trailers, result) = match request.into_body().finish().await {
+        Ok(trailers) => (trailers, Ok(())),
+        Err(err) => (Default::default(), Err(std::io::Error::other(err))),
+    };
+    Finished::finish(body, result, trailers)
+}

test-programs/Cargo.toml

@@ -8,3 +8,4 @@ publish = false
 futures-lite.workspace = true
 serde_json.workspace = true
 wstd.workspace = true
+wasi.workspace = true

test-programs/artifacts/Cargo.toml

@@ -9,9 +9,12 @@ publish = false
 
 [dev-dependencies]
 anyhow.workspace = true
+clap.workspace = true
 test-log.workspace = true
 test-programs-artifacts.workspace = true
+ureq.workspace = true
 wasmtime.workspace = true
+wasmtime-cli.workspace = true
 wasmtime-wasi.workspace = true
 wasmtime-wasi-http.workspace = true
 

test-programs/artifacts/tests/http_server.rs

@@ -0,0 +1,89 @@
+use anyhow::Result;
+
+fn run_in_wasmtime(wasm: &str) -> Result<()> {
+    use clap::Parser;
+    use wasmtime_cli::commands::ServeCommand;
+
+    // Run wasmtime serve.
+    // Enable -Scli because we build with the default adapter rather than the
+    // proxy adapter.
+    // Disable logging so that Wasmtime's tracing_subscriber registration
+    // doesn't conflict with the test harness' registration.
+    let serve =
+        match ServeCommand::try_parse_from(["serve", "-Scli", "-Dlogging=n", wasm].into_iter()) {
+            Ok(serve) => serve,
+            Err(e) => {
+                dbg!(&e);
+                return Err(e.into());
+            }
+        };
+
+    serve.execute()
+}
+
+#[test_log::test]
+fn http_server() -> Result<()> {
+    use std::net::TcpStream;
+    use std::thread::sleep;
+    use std::time::Duration;
+
+    // Start a `wasmtime serve` server.
+    let wasmtime_thread =
+        std::thread::spawn(move || run_in_wasmtime(test_programs_artifacts::HTTP_SERVER));
+
+    // Clumsily wait for the server to accept connections.
+    'wait: loop {
+        sleep(Duration::from_millis(100));
+        if TcpStream::connect("127.0.0.1:8080").is_ok() {
+            break 'wait;
+        }
+    }
+
+    // Do some tests!
+
+    let body: String = ureq::get("http://127.0.0.1:8080").call()?.into_string()?;
+    assert_eq!(body, "Hello, wasi:http/proxy world!\n");
+
+    match ureq::get("http://127.0.0.1:8080/fail").call() {
+        Ok(body) => {
+            unreachable!("unexpected success from /fail: {:?}", body);
+        }
+        Err(ureq::Error::Transport(_transport)) => {}
+        Err(other) => {
+            unreachable!("unexpected error: {:?}", other);
+        }
+    }
+
+    const MESSAGE: &[u8] = b"hello, echoserver!\n";
+
+    let body: String = ureq::get("http://127.0.0.1:8080/echo")
+        .send(MESSAGE)?
+        .into_string()?;
+    assert_eq!(body.as_bytes(), MESSAGE);
+
+    let test_headers = [
+        ("Red", "Rhubarb"),
+        ("Orange", "Carrots"),
+        ("Yellow", "Bananas"),
+        ("Green", "Broccoli"),
+        ("Blue", "Blueberries"),
+        ("Purple", "Beets"),
+    ];
+
+    let mut response = ureq::get("http://127.0.0.1:8080/echo-headers");
+    for (name, value) in test_headers {
+        response = response.set(name, value);
+    }
+    let response = response.call()?;
+
+    assert!(response.headers_names().len() >= test_headers.len());
+    for (name, value) in test_headers {
+        assert_eq!(response.header(name), Some(value));
+    }
+
+    if wasmtime_thread.is_finished() {
+        wasmtime_thread.join().expect("wasmtime panicked")?;
+    }
+
+    Ok(())
+}

test-programs/src/bin/http_server.rs

@@ -0,0 +1 @@
+include!("../../../examples/http_server.rs");