test(jco): add test stubs

Author: vados-cosmonic

crates/test-components/src/bin/stream_rx.rs

@@ -10,6 +10,7 @@ use wit_bindgen::StreamReader;
 
 use bindings::exports::jco::test_components::use_stream_async;
 use bindings::exports::jco::test_components::use_stream_sync;
+use bindings::jco::test_components::resources;
 
 use bindings::exports::jco::test_components::use_stream_async::{
     ExampleEnum, ExampleFlags, ExampleRecord, ExampleVariant,
@@ -129,6 +130,29 @@ impl use_stream_async::Guest for Component {
     ) -> Vec<Vec<ExampleRecord>> {
         read_async_values(rx).await
     }
+
+    async fn read_stream_values_example_resource_own(rx: StreamReader<resources::ExampleResource>) {
+        let _ = read_async_values(rx).await;
+        // All vals dropped at the end of this function
+    }
+
+    async fn read_stream_values_example_resource_own_attr(
+        rx: StreamReader<resources::ExampleResource>,
+    ) -> Vec<u32> {
+        let vals = read_async_values::<resources::ExampleResource>(rx).await;
+        vals.into_iter().map(|r| r.get_id()).collect()
+    }
+
+    async fn read_stream_values_stream_string(
+        mut rx: StreamReader<StreamReader<String>>,
+    ) -> Vec<Vec<String>> {
+        let mut vals = Vec::new();
+        while let Some(inner_rx) = rx.next().await {
+            let inner_vals = read_async_values(inner_rx).await;
+            vals.push(inner_vals);
+        }
+        vals
+    }
 }
 
 async fn read_async_values<T>(mut rx: StreamReader<T>) -> Vec<T> {

crates/test-components/wit/all.wit

@@ -187,7 +187,7 @@ interface use-stream-sync {
 }
 
 interface use-stream-async {
-    // use resources.{example-resource};
+    use resources.{example-resource};
     use example-types.{example-variant, example-enum, example-record, example-flags};
 
     stream-passthrough: async func(s: stream<u32>) -> stream<u32>;
@@ -231,18 +231,18 @@ interface use-stream-async {
     read-stream-values-fixed-list-u32: async func(s: stream<list<list<u32, 5>>>) -> list<list<list<u32, 5>>>;
     read-stream-values-list-record: async func(s: stream<list<example-record>>) -> list<list<example-record>>;
 
-    // // NOTE: the check here will be whether the resources are disposed inside the component properly
-    // read-stream-values-example-resource-own: async func(s: stream<example-resource>);
+    // NOTE: the check here will be whether the resources are disposed inside the component properly
+    read-stream-values-example-resource-own: async func(s: stream<example-resource>);
 
-    // read-stream-values-example-resource-own-attr: async func(s: stream<example-resource>) -> list<u32>;
+    read-stream-values-example-resource-own-attr: async func(s: stream<example-resource>) -> list<u32>;
 
-    // read-stream-values-stream-string: async func(s: stream<stream<string>>) -> list<list<string>>;
+    read-stream-values-stream-string: async func(s: stream<stream<string>>) -> list<list<string>>;
 
     //read-stream-values-future-string: async func(vals: list<future<string>>) -> result<stream<future<string>>, string>;
 }
 
 world stream-rx {
-    // import resources;
+    import resources;
 
     export use-stream-sync;
     export use-stream-async;

packages/jco/test/p3/stream-lowers.js

@@ -10,6 +10,24 @@ import { WASIShim } from "@bytecodealliance/preview2-shim/instantiation";
 suite("stream<T> lowers", () => {
     let esModule, cleanup, instance;
 
+    class ExampleResource {
+        #id;
+
+        dropped = false;
+
+        constructor(id) {
+            this.#id = id;
+        }
+
+        getId() {
+            return this.#id;
+        }
+
+        [Symbol.for('dispose')]() {
+            this.dropped = true;
+        }
+    }
+
     beforeAll(async () => {
         const name = "stream-rx";
         const setupRes = await setupAsyncTest({
@@ -39,6 +57,9 @@ suite("stream<T> lowers", () => {
     beforeEach(async () => {
         instance = await esModule.instantiate(undefined, {
             ...new WASIShim().getImportObject(),
+            "jco:test-components/resources": {
+                ExampleResource,
+            },
         });
     });
 
@@ -390,4 +411,50 @@ suite("stream<T> lowers", () => {
         assert.deepEqual(returnedVals, vals);
     });
 
+    test.only("example-resource", async () => {
+        assert.instanceOf(instance["jco:test-components/use-stream-async"].readStreamValuesExampleResourceOwn, AsyncFunction);
+
+        let vals = [
+            new ExampleResource(0),
+            new ExampleResource(1),
+            new ExampleResource(2),
+        ];
+        await instance["jco:test-components/use-stream-async"].readStreamValuesExampleResourceOwn(
+            createReadableStreamFromValues(vals),
+        );
+        assert(vals.every(r => r.dropped === true));
+    });
+
+    test.skip("example-resource#get-id", async () => {
+        assert.instanceOf(instance["jco:test-components/use-stream-async"].readStreamValuesExampleResourceOwn, AsyncFunction);
+
+        let vals = [
+            new ExampleResource(2),
+            new ExampleResource(1),
+            new ExampleResource(0),
+        ];
+        const returnedVals = await instance["jco:test-components/use-stream-async"].readStreamValuesExampleResourceOwn(
+            createReadableStreamFromValues(vals),
+        );
+        assert.deepEqual(returnedVals, [2, 1, 0]);
+    });
+
+    test.skip("stream<string>", async () => {
+        assert.instanceOf(instance["jco:test-components/use-stream-async"].readStreamValuesStreamString, AsyncFunction);
+
+        let vals = [
+            createReadableStreamFromValues(["first", "stream", "values"]),
+            createReadableStreamFromValues(["second", "stream", "here"]),
+            createReadableStreamFromValues(["third", "values", "in stream"]),
+        ];
+        const returnedVals = await instance["jco:test-components/use-stream-async"].readStreamValuesStreamString(
+            createReadableStreamFromValues(vals),
+        );
+        assert.deepEqual(returnedVals, [
+            ["first", "stream", "values"],
+            ["second", "stream", "here"],
+            ["third", "values", "in stream"],
+        ]);
+    });
+
 });