Add outbound-wasi-http-0.2.0 tests

.gitignore

@@ -0,0 +1 @@
+conformance-tests

components/outbound-wasi-http-v0.2.0/.gitignore

@@ -0,0 +1,2 @@
+target/
+.spin/

components/outbound-wasi-http-v0.2.0/Cargo.toml

@@ -0,0 +1,11 @@
+[package]
+name = "wasi-http-rust-0-2-0"
+version = "0.1.0"
+edition = "2021"
+
+[lib]
+crate-type = ["cdylib"]
+
+[dependencies]
+url = "2.4.0"
+wit-bindgen = { workspace = true }

components/outbound-wasi-http-v0.2.0/src/lib.rs

@@ -0,0 +1,139 @@
+wit_bindgen::generate!({
+    path: "../../wit",
+    world: "wasi:http/proxy@0.2.0",
+});
+
+use exports::wasi::http0_2_0::incoming_handler;
+use url::Url;
+use wasi::{
+    http0_2_0::{
+        outgoing_handler,
+        types::{
+            Headers, IncomingRequest, Method, OutgoingBody, OutgoingRequest, OutgoingResponse,
+            ResponseOutparam, Scheme,
+        },
+    },
+    io0_2_0::streams::StreamError,
+};
+
+struct Component;
+
+export!(Component);
+
+impl incoming_handler::Guest for Component {
+    fn handle(request: IncomingRequest, outparam: ResponseOutparam) {
+        // The request must have a "url" header.
+        let Some(url) = request.headers().entries().iter().find_map(|(k, v)| {
+            (k == "url")
+                .then_some(v)
+                .and_then(|v| std::str::from_utf8(v).ok())
+                .and_then(|v| Url::parse(v).ok())
+        }) else {
+            // Otherwise, return a 400 Bad Request response.
+            return_response(outparam, 400, b"Bad Request");
+            return;
+        };
+
+        let headers = Headers::new();
+        headers
+            .append(&"Content-Length".into(), &"13".into())
+            .unwrap();
+        let outgoing_request = OutgoingRequest::new(headers);
+        outgoing_request.set_method(&Method::Post).unwrap();
+        outgoing_request
+            .set_path_with_query(Some(url.path()))
+            .unwrap();
+        outgoing_request
+            .set_scheme(Some(&match url.scheme() {
+                "http" => Scheme::Http,
+                "https" => Scheme::Https,
+                scheme => Scheme::Other(scheme.into()),
+            }))
+            .unwrap();
+        outgoing_request
+            .set_authority(Some(url.authority()))
+            .unwrap();
+
+        // Write the request body.
+        write_outgoing_body(outgoing_request.body().unwrap(), b"Hello, world!");
+
+        // Get the incoming response.
+        let response = match outgoing_handler::handle(outgoing_request, None) {
+            Ok(r) => r,
+            Err(e) => {
+                return_response(outparam, 500, e.to_string().as_bytes());
+                return;
+            }
+        };
+
+        let response = loop {
+            if let Some(response) = response.get() {
+                break response.unwrap().unwrap();
+            } else {
+                response.subscribe().block()
+            }
+        };
+        let incoming_body = response.consume().unwrap();
+        let incoming_stream = incoming_body.stream().unwrap();
+        let status = response.status();
+
+        // Create the outgoing response from the incoming response.
+        let response = OutgoingResponse::new(response.headers().clone());
+        response.set_status_code(status).unwrap();
+        let outgoing_body = response.body().unwrap();
+        {
+            let outgoing_stream = outgoing_body.write().unwrap();
+            ResponseOutparam::set(outparam, Ok(response));
+
+            loop {
+                match incoming_stream.read(1024) {
+                    Ok(buffer) => {
+                        if buffer.is_empty() {
+                            incoming_stream.subscribe().block();
+                        } else {
+                            outgoing_stream.blocking_write_and_flush(&buffer).unwrap();
+                        }
+                    }
+                    Err(StreamError::Closed) => break,
+                    Err(StreamError::LastOperationFailed(error)) => {
+                        panic!("{}", error.to_debug_string())
+                    }
+                }
+            }
+            // The outgoing stream must be dropped before the outgoing body is finished.
+        }
+
+        OutgoingBody::finish(outgoing_body, None).unwrap();
+    }
+}
+
+fn write_outgoing_body(outgoing_body: OutgoingBody, message: &[u8]) {
+    {
+        let outgoing_stream = outgoing_body.write().unwrap();
+        let mut offset = 0;
+        loop {
+            let write = outgoing_stream.check_write().unwrap();
+            if write == 0 {
+                outgoing_stream.subscribe().block();
+            } else {
+                let count = (write as usize).min(message.len() - offset);
+                outgoing_stream.write(&message[offset..][..count]).unwrap();
+                offset += count;
+                if offset == message.len() {
+                    outgoing_stream.flush().unwrap();
+                    break;
+                }
+            }
+        }
+        // The outgoing stream must be dropped before the outgoing body is finished.
+    }
+    OutgoingBody::finish(outgoing_body, None).unwrap();
+}
+
+fn return_response(outparam: ResponseOutparam, status: u16, body: &[u8]) {
+    let response = OutgoingResponse::new(Headers::new());
+    response.set_status_code(status).unwrap();
+    write_outgoing_body(response.body().unwrap(), body);
+
+    ResponseOutparam::set(outparam, Ok(response));
+}

