Merge pull request spinframework#1657 from fermyon/test-local-redis-sdk

Make a test that exercises the canary Rust SDK's redis support

Author: rylev

build.rs

@@ -130,8 +130,9 @@ fn run<S: Into<String> + AsRef<std::ffi::OsStr>>(
     cmd.stdout(process::Stdio::piped());
     cmd.stderr(process::Stdio::piped());
 
-    if let Some(dir) = dir {
-        cmd.current_dir(dir.into());
+    let dir = dir.map(Into::into);
+    if let Some(dir) = &dir {
+        cmd.current_dir(dir);
     };
 
     if let Some(env) = env {
@@ -141,20 +142,20 @@ fn run<S: Into<String> + AsRef<std::ffi::OsStr>>(
     };
 
     cmd.arg("-c");
-    cmd.arg(
-        args.into_iter()
-            .map(Into::into)
-            .collect::<Vec<String>>()
-            .join(" "),
-    );
+    let c = args
+        .into_iter()
+        .map(Into::into)
+        .collect::<Vec<String>>()
+        .join(" ");
+    cmd.arg(&c);
 
     let output = cmd.output().unwrap();
-    let code = output.status.code().unwrap();
-    if code != 0 {
-        println!("{:#?}", std::str::from_utf8(&output.stderr).unwrap());
-        println!("{:#?}", std::str::from_utf8(&output.stdout).unwrap());
-        // just fail
-        assert_eq!(0, code);
+    let exit = output.status;
+    if !exit.success() {
+        println!("{}", std::str::from_utf8(&output.stderr).unwrap());
+        println!("{}", std::str::from_utf8(&output.stdout).unwrap());
+        let dir = dir.unwrap_or_else(current_dir);
+        panic!("while running the build script, the command '{c}' failed to run in '{dir}'")
     }
 
     output
@@ -167,3 +168,9 @@ fn get_os_process() -> String {
         String::from("bash")
     }
 }
+
+fn current_dir() -> String {
+    std::env::current_dir()
+        .map(|d| d.display().to_string())
+        .unwrap_or_else(|_| String::from("<CURRENT DIR>"))
+}

crates/e2e-testing/src/testcase.rs

@@ -153,7 +153,9 @@ impl TestCase {
         }
 
         // run spin build
-        let build_output = controller.build_app(&appname).context("building app")?;
+        let build_output = controller
+            .build_app(&appname)
+            .context("failed building app")?;
         if bail_on_run_failure {
             utils::assert_success(&build_output);
         }

tests/spinup_tests.rs

@@ -89,8 +89,13 @@ mod spinup_tests {
     }
 
     #[tokio::test]
-    async fn simple_spin_rust_works() {
-        testcases::simple_spin_rust_works(CONTROLLER).await
+    async fn head_rust_sdk_http() {
+        testcases::head_rust_sdk_http(CONTROLLER).await
+    }
+
+    #[tokio::test]
+    async fn head_rust_sdk_redis() {
+        testcases::head_rust_sdk_redis(CONTROLLER).await
     }
 
     #[tokio::test]

tests/testcases/simple-spin-rust-test/.cargo/config.toml tests/testcases/head-rust-sdk-http/.cargo/config.toml

@@ -1,5 +1,5 @@
 [package]
-name    = "simple-spin-rust-test"
+name    = "head-rust-sdk-http"
 version = "0.1.0"
 edition = "2021"
 
@@ -17,7 +17,3 @@ http = "0.2"
 spin-sdk = { path = "../../../sdk/rust" }
 
 [workspace]
-
-# Metadata about this component.
-[package.metadata.component]
-name = "spinhelloworld"

tests/testcases/simple-spin-rust-test/Cargo.toml tests/testcases/head-rust-sdk-http/Cargo.toml

@@ -1,7 +1,7 @@
 spin_version = "1"
 authors = ["Fermyon Engineering <engineering@fermyon.com>"]
 description = "A simple application that returns hello and goodbye."
-name = "simple-spin-rust-test"
+name = "head-rust-sdk-http"
 trigger = {type = "http", base = "/test"}
 version = "1.0.0"
 
@@ -10,7 +10,7 @@ object = { default = "teapot" }
 
 [[component]]
 id = "hello"
-source = "target/wasm32-wasi/release/simple_spin_rust_test.wasm"
+source = "target/wasm32-wasi/release/head_rust_sdk_http.wasm"
 files = [ { source = "assets", destination = "/" } ]
 [component.trigger]
 route = "/hello/..."

tests/testcases/simple-spin-rust-test/assets/test.txt tests/testcases/head-rust-sdk-http/assets/test.txt

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

tests/testcases/simple-spin-rust-test/spin.toml tests/testcases/head-rust-sdk-http/spin.toml

@@ -0,0 +1,15 @@
+[package]
+name    = "head-rust-sdk-redis"
+version = "0.1.0"
+edition = "2021"
+
+[lib]
+crate-type = [ "cdylib" ]
+
+[dependencies]
+anyhow = "1"
+bytes = "1"
+http = "0.2"
+spin-sdk = { path = "../../../sdk/rust"}
+
+[workspace]

tests/testcases/simple-spin-rust-test/src/lib.rs tests/testcases/head-rust-sdk-http/src/lib.rs

@@ -0,0 +1,14 @@
+spin_version = "1"
+authors = ["Fermyon Engineering <engineering@fermyon.com>"]
+description = "A simple redis application that exercises the Rust SDK in the current branch"
+name = "head-rust-sdk-redis"
+trigger = {type = "redis", address = "redis://redis:6379"}
+version = "1.0.0"
+
+[[component]]
+id = "hello"
+source = "target/wasm32-wasi/release/head_rust_sdk_redis.wasm"
+[component.trigger]
+channel = "my-channel"
+[component.build]
+command = "cargo build --target wasm32-wasi --release"

tests/testcases/head-rust-sdk-redis/.cargo/config.toml

@@ -0,0 +1,10 @@
+use spin_sdk::redis_component;
+
+#[redis_component]
+fn on_message(message: bytes::Bytes) -> anyhow::Result<()> {
+    println!(
+        "Got message: '{}'",
+        std::str::from_utf8(&*message).unwrap_or("<MESSAGE NOT UTF8>")
+    );
+    Ok(())
+}

tests/testcases/head-rust-sdk-redis/Cargo.toml

@@ -665,7 +665,8 @@ pub async fn assets_routing_works(controller: &dyn Controller) {
     tc.run(controller).await.unwrap()
 }
 
-pub async fn simple_spin_rust_works(controller: &dyn Controller) {
+/// Test an http app using the current branch's version of the Rust SDK
+pub async fn head_rust_sdk_http(controller: &dyn Controller) {
     async fn checks(
         metadata: AppMetadata,
         _: Option<Pin<Box<dyn AsyncBufRead>>>,
@@ -719,8 +720,42 @@ pub async fn simple_spin_rust_works(controller: &dyn Controller) {
     }
 
     let tc = TestCaseBuilder::default()
-        .name("simple-spin-rust-test".to_string())
-        .appname(Some("simple-spin-rust-test".to_string()))
+        .name("head-rust-sdk-http".to_string())
+        .appname(Some("head-rust-sdk-http".to_string()))
+        .assertions(
+            |metadata: AppMetadata,
+             stdout_stream: Option<Pin<Box<dyn AsyncBufRead>>>,
+             stderr_stream: Option<Pin<Box<dyn AsyncBufRead>>>| {
+                Box::pin(checks(metadata, stdout_stream, stderr_stream))
+            },
+        )
+        .build()
+        .unwrap();
+
+    tc.run(controller).await.unwrap()
+}
+
+/// Test a redis app using the current branch's version of the Rust SDK
+pub async fn head_rust_sdk_redis(controller: &dyn Controller) {
+    async fn checks(
+        _: AppMetadata,
+        _: Option<Pin<Box<dyn AsyncBufRead>>>,
+        stderr_stream: Option<Pin<Box<dyn AsyncBufRead>>>,
+    ) -> Result<()> {
+        wait_for_spin().await;
+        let stderr = get_output_stream(stderr_stream).await?;
+        anyhow::ensure!(
+            stderr.is_empty(),
+            "expected stderr to be empty, but it was not: {}",
+            stderr.join("\n")
+        );
+        Ok(())
+    }
+
+    let tc = TestCaseBuilder::default()
+        .name("head-rust-sdk-redis".to_string())
+        .appname(Some("head-rust-sdk-redis".to_string()))
+        .trigger_type("redis".to_string())
         .assertions(
             |metadata: AppMetadata,
              stdout_stream: Option<Pin<Box<dyn AsyncBufRead>>>,
@@ -877,8 +912,7 @@ pub async fn redis_go_works(controller: &dyn Controller) {
         _: Option<Pin<Box<dyn AsyncBufRead>>>,
         stderr_stream: Option<Pin<Box<dyn AsyncBufRead>>>,
     ) -> Result<()> {
-        //TODO: wait for spin up to be ready dynamically
-        sleep(Duration::from_secs(10)).await;
+        wait_for_spin().await;
 
         let output = utils::run(
             &[
@@ -894,7 +928,7 @@ pub async fn redis_go_works(controller: &dyn Controller) {
         )?;
         utils::assert_success(&output);
 
-        let stderr = utils::get_output_stream(stderr_stream, Duration::from_secs(5)).await?;
+        let stderr = get_output_stream(stderr_stream).await?;
         let expected_logs = vec!["Payload::::", "msg-from-go-channel"];
 
         assert!(expected_logs
@@ -934,8 +968,7 @@ pub async fn redis_rust_works(controller: &dyn Controller) {
         _: Option<Pin<Box<dyn AsyncBufRead>>>,
         stderr_stream: Option<Pin<Box<dyn AsyncBufRead>>>,
     ) -> Result<()> {
-        //TODO: wait for spin up to be ready dynamically
-        sleep(Duration::from_secs(20)).await;
+        wait_for_spin().await;
 
         utils::run(
             &[
@@ -950,7 +983,7 @@ pub async fn redis_rust_works(controller: &dyn Controller) {
             None,
         )?;
 
-        let stderr = utils::get_output_stream(stderr_stream, Duration::from_secs(5)).await?;
+        let stderr = get_output_stream(stderr_stream).await?;
 
         let expected_logs = vec!["msg-from-rust-channel"];
 
@@ -1207,3 +1240,14 @@ pub async fn error_messages(controller: &dyn Controller) {
 
     tc.try_run(controller).await.unwrap();
 }
+
+async fn get_output_stream(
+    stream: Option<Pin<Box<dyn AsyncBufRead>>>,
+) -> anyhow::Result<Vec<String>> {
+    utils::get_output_stream(stream, Duration::from_secs(5)).await
+}
+
+async fn wait_for_spin() {
+    //TODO: wait for spin up to be ready dynamically
+    sleep(Duration::from_secs(10)).await;
+}