Add tests to spin-core crate

Signed-off-by: Lann Martin <lann.martin@fermyon.com>

Author: lann

Cargo.lock

@@ -39,6 +39,7 @@ 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/http/tests/rust-http-test");
     build_wasm_test_program("redis-rust.wasm", "crates/redis/tests/rust");
     build_wasm_test_program("wagi-test.wasm", "crates/http/tests/wagi-test");

build.rs

@@ -10,4 +10,8 @@ async-trait = "0.1"
 wasi-cap-std-sync = "0.39"
 wasi-common = "0.39"
 wasmtime = "0.39"
-wasmtime-wasi = { version = "0.39", features = ["tokio"] }
+wasmtime-wasi = { version = "0.39", features = ["tokio"] }
+
+[dev-dependencies]
+tempfile = "3"
+tokio = { version = "1", features = ["macros", "rt"] }

crates/core/Cargo.toml

@@ -174,3 +174,44 @@ impl HostComponentsData {
         self.data[idx].get_or_insert_with(|| self.data_builders[idx]())
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    struct TestHC;
+
+    impl HostComponent for TestHC {
+        type Data = u8;
+
+        fn add_to_linker<T: Send>(
+            _linker: &mut Linker<T>,
+            _get: impl Fn(&mut Data<T>) -> &mut Self::Data + Send + Sync + Copy + 'static,
+        ) -> Result<()> {
+            Ok(())
+        }
+
+        fn build_data(&self) -> Self::Data {
+            0
+        }
+    }
+
+    #[test]
+    fn host_components_data() {
+        let engine = wasmtime::Engine::default();
+        let mut linker: crate::Linker<()> = crate::Linker::new(&engine);
+
+        let mut builder = HostComponents::builder();
+        let handle1 = builder
+            .add_host_component(&mut linker, Arc::new(TestHC))
+            .unwrap();
+        let handle2 = builder.add_host_component(&mut linker, TestHC).unwrap();
+        let host_components = builder.build();
+        let mut hc_data = host_components.new_data();
+
+        assert_eq!(hc_data.get_or_insert(handle1), &0);
+
+        hc_data.set(handle2, 1);
+        assert_eq!(hc_data.get_or_insert(handle2), &1);
+    }
+}

crates/core/src/host_component.rs

@@ -16,3 +16,22 @@ impl OutputBuffer {
         WritePipe::from_shared(self.0.clone())
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use std::io::IoSlice;
+
+    use wasi_common::WasiFile;
+
+    use super::*;
+
+    #[tokio::test]
+    async fn take_what_you_write() {
+        let mut buf = OutputBuffer::default();
+        buf.writer()
+            .write_vectored(&[IoSlice::new(b"foo")])
+            .await
+            .unwrap();
+        assert_eq!(buf.take(), b"foo");
+    }
+}

crates/core/src/io.rs

@@ -108,9 +108,9 @@ impl StoreBuilder {
         self.store_limits = StoreLimitsAsync::new(Some(max_memory_size), None);
     }
 
-    /// Inherit stdin, stdout, and stderr from the host process.
-    pub fn inherit_stdio(&mut self) {
-        self.with_wasi(|wasi| wasi.inherit_stdio());
+    /// Inherit stdin from the host process.
+    pub fn inherit_stdin(&mut self) {
+        self.with_wasi(|wasi| wasi.inherit_stdin());
     }
 
     /// Sets the WASI `stdin` descriptor.
@@ -123,6 +123,11 @@ impl StoreBuilder {
         self.stdin(ReadPipe::new(r))
     }
 
+    /// Inherit stdin from the host process.
+    pub fn inherit_stdout(&mut self) {
+        self.with_wasi(|wasi| wasi.inherit_stdout());
+    }
+
     /// Sets the WASI `stdout` descriptor.
     pub fn stdout(&mut self, file: impl WasiFile + 'static) {
         self.with_wasi(|wasi| wasi.stdout(Box::new(file)))
@@ -140,6 +145,11 @@ impl StoreBuilder {
         buffer
     }
 
+    /// Inherit stdin from the host process.
+    pub fn inherit_stderr(&mut self) {
+        self.with_wasi(|wasi| wasi.inherit_stderr());
+    }
+
     /// Sets the WASI `stderr` descriptor.
     pub fn stderr(&mut self, file: impl WasiFile + 'static) {
         self.with_wasi(|wasi| wasi.stderr(Box::new(file)))

crates/core/src/store.rs

@@ -0,0 +1,2 @@
+[build]
+target = "wasm32-wasi"

crates/core/tests/core-wasi-test/.cargo/config.toml

@@ -0,0 +1,9 @@
+[package]
+name    = "core-wasi-test"
+version = "0.1.0"
+edition = "2021"
+
+[profile.release]
+debug = true
+
+[workspace]

crates/core/tests/core-wasi-test/Cargo.toml

@@ -0,0 +1,58 @@
+//! This test program takes argument(s) that determine which WASI feature to
+//! exercise and returns an exit code of 0 for success, 1 for WASI interface
+//! failure (which is sometimes expected in a test), and some other code on
+//! invalid argument(s).
+
+#[link(wasm_import_module = "multiplier")]
+extern "C" {
+    fn multiply(n: i32) -> i32;
+}
+
+type Result = std::result::Result<(), Box<dyn std::error::Error>>;
+
+fn main() -> Result {
+    let mut args = std::env::args();
+    let cmd = args.next().expect("cmd");
+    match cmd.as_str() {
+        "noop" => (),
+        "echo" => {
+            eprintln!("echo");
+            std::io::copy(&mut std::io::stdin(), &mut std::io::stdout())?;
+        }
+        "alloc" => {
+            let size: usize = args.next().expect("size").parse().expect("size");
+            eprintln!("alloc {size}");
+            let layout = std::alloc::Layout::from_size_align(size, 8).expect("layout");
+            unsafe {
+                let p = std::alloc::alloc(layout);
+                if p.is_null() {
+                    return Err("allocation failed".into());
+                }
+                // Force allocation to actually happen
+                p.read_volatile();
+            }
+        }
+        "read" => {
+            let path = args.next().expect("path");
+            eprintln!("read {path}");
+            std::fs::read(path)?;
+        }
+        "write" => {
+            let path = args.next().expect("path");
+            eprintln!("write {path}");
+            std::fs::write(path, "content")?;
+        }
+        "multiply" => {
+            let input: i32 = args.next().expect("input").parse().expect("i32");
+            eprintln!("multiply {input}");
+            let output = unsafe { multiply(input) };
+            println!("{output}");
+        }
+        "panic" => {
+            eprintln!("panic");
+            panic!("intentional panic");
+        }
+        cmd => panic!("unknown cmd {cmd}"),
+    };
+    Ok(())
+}