wip: working but failing test

Author: vados-cosmonic

crates/js-component-bindgen/src/transpile_bindgen.rs

@@ -2562,23 +2562,19 @@ impl<'a> Instantiator<'a, '_> {
         // Figure out the function name and callee (e.g. class for a given resource) to use
         let (import_name, binding_name) = match func.kind {
             FunctionKind::Freestanding | FunctionKind::AsyncFreestanding => (
-                // TODO: if we want to avoid async<some fn> for imports,
-                // we need to use the code below:
+                // TODO: if we want to avoid the naming of 'async<fn name>' (e.g. 'asyncSleepMillis'
+                // vs 'sleepMillis' which just *is* an imported async function)....
+                //
+                // We need to use the code below:
                 //
                 // func_name
                 //     .strip_prefix("[async]")
                 //     .unwrap_or(func_name)
                 //     .to_lower_camel_case(),
                 //
-                // This would break *a lot* of downstream though.
-
-                // func_name.to_lower_camel_case(),
-
-                func_name
-                    .strip_prefix("[async]")
-                    .unwrap_or(func_name)
-                    .to_lower_camel_case(),
-
+                // This has the potential to break a lot of downstream consumers who are expecting to
+                // provide 'async<fn name>`, so it must be done before a breaking change.
+                func_name.to_lower_camel_case(),
                 callee_name,
             ),
 

packages/jco/test/p3/ported/wasmtime/component-async/backpressure.js

@@ -2,7 +2,7 @@ import { join } from 'node:path';
 
 import { suite, test } from 'vitest';
 
-import { testComponent, composeCallerCallee, COMPONENT_FIXTURES_DIR } from "./common.js";
+import { buildAndTranspile, composeCallerCallee, COMPONENT_FIXTURES_DIR } from "./common.js";
 
 // These tests are ported from upstream wasmtime's component-async-tests
 //
@@ -23,6 +23,15 @@ suite('backpressure scenario', () => {
             callerPath,
             calleePath,
         });
-        await testComponent({ componentPath });
+
+        let cleanup;
+        try {
+            const res = await buildAndTranspile({ componentPath });
+            const instance = res.instance;
+            cleanup = res.cleanup;
+            await instance['local:local/run'].asyncRun();
+        } finally {
+            if (cleanup) { await cleanup(); }
+        }
     });
 });

packages/jco/test/p3/ported/wasmtime/component-async/common.js

@@ -27,13 +27,7 @@ async function ensureFile(filePath) {
 }
 
 /**
- * Run a single component test for a component that
- * exports `local:local/run` (normally async) in the style of
- * wasmtime component-async-tests
- *
- * This test will generally transpile the component and then run its' 'local:local/run' export
- *
- * @see https://github.com/bytecodealliance/wasmtime/blob/main/crates/misc/component-async-tests/tests/scenario/util.rs
+ * Build and transpile a component for use in a test
  *
  * @param {object} args
  * @param {string} args.componentPath - path to the wasm binary that should be tested
@@ -42,7 +36,7 @@ async function ensureFile(filePath) {
  * @param {object} args.transpile.extraArgs - extra arguments that should be used during transpilation (ex. `{minify: false}`)
  * @returns {Promise<void>} A Promise that resolves when the test completes
  */
