Get things working

Signed-off-by: Ryan Levick <[email protected]>

Author: rylev

Cargo.lock

@@ -150,10 +150,27 @@ impl RuntimeTest<InMemorySpin> {
         })
     }
 
-    fn run(&mut self) {
+    pub fn run(&mut self) {
         self.run_test(|env| {
             let runtime = env.runtime_mut();
-            todo!()
+            let response = runtime.make_http_request(testing_framework::Request::new(reqwest::Method::GET, "/"))?;
+            if response.status() == 200 {
+                return Ok(());
+            }
+            if response.status() != 500 {
+                return Err(anyhow::anyhow!("Runtime tests are expected to return either either a 200 or a 500, but it returned a {}", response.status()).into());
+            }
+            let text = response
+                .text()
+                .context("could not get runtime test HTTP response")?;
+            if text.is_empty() {
+                return Err(anyhow::anyhow!("Runtime tests are expected to return a response body, but the response body was empty.").into());
+            }
+
+            Err(TestError::Failure(RuntimeTestFailure {
+                error: text,
+                stderr: String::new()
+            }))
         })
     }
 }

tests/runtime-tests/src/lib.rs

@@ -15,12 +15,13 @@ mod runtime_tests {
     fn run(test_path: PathBuf) {
         let config = runtime_tests::RuntimeTestConfig {
             test_path,
-            runtime_config: testing_framework::SpinConfig {
-                binary_path: env!("CARGO_BIN_EXE_spin").into(),
-            },
+            runtime_config: (),
+            // runtime_config: testing_framework::SpinConfig {
+            //     binary_path: env!("CARGO_BIN_EXE_spin").into(),
+            // },
             on_error: testing_framework::OnTestError::Panic,
         };
-        runtime_tests::RuntimeTest::<testing_framework::Spin>::bootstrap(config)
+        runtime_tests::RuntimeTest::<testing_framework::InMemorySpin>::bootstrap(config)
             .expect("failed to bootstrap runtime tests tests")
             .run();
     }

tests/runtime.rs

@@ -6,11 +6,18 @@ edition = "2021"
 [dependencies]
 anyhow = { workspace = true }
 fslock = "0.2.1"
+http = "1.0"
+http-body-util = "0.1.0"
 log = "0.4"
 nix = "0.26.1"
 regex = "1.10.2"
 reqwest = { workspace = true }
 temp-dir = "0.1.11"
 test-components = { path = "../test-components" }
+spin-trigger-http = { path = "../../crates/trigger-http" }
+spin-http = { path = "../../crates/http" }
+spin-trigger = { path = "../../crates/trigger" }
+spin-loader = { path = "../../crates/loader" }
 toml = "0.8.6"
 tokio = "1.23"
+wasmtime-wasi-http = "17.0"

tests/testing-framework/Cargo.toml

@@ -3,7 +3,7 @@ use std::path::{Path, PathBuf};
 use crate::{
     services::{Services, ServicesConfig},
     spin::{Spin, SpinMode},
-    Runtime,
+    Response, Runtime,
 };
 use anyhow::Context as _;
 
@@ -192,7 +192,46 @@ impl TestEnvironmentConfig<Spin> {
     }
 }
 
-pub struct InMemorySpin;
+pub struct InMemorySpin {
+    trigger: spin_trigger_http::HttpTrigger,
+}
+
+impl InMemorySpin {
+    pub fn make_http_request(
+        &self,
+        req: crate::Request<'_, &[u8]>,
+    ) -> anyhow::Result<crate::Response> {
+        tokio::runtime::Runtime::new()?.block_on(async {
+            let req = http::request::Request::builder()
+                .method(http::Method::GET) // TODO
+                .uri(req.uri)
+                // TODO: headers
+                .body(spin_http::body::empty()) // TODO
+                .unwrap();
+            let response = self
+                .trigger
+                .handle(
+                    req,
+                    http::uri::Scheme::HTTP,
+                    std::net::SocketAddr::V4(std::net::SocketAddrV4::new(
+                        std::net::Ipv4Addr::LOCALHOST,
+                        80,
+                    )),
+                )
+                .await?;
+            use http_body_util::BodyExt;
+            let status = response.status().as_u16();
+            let body = response.into_body();
+            let chunks = body
+                .collect()
+                .await
+                .context("could not get runtime test HTTP response")?
+                .to_bytes()
+                .to_vec();
+            Ok(Response::full(status, Default::default(), chunks))
+        })
+    }
+}
 
 impl Runtime for InMemorySpin {
     type Config = ();
@@ -211,7 +250,34 @@ impl TestEnvironmentConfig<InMemorySpin> {
             services_config,
             create_runtime: Box::new(|env| {
                 preboot(env)?;
-                Ok(InMemorySpin)
+                tokio::runtime::Runtime::new()
+                    .context("failed to start tokio runtime")?
+                    .block_on(async {
+                        use spin_trigger::{
+                            loader::TriggerLoader, HostComponentInitData, RuntimeConfig,
+                            TriggerExecutorBuilder,
+                        };
+                        use spin_trigger_http::HttpTrigger;
+                        let locked_app = spin_loader::from_file(
+                            env.path().join("spin.toml"),
+                            spin_loader::FilesMountStrategy::Direct,
+                            None,
+                        )
+                        .await?;
+                        let json = locked_app.to_json()?;
+                        std::fs::write(env.path().join("locked.json"), json)?;
+
+                        let loader = TriggerLoader::new(env.path().join(".working_dir"), false);
+                        let trigger = TriggerExecutorBuilder::<HttpTrigger>::new(loader)
+                            .build(
+                                format!("file:{}", env.path().join("locked.json").display()),
+                                RuntimeConfig::default(),
+                                HostComponentInitData::default(),
+                            )
+                            .await?;
+
+                        Result::<_, anyhow::Error>::Ok(InMemorySpin { trigger })
+                    })
             }),
         }
     }