test(jco): add regression test for bare export initialize

Author: vados-cosmonic

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

@@ -10,7 +10,7 @@ use wit_bindgen::rt::async_support::ErrorContext;
 
 struct Component;
 
-impl bindings::exports::jco::test_components::local_run::Guest for Component {
+impl bindings::exports::jco::test_components::local_run_async::Guest for Component {
     async fn run() {
         let err_ctx = ErrorContext::new("error");
         assert_eq!("error", err_ctx.debug_message());

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

@@ -0,0 +1,43 @@
+mod bindings {
+    use super::Component;
+    wit_bindgen::generate!({
+        world: "basic-run-string",
+    });
+    export!(Component);
+}
+
+use crate::bindings::exports::jco::test_components::get_string;
+use crate::bindings::exports::jco::test_components::local_run_string;
+
+use std::sync::OnceLock;
+
+struct Component;
+
+static INIT_DATA: OnceLock<Option<String>> = OnceLock::new();
+
+/// Initialization takes the ENV value of "TEST" (if present)
+#[unsafe(no_mangle)]
+pub extern "C" fn _initialize() {
+    INIT_DATA.get_or_init(|| std::env::var("TEST").ok());
+}
+
+/// This version relies on the initialized data
+impl local_run_string::Guest for Component {
+    fn run() -> String {
+        INIT_DATA
+            .get()
+            .expect("failed to get init data")
+            .clone()
+            .expect("missing string in init data")
+    }
+}
+
+/// This version relies on the imported interface
+impl get_string::Guest for Component {
+    fn get_string() -> String {
+        bindings::jco::test_components::get_string::get_string()
+    }
+}
+
+// Stub only to ensure this works as a binary
+fn main() {}

crates/test-components/wit/all.wit

@@ -1,9 +1,17 @@
 package jco:test-components;
 
-interface local-run {
+interface local-run-async {
     run: async func();
 }
 
+interface local-run-string {
+    run: func() -> string;
+}
+
+interface get-string {
+    get-string: func() -> string;
+}
+
 interface async-add-s32 {
     add: async func(a: s32, b: s32) -> result<s32, string>;
 }
@@ -97,7 +105,7 @@ world async-simple-import {
 }
 
 world async-error-context {
-  export local-run;
+  export local-run-async;
 }
 
 world async-flat-param-adder {
@@ -138,4 +146,10 @@ interface fixed-length-lists-fn {
 
 world fixed-length-lists {
   export fixed-length-lists-fn;
-}
+}
+
+world basic-run-string {
+    import get-string;
+    export get-string;
+    export local-run-string;
+}

packages/jco/test/initialization.js

@@ -0,0 +1,81 @@
+import { join } from "node:path";
+
+import { suite, test, assert } from "vitest";
+
+import { WASIShim } from "@bytecodealliance/preview2-shim/instantiation";
+
+import { setupAsyncTest } from "./helpers.js";
+import { LOCAL_TEST_COMPONENTS_DIR } from "./common.js";
+
+suite("non-wizered raw initialize export", () => {
+    test("sync", async () => {
+        const name = "non-wizered-init";
+        // NOTE: simply importing the instance will run the initialization function,
+        // and it should not fail
+        const { instance, cleanup } = await setupAsyncTest({
+            component: {
+                name,
+                path: join(LOCAL_TEST_COMPONENTS_DIR, `${name}.wasm`),
+                imports: {
+                    ...new WASIShim({ sandbox: { env: { TEST: "YES" } } }).getImportObject(),
+                    "jco:test-components/get-string": {
+                        getString() {
+                            return "FROM IMPORT";
+                        },
+                    },
+                },
+            },
+            jco: {
+                transpile: {
+                    extraArgs: {
+                        minify: false,
+                    },
+                },
+            },
+        });
+
+        assert.strictEqual(instance["jco:test-components/local-run-string"].run(), "YES");
+        assert.strictEqual(instance["jco:test-components/get-string"].getString(), "FROM IMPORT");
+
+        await cleanup();
+    });
+
+    // TODO(breaking): remove this once manually specified async is removed
+    test("legacy async", async () => {
+        if (typeof WebAssembly?.Suspending !== "function") {
+            return;
+        }
+
+        const name = "non-wizered-init";
+        // NOTE: simply importing the instance will run the initialization function,
+        // and it should not fail
+        const { instance, cleanup } = await setupAsyncTest({
+            component: {
+                name,
+                path: join(LOCAL_TEST_COMPONENTS_DIR, `${name}.wasm`),
+                imports: {
+                    ...new WASIShim({ sandbox: { env: { TEST: "YES" } } }).getImportObject(),
+                    "jco:test-components/get-string": {
+                        async getString() {
+                            return "FROM IMPORT";
+                        },
+                    },
+                },
+            },
+            jco: {
+                transpile: {
+                    extraArgs: {
+                        minify: false,
+                        asyncMode: "jspi",
+                        asyncImports: ["jco:test-components/get-string#get-string"],
+                        asyncExports: ["jco:test-components/get-string#get-string"],
+                    },
+                },
+            },
+        });
+
+        assert.strictEqual(await instance["jco:test-components/get-string"].getString(), "FROM IMPORT");
+
+        await cleanup();
+    });
+});

packages/jco/test/p3/error-context.js

@@ -27,7 +27,7 @@ suite("Error Context (WASI P3)", () => {
         const { WASIShim } = await import("@bytecodealliance/preview2-shim/instantiation");
         const instance = await esModule.instantiate(undefined, new WASIShim().getImportObject());
 
-        const runFn = instance["jco:test-components/local-run"].run;
+        const runFn = instance["jco:test-components/local-run-async"].run;
         assert.strictEqual(runFn instanceof AsyncFunction, true, "run function should be async");
 
         await runFn();