tests: Migrate spin inbound-http test to integration test suite

Signed-off-by: Lann Martin <[email protected]>

Author: lann

build.rs

@@ -64,10 +64,6 @@ error: the `wasm32-wasi` target is not installed
     std::fs::create_dir_all("target/test-programs").unwrap();
 
     build_wasm_test_program("core-wasi-test.wasm", "crates/core/tests/core-wasi-test");
-    build_wasm_test_program(
-        "rust-http-test.wasm",
-        "crates/trigger-http/tests/rust-http-test",
-    );
     build_wasm_test_program("redis-rust.wasm", "crates/trigger-redis/tests/rust");
 
     build_wasm_test_program(

crates/trigger-http/src/lib.rs

@@ -542,7 +542,6 @@ impl OutboundWasiHttpHandler for HttpRuntimeData {
 #[cfg(test)]
 mod tests {
     use anyhow::Result;
-    use spin_testing::test_socket_addr;
 
     use super::*;
 
@@ -668,31 +667,6 @@ mod tests {
         res
     }
 
-    #[tokio::test]
-    async fn test_spin_http() -> Result<()> {
-        let trigger: HttpTrigger = spin_testing::HttpTestConfig::default()
-            .test_program("rust-http-test.wasm")
-            .http_spin_trigger("/test")
-            .build_trigger()
-            .await;
-
-        let body = body::full(Bytes::from_static("Fermyon".as_bytes()));
-        let req = http::Request::post("https://myservice.fermyon.dev/test?abc=def")
-            .header("x-custom-foo", "bar")
-            .header("x-custom-foo2", "bar2")
-            .body(body)
-            .unwrap();
-
-        let res = trigger
-            .handle(req, Scheme::HTTPS, test_socket_addr())
-            .await?;
-        assert_eq!(res.status(), StatusCode::OK);
-        let body_bytes = res.into_body().collect().await.unwrap().to_bytes();
-        assert_eq!(body_bytes.to_vec(), "Hello, Fermyon".as_bytes());
-
-        Ok(())
-    }
-
     #[test]
     fn parse_listen_addr_prefers_ipv4() {
         let addr = parse_listen_addr("localhost:12345").unwrap();

crates/trigger-http/tests/rust-http-test/.cargo/config.toml

@@ -1031,6 +1031,41 @@ route = "/..."
         Ok(())
     }
 
+    #[test]
+    fn test_spin_inbound_http() -> anyhow::Result<()> {
+        run_test(
+            "spin-inbound-http",
+            testing_framework::SpinMode::Http,
+            [],
+            testing_framework::ServicesConfig::none(),
+            move |env| {
+                let spin = env.runtime_mut();
+                assert_spin_request(
+                    spin,
+                    testing_framework::Request::full(
+                        Method::GET,
+                        "/base/echo",
+                        &[],
+                        Some("Echo..."),
+                    ),
+                    testing_framework::Response::new_with_body(200, "Echo..."),
+                )?;
+                assert_spin_request(
+                    spin,
+                    testing_framework::Request::full(
+                        Method::GET,
+                        "/base/assert-headers?k=v",
+                        &[("X-Custom-Foo", "bar")],
+                        Some(r#"{"x-custom-foo": "bar"}"#),
+                    ),
+                    testing_framework::Response::new(200),
+                )?;
+                Ok(())
+            },
+        )?;
+        Ok(())
+    }
+
     #[test]
     fn test_wagi_http() -> anyhow::Result<()> {
         run_test(

crates/trigger-http/tests/rust-http-test/Cargo.toml

@@ -0,0 +1,11 @@
+[package]
+name = "integration-spin-inbound-http"
+version = "0.1.0"
+edition = "2021"
+
+[lib]
+crate-type = ["cdylib"]
+
+[dependencies]
+miniserde = "0.1.36"
+wit-bindgen = "0.13"

crates/trigger-http/tests/rust-http-test/src/lib.rs

@@ -0,0 +1,58 @@
+wit_bindgen::generate!({
+    world: "http-trigger",
+    path: "../../../../wit-0.2.0/deps/spin@unversioned",
+    exports: {
+        "fermyon:spin/inbound-http": SpinHttp,
+    }
+});
+
+use std::collections::HashMap;
+
+use exports::fermyon::spin::inbound_http::{self, Request, Response};
+use miniserde::json;
+
+struct SpinHttp;
+
+impl inbound_http::Guest for SpinHttp {
+    fn handle_request(req: Request) -> Response {
+        let (status, body) = match handle_request(req) {
+            Ok(body) => (200, body),
+            Err(err) => (500, format!("{err:?}").into_bytes()),
+        };
+        Response {
+            status,
+            headers: None,
+            body: Some(body),
+        }
+    }
+}
+
+fn handle_request(req: Request) -> Result<Vec<u8>, Box<dyn std::error::Error>> {
+    if !req.params.is_empty() {
+        return Err("request params field is deprecated".into());
+    }
+
+    let headers = req.headers.into_iter().collect::<HashMap<_, _>>();
+    let path = headers
+        .get("spin-path-info")
+        .map(|path| path.as_str())
+        .unwrap_or("");
+    match path {
+        "/echo" => Ok(req.body.unwrap_or_default()),
+        "/assert-headers" => {
+            let body = String::from_utf8(req.body.unwrap_or_default())?;
+            let expected: HashMap<String, String> = json::from_str(&body)?;
+            for (key, val) in expected {
+                let got = headers
+                    .get(&key)
+                    .ok_or_else(|| format!("missing header {key:?}"))?;
+                if got != &val {
+                    return Err(format!("expected header {key}: {val:?}, got {got:?}").into());
+                }
+            }
+
+            Ok(vec![])
+        }
+        other => Err(format!("unknown test route spin-path-info={other:?}").into()),
+    }
+}

tests/integration.rs

@@ -0,0 +1,15 @@
+spin_manifest_version = 2
+
+[application]
+authors = ["Fermyon Engineering <[email protected]>"]
+description = "Test using the spin inbound-http interface."
+name = "spin-inbound-http"
+version = "1.0.0"
+
+[application.trigger.http]
+base = "/base"
+
+[[trigger.http]]
+route = "/..."
+[trigger.http.component]
+source = "%{source=integration-spin-inbound-http}"