crates/conformance-tests/src/config.rs

@@ -1,17 +1,21 @@
+use anyhow::Context;
+
 /// The configuration of a conformance test
-#[derive(Debug, serde::Deserialize)]
+#[derive(Debug, Clone, serde::Deserialize)]
 pub struct TestConfig {
     pub invocations: Vec<Invocation>,
+    #[serde(default)]
+    pub services: Vec<String>,
 }
 
-#[derive(Debug, serde::Deserialize)]
+#[derive(Debug, Clone, serde::Deserialize)]
 #[serde(untagged)]
 pub enum Invocation {
     Http(HttpInvocation),
 }
 
 /// An invocation of the runtime
-#[derive(Debug, serde::Deserialize)]
+#[derive(Debug, Clone, serde::Deserialize)]
 pub struct HttpInvocation {
     pub request: Request,
     pub response: Response,
@@ -33,7 +37,7 @@ impl HttpInvocation {
     }
 }
 
-#[derive(Debug, serde::Deserialize)]
+#[derive(Debug, Clone, serde::Deserialize)]
 pub struct Request {
     #[serde(default)]
     pub method: Method,
@@ -45,6 +49,39 @@ pub struct Request {
 }
 
 impl Request {
+    /// Substitute template variables in the request with well known env variables
+    ///
+    /// Supported variables:
+    /// - port: map a well known guest port to the port exposed by the service on the host
+    pub fn substitute_from_env<R>(
+        &mut self,
+        env: &mut test_environment::TestEnvironment<R>,
+    ) -> anyhow::Result<()> {
+        self.substitute(move |key, value| {
+            if key != "port" {
+                anyhow::bail!("unknown template key: {key}")
+            }
+            let port = env
+                .get_port(value.parse().context("port must be a number")?)?
+                .with_context(|| format!("no port {value} exposed by any service"))?;
+            Ok(Some(port.to_string()))
+        })
+    }
+
+    /// Substitute template variables in the request
+    pub fn substitute(
+        &mut self,
+        mut replacement: impl FnMut(&str, &str) -> anyhow::Result<Option<String>>,
+    ) -> anyhow::Result<()> {
+        for header in &mut self.headers {
+            test_environment::manifest_template::replace_template(
+                &mut header.value,
+                &mut replacement,
+            )?;
+        }
+        Ok(())
+    }
+
     /// Send the request
     pub fn send<F>(self, send: F) -> anyhow::Result<test_environment::http::Response>
     where
@@ -70,7 +107,7 @@ impl Request {
     }
 }
 
-#[derive(Debug, serde::Deserialize)]
+#[derive(Debug, Clone, serde::Deserialize)]
 pub struct Response {
     #[serde(default = "default_response_status")]
     pub status: u16,
@@ -82,21 +119,21 @@ fn default_response_status() -> u16 {
     200
 }
 
-#[derive(Debug, serde::Deserialize)]
+#[derive(Debug, Clone, serde::Deserialize)]
 pub struct RequestHeader {
     pub name: String,
     pub value: String,
 }
 
-#[derive(Debug, serde::Deserialize)]
+#[derive(Debug, Clone, serde::Deserialize)]
 pub struct ResponseHeader {
     pub name: String,
     pub value: Option<String>,
     #[serde(default)]
     pub optional: bool,
 }
 
-#[derive(Debug, serde::Deserialize, Default)]
+#[derive(Debug, Clone, serde::Deserialize, Default)]
 pub enum Method {
     #[default]
     GET,

crates/conformance-tests/src/lib.rs

@@ -62,7 +62,7 @@ pub fn tests(tests_dir: &Path) -> anyhow::Result<impl Iterator<Item = Test>> {
             let config = r#try!(json5::from_str::<config::TestConfig>(&config)
                 .context("test config could not be parsed"));
 
-            let component_name = format!("{name}.wasm");
+            let component_name = "component.wasm";
             Some(Ok(Test {
                 name,
                 config,
@@ -75,6 +75,7 @@ pub fn tests(tests_dir: &Path) -> anyhow::Result<impl Iterator<Item = Test>> {
     Ok(items.into_iter())
 }
 
+#[derive(Debug, Clone)]
 pub struct Test {
     pub name: String,
     pub config: config::TestConfig,
@@ -92,9 +93,12 @@ pub mod assertions {
     ) -> anyhow::Result<()> {
         anyhow::ensure!(
             actual.status() == expected.status,
-            "actual status {} != expected status {}",
+            "actual status {} != expected status {}\nbody:\n{}",
             actual.status(),
-            expected.status
+            expected.status,
+            actual
+                .text()
+                .unwrap_or_else(|_| String::from("<invalid utf-8>"))
         );
 
         let mut actual_headers = actual

crates/test-environment/services/.gitignore

@@ -0,0 +1 @@
+*.lock

crates/test-environment/src/manifest_template.rs

@@ -67,7 +67,51 @@ impl EnvTemplate {
         Ok(())
     }
 
+    pub fn substitute_value(
+        &mut self,
+        key: &str,
+        replacement: impl Fn(&str) -> String,
+    ) -> anyhow::Result<()> {
+        replace_template(&mut self.content, |k, v| {
+            if k == key {
+                Ok(Some(replacement(v)))
+            } else {
+                Ok(None)
+            }
+        })
+    }
+
     pub fn contents(&self) -> &str {
         &self.content
     }
 }
+
+/// Replace template variables in a string.
+///
+/// Every time a template is found, the `replacement` function is called with the template key and value.
+pub fn replace_template(
+    content: &mut String,
+    mut replacement: impl FnMut(&str, &str) -> anyhow::Result<Option<String>>,
+) -> Result<(), anyhow::Error> {
+    let regex = TEMPLATE_REGEX.get_or_init(|| regex::Regex::new(r"%\{(.*?)\}").unwrap());
+    'outer: loop {
+        'inner: for captures in regex.captures_iter(content) {
+            let (Some(full), Some(capture)) = (captures.get(0), captures.get(1)) else {
+                continue 'inner;
+            };
+            let template = capture.as_str();
+            let (template_key, template_value) = template.split_once('=').with_context(|| {
+                format!("invalid template '{template}'(template should be in the form $KEY=$VALUE)")
+            })?;
+            let (template_key, template_value) = (template_key.trim(), template_value.trim());
+            if let Some(replacement) = replacement(template_key, template_value)? {
+                content.replace_range(full.range(), &replacement);
+                // Restart the search after a substitution
+                continue 'outer;
+            }
+        }
+        // Break the outer loop if no substitutions were made
+        break 'outer;
+    }
+    Ok(())
+}