test(import): add test for calling JS func in Rust

🐀 the use case would be having lifecycle hook in wasm code

Author: DrSensor

test/export.spec.js

@@ -52,21 +52,4 @@ describe('test export option', () => {
     expect(wasmInstance).toBeInstanceOf(WebAssembly.Instance);
     expect(wasmInstance.exports.add(1, 2)).toBe(3); // can be used directly, not suitable for big size wasm
   });
-
-  test('export of WebAssembly.instantiate', async () => {
-    const bundle = await rollup({
-      input,
-      plugins: [rust({ export: 'promise' })]
-    });
-
-    const compileWasm = await require(bundle);
-
-    // Usage
-    const { module, instance } = await compileWasm;
-    const { add } = instance.exports;
-
-    expect(module).toBeInstanceOf(WebAssembly.Module);
-    expect(instance).toBeInstanceOf(WebAssembly.Instance);
-    expect(add(1, 2)).toBe(3);
-  });
 });

test/fixtures/hook_function/Cargo.toml

@@ -0,0 +1,8 @@
+[package]
+name = "adder"
+version = "0.1.0"
+authors = ["Fahmi Akbar Wildana <fahmi.a.w@gmail.com>"]
+
+[lib]
+crate-type = ["cdylib"]
+path = "lib.rs"

test/fixtures/hook_function/index.js

@@ -0,0 +1 @@
+export * from './lib.rs';

test/fixtures/hook_function/lib.rs

@@ -0,0 +1,13 @@
+#[link(wasm_import_module = "hook")]
+extern {
+    fn before(a: u8, b: u8);
+    fn after(c: u8);
+}
+
+#[no_mangle]
+pub fn add(a: u8, b: u8) -> u8 {
+    unsafe { before(a, b) };
+    let c = a + b;
+    unsafe { after(c) };
+    return c;
+}

test/import.spec.js

@@ -0,0 +1,84 @@
+// @flow
+import { rollup } from 'rollup';
+import { require } from './util';
+import rust from '../src/main.js';
+
+describe('test export option for importjs', () => {
+  const input = 'test/fixtures/hook_function/index.js';
+
+  test('export of WebAssembly.compile', async () => {
+    const bundle = await rollup({
+      input,
+      plugins: [rust({ export: 'async-module' })]
+    });
+
+    const compileWasm = await require(bundle);
+
+    // Usage
+    const importObj = {
+      hook: {
+        before: jest.fn(),
+        after: jest.fn()
+      }
+    };
+    const module = await compileWasm();
+    const instance = new WebAssembly.Instance(module, importObj);
+    const { add } = instance.exports;
+
+    expect(module).toBeInstanceOf(WebAssembly.Module);
+    expect(instance).toBeInstanceOf(WebAssembly.Instance);
+    // $FlowFixMe: false alarm
+    expect(add(1, 2)).toBe(3);
+    expect(importObj.hook.before).toHaveBeenCalledWith(1, 2);
+    expect(importObj.hook.after).toHaveBeenCalledWith(3);
+  });
+
+  test('export of WebAssembly.instantiate(WebAssembly.Module)', async () => {
+    const bundle = await rollup({
+      input,
+      plugins: [rust({ export: 'async-instance' })]
+    });
+
+    const compileWasm = await require(bundle);
+
+    // Usage
+    const importObj = {
+      hook: {
+        before: jest.fn(),
+        after: jest.fn()
+      }
+    };
+    const instance = await compileWasm(importObj);
+    const { add } = instance.exports;
+
+    expect(instance).toBeInstanceOf(WebAssembly.Instance);
+    expect(add(1, 2)).toBe(3);
+    expect(importObj.hook.before).toHaveBeenCalledWith(1, 2);
+    expect(importObj.hook.after).toHaveBeenCalledWith(3);
+  });
+
+  test('export of WebAssembly.instantiate(Buffer)', async () => {
+    const bundle = await rollup({
+      input,
+      plugins: [rust({ export: 'async' })]
+    });
+
+    const compileWasm = await require(bundle);
+
+    // Usage
+    const importObj = {
+      hook: {
+        before: jest.fn(),
+        after: jest.fn()
+      }
+    };
+    const { module, instance } = await compileWasm(importObj);
+    const { add } = instance.exports;
+
+    expect(module).toBeInstanceOf(WebAssembly.Module);
+    expect(instance).toBeInstanceOf(WebAssembly.Instance);
+    expect(add(1, 2)).toBe(3);
+    expect(importObj.hook.before).toHaveBeenCalledWith(1, 2);
+    expect(importObj.hook.after).toHaveBeenCalledWith(3);
+  });
+});