http test runs get from postman-echo

Author: pchickey

Cargo.toml

@@ -22,6 +22,7 @@ wasi.workspace = true
 
 [dev-dependencies]
 anyhow.workspace = true
+serde_json.workspace = true
 test-program-suite.workspace = true
 wasmtime.workspace = true
 wasmtime-wasi.workspace = true
@@ -42,6 +43,7 @@ license = "MIT OR Apache-2.0 OR Apache-2.0 WITH LLVM-exception"
 anyhow = "1"
 cargo_metadata = "0.18.1"
 heck = "0.5"
+serde_json = "1"
 slab = "0.4.9"
 test-programs = { path = "test-programs" }
 test-program-suite = { path = "test-programs/suite" }

examples/http_get.rs

@@ -0,0 +1,36 @@
+use std::error::Error;
+use wstd::http::{Client, Method, Request, Url};
+use wstd::io::AsyncRead;
+use wstd::runtime::block_on;
+
+fn main() -> Result<(), Box<dyn Error>> {
+    block_on(async move {
+        let request = Request::new(Method::Get, Url::parse("https://postman-echo.com/get")?);
+        let mut response = Client::new().send(request).await?;
+
+        let content_type = response
+            .headers()
+            .get(&"content-type".into())
+            .ok_or_else(|| "response expected to have content-type header")?;
+        assert_eq!(content_type.len(), 1, "one header value for content-type");
+        assert_eq!(content_type[0], b"application/json; charset=utf-8");
+
+        // Would much prefer read_to_end here:
+        let mut body_buf = vec![0; 4096];
+        let body_len = response.body().read(&mut body_buf).await?;
+        body_buf.truncate(body_len);
+
+        let val: serde_json::Value = serde_json::from_slice(&body_buf)?;
+        let body_url = val
+            .get("url")
+            .ok_or_else(|| "body json has url")?
+            .as_str()
+            .ok_or_else(|| "body json url is str")?;
+        assert!(
+            body_url.contains("postman-echo.com/get"),
+            "expected body url to contain the authority and path, got: {body_url}"
+        );
+
+        Ok(())
+    })
+}

test-programs/Cargo.toml

@@ -5,4 +5,5 @@ edition = "2021"
 publish = false
 
 [dependencies]
+serde_json.workspace = true
 wstd.workspace = true

test-programs/src/bin/http_get.rs

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

tests/test-programs.rs

@@ -3,7 +3,7 @@ use wasmtime::{
     component::{Component, Linker, ResourceTable},
     Config, Engine, Store,
 };
-use wasmtime_wasi::{StdoutStream, WasiCtx, WasiView};
+use wasmtime_wasi::{pipe::MemoryOutputPipe, WasiCtx, WasiView};
 use wasmtime_wasi_http::{WasiHttpCtx, WasiHttpView};
 
 struct Ctx {
@@ -30,7 +30,7 @@ impl WasiHttpView for Ctx {
     }
 }
 
-fn run_in_wasmtime(wasm: &[u8], stdout: impl StdoutStream + 'static) -> Result<()> {
+fn run_in_wasmtime(wasm: &[u8], stdout: Option<MemoryOutputPipe>) -> Result<()> {
     let config = Config::default();
     let engine = Engine::new(&config).context("creating engine")?;
     let component = Component::new(&engine, wasm).context("loading component")?;
@@ -40,15 +40,17 @@ fn run_in_wasmtime(wasm: &[u8], stdout: impl StdoutStream + 'static) -> Result<(
     wasmtime_wasi_http::add_only_http_to_linker_sync(&mut linker)
         .context("add wasi-http to linker")?;
 
+    let mut builder = WasiCtx::builder();
+    builder.inherit_stderr().inherit_network();
+    let wasi = match stdout {
+        Some(stdout) => builder.stdout(stdout).build(),
+        None => builder.inherit_stdout().build(),
+    };
     let mut store = Store::new(
         &engine,
         Ctx {
             table: ResourceTable::new(),
-            wasi: WasiCtx::builder()
-                .stdout(stdout)
-                .inherit_stderr()
-                .inherit_network()
-                .build(),
+            wasi,
             http: WasiHttpCtx::new(),
         },
     );
@@ -84,7 +86,7 @@ fn tcp_echo_server() -> Result<()> {
 
     let pipe = wasmtime_wasi::pipe::MemoryOutputPipe::new(1024 * 1024);
     let write_end = pipe.clone();
-    let wasmtime_thread = std::thread::spawn(move || run_in_wasmtime(&wasm, write_end));
+    let wasmtime_thread = std::thread::spawn(move || run_in_wasmtime(&wasm, Some(write_end)));
 
     'wait: loop {
         sleep(Duration::from_millis(100));
@@ -117,3 +119,11 @@ fn tcp_echo_server() -> Result<()> {
     }
     Ok(())
 }
+
+#[test]
+fn http_get() -> Result<()> {
+    println!("testing {}", test_program_suite::HTTP_GET);
+    let wasm = std::fs::read(test_program_suite::HTTP_GET).context("read wasm")?;
+
+    run_in_wasmtime(&wasm, None)
+}