-export async function testComponent(args) {
+export async function buildAndTranspile(args) {
     const componentPath = await ensureFile(args.componentPath);
     const { esModule, cleanup } = await setupAsyncTest({
         asyncMode: 'jspi',
@@ -72,45 +66,11 @@ export async function testComponent(args) {
         }
     );
 
-    let runFn;
-    let result;
-    if ('local:local/run' in instance) {
-        runFn = instance['local:local/run'].asyncRun;
-        assert.strictEqual(
-            runFn instanceof AsyncFunction,
-            true,
-            'local:local/run should be async'
-        );
-    } else if ('wasi:cli/[email protected]' in instance) {
-        runFn = instance['wasi:cli/[email protected]'].run;
-    }
-
-    if (runFn) {
-        if (runFn instanceof AsyncFunction) {
-            result = await runFn();
-        } else {
-            result = runFn();
-        }
-    }
-
-    // Ensure our test does *something* via a detected export or if testing
-    // will happen outside, due to noCleanup
-    if (!runFn && !args.noCleanup) {
-        throw new Error("no detected function was run, and cleanup is specified");
-    }
-
-    if (args.noCleanup) {
-        return {
-            result,
-            instance,
-            esModule,
-            cleanup,
-        };
-    }
-
-    await cleanup();
-
-    return { result };
+    return {
+        instance,
+        esModule,
+        cleanup,
+    };
 }
 
 /**

packages/jco/test/p3/ported/wasmtime/component-async/error-context.js

@@ -2,7 +2,7 @@ import { join } from 'node:path';
 
 import { suite, test } from 'vitest';
 
-import { testComponent, composeCallerCallee, COMPONENT_FIXTURES_DIR } from "./common.js";
+import { buildAndTranspile, composeCallerCallee, COMPONENT_FIXTURES_DIR } from "./common.js";
 
 // These tests are ported from upstream wasmtime's component-async-tests
 //
@@ -15,7 +15,16 @@ suite('error-context scenario', () => {
             COMPONENT_FIXTURES_DIR,
             'p3/error-context/async-error-context.wasm'
         );
-        await testComponent({ componentPath });
+
+        let cleanup;
+        try {
+            const res = await buildAndTranspile({ componentPath });
+            const instance = res.instance;
+            cleanup = res.cleanup;
+            await instance['local:local/run'].asyncRun();
+        } finally {
+            if (cleanup) { await cleanup(); }
+        }
     });
 
     test('caller & callee', async () => {
@@ -31,6 +40,15 @@ suite('error-context scenario', () => {
             callerPath,
             calleePath,
         });
-        await testComponent({ componentPath });
+
+        let cleanup;
+        try {
+            const res = await buildAndTranspile({ componentPath });
+            cleanup = res.cleanup;
+            const instance = res.instance;
+            await instance['local:local/run'].asyncRun();
+        } finally {
+            if (cleanup) { await cleanup(); }
+        }
     });
 });

packages/jco/test/p3/ported/wasmtime/component-async/post-return.js

@@ -1,8 +1,8 @@
 import { join } from 'node:path';
 
-import { suite, test } from 'vitest';
+import { suite, test, expect, vi } from 'vitest';
 
-import { testComponent, composeCallerCallee, COMPONENT_FIXTURES_DIR } from "./common.js";
+import { buildAndTranspile, composeCallerCallee, COMPONENT_FIXTURES_DIR } from "./common.js";
 
 // These tests are ported from upstream wasmtime's component-async-tests
 //
@@ -23,7 +23,16 @@ suite.skip('post-return scenario', () => {
             callerPath,
             calleePath,
         });
-        await testComponent({ componentPath });
+
+        let cleanup;
+        try {
+            const res = await buildAndTranspile({ componentPath });
+            const instance = res.instance;
+            cleanup = res.cleanup;
+            await instance['local:local/run'].asyncRun();
+        } finally {
+            if (cleanup) { await cleanup(); }
+        }
     });
 });
 
@@ -46,31 +55,49 @@ suite('post-return async sleep scenario', () => {
             callerPath,
             calleePath,
         });
-        await testComponent({
-            componentPath,
-            instantiation: {
-                imports: {
-                    'local:local/sleep': {
-                        // WIT:
-                        // ```
-                        // sleep-millis: async func(time-in-millis: u64);
-                        // ```
-                        // see: wasmtime/crates/misc/component-async-tests/wit/test.wit
 
-                        // sleepMillis: async (ms) => {
-                        //     await new Promise((resolve) => setTimeout(resolve, ms));
-                        // },
-                        // asyncSleepMillis: async (ms) => {
-                        //     await new Promise((resolve) => setTimeout(resolve, ms));
-                        // },
-                    }
-                }
-            },
-            transpile: {
-                extraArgs: {
-                    minify: false,
-                }
-            },
+        const waitTimeMs = 300;
+        const asyncSleepMillis = vi.fn(async (ms) => {
+            expect(ms).toStrictEqual(waitTimeMs);
+            await new Promise((resolve) => setTimeout(resolve, ms));
         });
+
+        let cleanup;
+        try {
+            const res = await buildAndTranspile({
+                componentPath,
+                noCleanup: true,
+                instantiation: {
+                    imports: {
+                        'local:local/sleep': {
+                            // WIT:
+                            //
+                            // ```
+                            // sleep-millis: async func(time-in-millis: u64);
+                            // ```
+                            // see: wasmtime/crates/misc/component-async-tests/wit/test.wit
+                            asyncSleepMillis,
+                        }
+                    }
+                },
+                transpile: {
+                    extraArgs: {
+                        minify: false,
+                    }
+                },
+            });
+            const instance = res.instance;
+            cleanup = res.cleanup;
+
+            await instance['local:local/sleep-post-return'].asyncRun(waitTimeMs);
+
+            // TODO: fix: sleep-post-return is running but *does not* call the import properly,
+            // likely because the task is not actually the thing being returned -- the promise is 
+            // returning early?
+
+            expect(asyncSleepMillis).toHaveBeenCalled();
+        } finally {
+            if (cleanup) { await cleanup(); }
+        }
     });
 });