Smoke test for blobstore API

Signed-off-by: itowlson <[email protected]>

Author: itowlson

crates/blobstore-fs/src/lib.rs

@@ -228,6 +228,17 @@ struct BlobContent {
     end: u64,
 }
 
+impl BlobContent {
+    fn len(&self) -> u64 {
+        let excl_end = if self.end == u64::MAX {
+            self.end
+        } else {
+            self.end + 1
+        };
+        excl_end - self.start
+    }
+}
+
 #[async_trait]
 impl spin_factor_blobstore::IncomingData for BlobContent {
     async fn consume_sync(&mut self) -> anyhow::Result<Vec<u8>> {
@@ -238,9 +249,7 @@ impl spin_factor_blobstore::IncomingData for BlobContent {
         let mut buf = Vec::with_capacity(1000);
 
         file.seek(std::io::SeekFrom::Start(self.start)).await?;
-        file.take(self.end - self.start)
-            .read_to_end(&mut buf)
-            .await?;
+        file.take(self.len()).read_to_end(&mut buf).await?;
 
         Ok(buf)
     }
@@ -253,7 +262,7 @@ impl spin_factor_blobstore::IncomingData for BlobContent {
         let file = self.file.take().unwrap();
         let stm = tokio_util::io::ReaderStream::new(file)
             .skip(self.start.try_into().unwrap())
-            .take((self.end - self.start).try_into().unwrap());
+            .take(self.len().try_into().unwrap());
 
         let ar = stm.into_async_read().compat();
         wasmtime_wasi::p2::pipe::AsyncReadStream::new(ar)

crates/factor-blobstore/src/runtime_config/spin.rs

@@ -64,10 +64,7 @@ impl RuntimeConfigResolver {
             .insert(T::RUNTIME_CONFIG_TYPE, store_from_toml_fn(store_type))
             .is_some()
         {
-            anyhow::bail!(
-                "duplicate key value store type {:?}",
-                T::RUNTIME_CONFIG_TYPE
-            );
+            anyhow::bail!("duplicate blob store type {:?}", T::RUNTIME_CONFIG_TYPE);
         }
         Ok(())
     }

tests/integration.rs

@@ -96,6 +96,38 @@ mod integration_tests {
         Ok(())
     }
 
+    #[test]
+    fn blobstore_smoke_test() -> anyhow::Result<()> {
+        let temp_dir = tempfile::tempdir()?;
+
+        let rt_file = temp_dir.path().join("rt.toml");
+        std::fs::write(
+            &rt_file,
+            format!(
+                "[blob_store.default]\ntype = \"file_system\"\npath = \"{}\"",
+                temp_dir.path().display()
+            ),
+        )?;
+
+        run_test(
+            "blobstore",
+            SpinConfig {
+                binary_path: spin_binary(),
+                spin_up_args: vec![
+                    "--runtime-config-file".into(),
+                    rt_file.display().to_string(),
+                ],
+                app_type: SpinAppType::Http,
+            },
+            ServicesConfig::none(),
+            move |env| {
+                let spin = env.runtime_mut();
+                assert_spin_request(spin, Request::new(Method::Get, "/"), Response::new(200))
+            },
+        )?;
+        Ok(())
+    }
+
     #[test]
     #[cfg(feature = "extern-dependencies-tests")]
     #[allow(dependency_on_unit_never_type_fallback)]

tests/test-components/components/Cargo.lock

@@ -0,0 +1,11 @@
+[package]
+name = "blobstore"
+version = "0.1.0"
+edition = "2021"
+
+[lib]
+crate-type = ["cdylib"]
+
+[dependencies]
+helper = { path = "../../helper" }
+wit-bindgen = { workspace = true }

tests/test-components/components/blobstore/Cargo.toml

@@ -0,0 +1,10 @@
+# Key Value
+
+Tests the blobstore interface.
+
+## Expectations
+
+This test component expects the following to be true:
+* It is given permission to open a connection to the "default" store.
+* It does not have permission to access a store named "forbidden".
+* It is empty

tests/test-components/components/blobstore/README.md

@@ -0,0 +1,37 @@
+use helper::{ensure_eq, ensure_ok};
+
+use helper::http_trigger_bindings::wasi::blobstore::blobstore::get_container;
+use helper::http_trigger_bindings::wasi::blobstore::types::{IncomingValue, OutgoingValue};
+
+helper::define_component!(Component);
+
+impl Component {
+    fn main() -> Result<(), String> {
+        let container = ensure_ok!(get_container(&"default".into()));
+
+        let blob_name = "my-blob".to_string();
+
+        let outgoing = OutgoingValue::new_outgoing_value();
+        ensure_ok!(container.write_data(&blob_name, &outgoing));
+
+        let stm = ensure_ok!(outgoing.outgoing_value_write_body().map_err(|_| "failed to write outgoing body"));
+
+        ensure_ok!(stm.blocking_write_and_flush(b"Hello world"));
+
+        ensure_ok!(OutgoingValue::finish(outgoing));
+
+        let incoming = ensure_ok!(container.get_data(&blob_name, 0, u64::MAX));
+        let content = ensure_ok!(IncomingValue::incoming_value_consume_sync(incoming));
+        ensure_eq!(content, b"Hello world");
+
+        let incoming = ensure_ok!(container.get_data(&blob_name, 0, 4));
+        let content = ensure_ok!(IncomingValue::incoming_value_consume_sync(incoming));
+        ensure_eq!(content, b"Hello");
+
+        let incoming = ensure_ok!(container.get_data(&blob_name, 2, 4));
+        let content = ensure_ok!(IncomingValue::incoming_value_consume_sync(incoming));
+        ensure_eq!(content, b"llo");
+
+        Ok(())
+    }
+}

tests/test-components/components/blobstore/src/lib.rs

@@ -0,0 +1,15 @@
+spin_manifest_version = 2
+
+[application]
+authors = ["Fermyon Engineering <[email protected]>"]
+description = "A simple application that exercises blob storage."
+name = "blobstore"
+version = "1.0.0"
+
+[[trigger.http]]
+route = "/..."
+component = "hello"
+
+[component.hello]
+source = "%{source=blobstore}"
+blob_containers = ["default"]