quickjs-emscripten-sync 1.2.0 → 1.5.0

package/src/index.test.ts

@@ -1,10 +1,82 @@
 import { getQuickJS } from "quickjs-emscripten";
+import { describe, expect, test, vi } from "vitest";
+
+import { isWrapped } from "./wrapper";
+
 import { Arena } from ".";
 
+describe("readme", () => {
+  test("first", async () => {
+    class Cls {
+      field = 0;
+
+      method() {
+        return ++this.field;
+      }
+    }
+
+    const ctx = (await getQuickJS()).newContext();
+    const arena = new Arena(ctx, { isMarshalable: true });
+
+    // We can pass objects to the VM and run code safely
+    const exposed = {
+      Cls,
+      cls: new Cls(),
+      syncedCls: arena.sync(new Cls()),
+    };
+    arena.expose(exposed);
+
+    expect(arena.evalCode(`cls instanceof Cls`)).toBe(true);
+    expect(arena.evalCode(`cls.field`)).toBe(0);
+    expect(arena.evalCode(`cls.method()`)).toBe(1);
+    expect(arena.evalCode(`cls.field`)).toBe(1);
+
+    expect(arena.evalCode(`syncedCls.field`)).toBe(0);
+    expect(exposed.syncedCls.method()).toBe(1);
+    expect(arena.evalCode(`syncedCls.field`)).toBe(1);
+
+    arena.dispose();
+    ctx.dispose();
+  });
+
+  test("usage", async () => {
+    const quickjs = await getQuickJS();
+    const ctx = quickjs.newContext();
+
+    // init Arena
+    // ⚠️ Marshaling is opt-in for security reasons.
+    // ⚠️ Be careful when activating marshalling.
+    const arena = new Arena(ctx, { isMarshalable: true });
+
+    // expose objects as global objects in QuickJS VM
+    const log = vi.fn();
+    arena.expose({
+      console: { log },
+    });
+    arena.evalCode(`console.log("hello, world");`); // run console.log
+    expect(log).toBeCalledWith("hello, world");
+    arena.evalCode(`1 + 1`); // 2
+
+    // expose objects but also enable sync
+    const data = arena.sync({ hoge: "foo" });
+    arena.expose({ data });
+
+    arena.evalCode(`data.hoge = "bar"`);
+    // eval code and operations to exposed objects are automatically synced
+    expect(data.hoge).toBe("bar");
+    data.hoge = "changed!";
+    expect(arena.evalCode(`data.hoge`)).toBe("changed!");
+
+    // Don't forget calling arena.dispose() before disposing QuickJS VM!
+    arena.dispose();
+    ctx.dispose();
+  });
+});
+
 describe("evalCode", () => {
   test("simple object and function", async () => {
-    const vm = (await getQuickJS()).createVm();
-    const arena = new Arena(vm, { isMarshalable: true });
+    const ctx = (await getQuickJS()).newContext();
+    const arena = new Arena(ctx, { isMarshalable: true });
 
     const result = arena.evalCode(
       `({
@@ -18,7 +90,7 @@ describe("evalCode", () => {
         get e() {
           return { a: 1 };
         }
-      })`
+      })`,
     );
     expect(result).toEqual({
       a: 1,
@@ -36,23 +108,36 @@ describe("evalCode", () => {
     expect(result.e).toStrictEqual({ a: 1 });
 
     arena.dispose();
-    vm.dispose();
+    ctx.dispose();
   });
 
   test("Math", async () => {
-    const vm = (await getQuickJS()).createVm();
-    const arena = new Arena(vm, { isMarshalable: true });
+    const ctx = (await getQuickJS()).newContext();
+    const arena = new Arena(ctx, { isMarshalable: true });
 
     const VMMath = arena.evalCode(`Math`) as Math;
     expect(VMMath.floor(1.1)).toBe(1);
 
     arena.dispose();
-    vm.dispose();
+    ctx.dispose();
+  });
+
+  test("Date", async () => {
+    const ctx = (await getQuickJS()).newContext();
+    const arena = new Arena(ctx, { isMarshalable: true });
+
+    const date = new Date(2022, 7, 26);
+    expect(arena.evalCode("new Date(2022, 7, 26)")).toEqual(date);
+    expect(arena.evalCode("d => d instanceof Date")(date)).toBe(true);
+    expect(arena.evalCode("d => d.getTime()")(date)).toBe(date.getTime());
+
+    arena.dispose();
+    ctx.dispose();
   });
 
   test("class", async () => {
-    const vm = (await getQuickJS()).createVm();
-    const arena = new Arena(vm, { isMarshalable: true });
+    const ctx = (await getQuickJS()).newContext();
+    const arena = new Arena(ctx, { isMarshalable: true });
 
     const instance = arena.evalCode(`{
       globalThis.Cls = class D {
@@ -73,12 +158,12 @@ describe("evalCode", () => {
     expect(instance.a).toBe(102);
 
     arena.dispose();
-    vm.dispose();
+    ctx.dispose();
   });
 
   test("obj", async () => {
-    const vm = (await getQuickJS()).createVm();
-    const arena = new Arena(vm, { isMarshalable: true });
+    const ctx = (await getQuickJS()).newContext();
+    const arena = new Arena(ctx, { isMarshalable: true });
 
     const obj = arena.evalCode(`globalThis.AAA = { a: 1 }`);
 
@@ -89,14 +174,56 @@ describe("evalCode", () => {
     expect(arena.evalCode(`AAA.a`)).toBe(2);
 
     arena.dispose();
-    vm.dispose();
+    ctx.dispose();
+  });
+
+  test("promise", async () => {
+    const ctx = (await getQuickJS()).newContext();
+    const arena = new Arena(ctx, { isMarshalable: true });
+
+    const [promise, resolve] = arena.evalCode<[Promise<string>, (d: string) => void]>(`
+      let resolve;
+      const promise = new Promise(r => {
+        resolve = r;
+      }).then(d => d + "!");
+      [promise, resolve]
+    `);
+    expect(promise).instanceOf(Promise);
+    expect(isWrapped(arena._unwrapIfNotSynced(promise), arena._symbol)).toBe(false);
+
+    resolve("hoge");
+    expect(arena.executePendingJobs()).toBe(2);
+    expect(await promise).toBe("hoge!");
+
+    arena.dispose();
+    ctx.dispose();
+  });
+
+  test("promise2", async () => {
+    const ctx = (await getQuickJS()).newContext();
+    const arena = new Arena(ctx, { isMarshalable: true });
+
+    const deferred: { resolve?: (s: string) => void } = {};
+    const promise = new Promise(resolve => {
+      deferred.resolve = resolve;
+    });
+    const res = vi.fn();
+    arena.evalCode(`(p, r) => { p.then(d => { r(d + "!"); }); }`)(promise, res);
+
+    deferred.resolve?.("hoge");
+    await promise;
+    expect(arena.executePendingJobs()).toBe(1);
+    expect(res).toBeCalledWith("hoge!");
+
+    arena.dispose();
+    ctx.dispose();
   });
 });
 
 describe("expose without sync", () => {
   test("simple object and function", async () => {
-    const vm = (await getQuickJS()).createVm();
-    const arena = new Arena(vm, { isMarshalable: true });
+    const ctx = (await getQuickJS()).newContext();
+    const arena = new Arena(ctx, { isMarshalable: true });
 
     const obj = {
       a: 1,
@@ -127,12 +254,12 @@ describe("expose without sync", () => {
     expect(arena.evalCode(`obj.e`)).toStrictEqual({ a: 1 });
 
     arena.dispose();
-    vm.dispose();
+    ctx.dispose();
   });
 
   test("Math", async () => {
-    const vm = (await getQuickJS()).createVm();
-    const arena = new Arena(vm, { isMarshalable: true });
+    const ctx = (await getQuickJS()).newContext();
+    const arena = new Arena(ctx, { isMarshalable: true });
 
     arena.expose({ Math2: Math });
     expect(arena.evalCode(`Math`)).not.toBe(Math);
@@ -140,12 +267,12 @@ describe("expose without sync", () => {
     expect(arena.evalCode(`Math2.floor(1.1)`)).toBe(1);
 
     arena.dispose();
-    vm.dispose();
+    ctx.dispose();
   });
 
   test("class", async () => {
-    const vm = (await getQuickJS()).createVm();
-    const arena = new Arena(vm, { isMarshalable: true });
+    const ctx = (await getQuickJS()).newContext();
+    const arena = new Arena(ctx, { isMarshalable: true });
 
     class D {
       a: number;
@@ -169,12 +296,12 @@ describe("expose without sync", () => {
     expect(arena.evalCode(`d.a`)).toBe(102);
 
     arena.dispose();
-    vm.dispose();
+    ctx.dispose();
   });
 
   test("object and function", async () => {
-    const vm = (await getQuickJS()).createVm();
-    const arena = new Arena(vm, { isMarshalable: true });
+    const ctx = (await getQuickJS()).newContext();
+    const arena = new Arena(ctx, { isMarshalable: true });
 
     const obj = {
       a: 1,
@@ -206,14 +333,14 @@ describe("expose without sync", () => {
     expect(arena.evalCode(`obj.a`)).toBe(100);
 
     arena.dispose();
-    vm.dispose();
+    ctx.dispose();
   });
 });
 
 describe("expose with sync", () => {
   test("sync before expose", async () => {
-    const vm = (await getQuickJS()).createVm();
-    const arena = new Arena(vm, { isMarshalable: true });
+    const ctx = (await getQuickJS()).newContext();
+    const arena = new Arena(ctx, { isMarshalable: true });
 
     const obj = {
       a: 1,
@@ -252,12 +379,12 @@ describe("expose with sync", () => {
     expect(arena.evalCode(`obj.a`)).toBe(100);
 
     arena.dispose();
-    vm.dispose();
+    ctx.dispose();
   });
 
   test("sync after expose", async () => {
-    const vm = (await getQuickJS()).createVm();
-    const arena = new Arena(vm, { isMarshalable: true });
+    const ctx = (await getQuickJS()).newContext();
+    const arena = new Arena(ctx, { isMarshalable: true });
 
     const obj = {
       a: 1,
@@ -297,13 +424,13 @@ describe("expose with sync", () => {
     expect(arena.evalCode(`obj.a`)).toBe(100);
 
     arena.dispose();
-    vm.dispose();
+    ctx.dispose();
   });
 });
 
 test("evalCode -> expose", async () => {
-  const vm = (await getQuickJS()).createVm();
-  const arena = new Arena(vm, { isMarshalable: true });
+  const ctx = (await getQuickJS()).newContext();
+  const arena = new Arena(ctx, { isMarshalable: true });
 
   const obj = arena.evalCode(`({ a: 1, b: 1 })`);
   arena.expose({ obj });
@@ -329,12 +456,12 @@ test("evalCode -> expose", async () => {
   expect(arena.evalCode(`obj.b`)).toBe(2);
 
   arena.dispose();
-  vm.dispose();
+  ctx.dispose();
 });
 
 test("expose -> evalCode", async () => {
-  const vm = (await getQuickJS()).createVm();
-  const arena = new Arena(vm, { isMarshalable: true });
+  const ctx = (await getQuickJS()).newContext();
+  const arena = new Arena(ctx, { isMarshalable: true });
 
   const obj = { a: 1 };
   arena.expose({ obj });
@@ -351,12 +478,12 @@ test("expose -> evalCode", async () => {
   expect(arena.evalCode(`obj.a`)).toBe(3);
 
   arena.dispose();
-  vm.dispose();
+  ctx.dispose();
 });
 
 test("evalCode -> expose -> evalCode", async () => {
-  const vm = (await getQuickJS()).createVm();
-  const arena = new Arena(vm, { isMarshalable: true });
+  const ctx = (await getQuickJS()).newContext();
+  const arena = new Arena(ctx, { isMarshalable: true });
 
   const obj = [1];
   expect(arena.evalCode("a => a[0] + 10")(obj)).toBe(11);
@@ -364,12 +491,12 @@ test("evalCode -> expose -> evalCode", async () => {
   expect(arena.evalCode("obj")).toBe(obj);
 
   arena.dispose();
-  vm.dispose();
+  ctx.dispose();
 });
 
 test("register and unregister", async () => {
-  const vm = (await getQuickJS()).createVm();
-  const arena = new Arena(vm, { isMarshalable: true, registeredObjects: [] });
+  const ctx = (await getQuickJS()).newContext();
+  const arena = new Arena(ctx, { isMarshalable: true, registeredObjects: [] });
 
   arena.register(Math, `Math`);
   expect(arena.evalCode(`Math`)).toBe(Math);
@@ -384,29 +511,27 @@ test("register and unregister", async () => {
   expect(arena.evalCode(`new Error()`)).toBeInstanceOf(Error);
 
   arena.dispose();
-  vm.dispose();
+  ctx.dispose();
 });
 
 test("registeredObjects option", async () => {
-  const vm = (await getQuickJS()).createVm();
-  const arena = new Arena(vm, {
+  const ctx = (await getQuickJS()).newContext();
+  const arena = new Arena(ctx, {
     isMarshalable: true,
     registeredObjects: [[Symbol.iterator, "Symbol.iterator"]],
   });
 
   expect(arena.evalCode(`Symbol.iterator`)).toBe(Symbol.iterator);
-  expect(arena.evalCode(`s => s === Symbol.iterator`)(Symbol.iterator)).toBe(
-    true
-  );
+  expect(arena.evalCode(`s => s === Symbol.iterator`)(Symbol.iterator)).toBe(true);
 
   arena.dispose();
-  vm.dispose();
+  ctx.dispose();
 });
 
 describe("isMarshalable option", () => {
   test("false", async () => {
-    const vm = (await getQuickJS()).createVm();
-    const arena = new Arena(vm, { isMarshalable: false });
+    const ctx = (await getQuickJS()).newContext();
+    const arena = new Arena(ctx, { isMarshalable: false });
 
     expect(arena.evalCode(`s => s === undefined`)(globalThis)).toBe(true);
     expect(arena.evalCode(`s => s === undefined`)({})).toBe(true);
@@ -414,12 +539,12 @@ describe("isMarshalable option", () => {
     expect(arena.evalCode(`aaa`)).toBeUndefined();
 
     arena.dispose();
-    vm.dispose();
+    ctx.dispose();
   });
 
   test("json", async () => {
-    const vm = (await getQuickJS()).createVm();
-    const arena = new Arena(vm, { isMarshalable: "json" });
+    const ctx = (await getQuickJS()).newContext();
+    const arena = new Arena(ctx, { isMarshalable: "json" });
 
     const obj = { a: () => {}, b: new Date(), c: [() => {}, 1] };
     const objJSON = { b: obj.b.toISOString(), c: [null, 1] };
@@ -431,13 +556,13 @@ describe("isMarshalable option", () => {
     expect(exposedObj).not.toBe(objJSON2);
 
     arena.dispose();
-    vm.dispose();
+    ctx.dispose();
   });
 
   test("conditional", async () => {
-    const vm = (await getQuickJS()).createVm();
-    const arena = new Arena(vm, {
-      isMarshalable: (o) => o !== globalThis,
+    const ctx = (await getQuickJS()).newContext();
+    const arena = new Arena(ctx, {
+      isMarshalable: o => o !== globalThis,
     });
 
     const obj = { a: 1 };
@@ -448,6 +573,45 @@ describe("isMarshalable option", () => {
     expect(arena.evalCode(`bbb`)).toBe(obj);
 
     arena.dispose();
-    vm.dispose();
+    ctx.dispose();
+  });
+});
+
+describe("edge cases", () => {
+  test("getter", async () => {
+    const ctx = (await getQuickJS()).newContext();
+    const arena = new Arena(ctx, { isMarshalable: true });
+
+    const called: string[] = [];
+    const obj = { c: 0 };
+    const exposed = {
+      get a() {
+        called.push("a");
+        return {
+          get b() {
+            called.push("b");
+            return obj;
+          },
+        };
+      },
+    };
+    const cb: { current?: () => any } = {};
+    const register = (fn: () => any) => {
+      cb.current = fn;
+    };
+
+    arena.expose({ exposed, register });
+    expect(called).toEqual([]);
+
+    arena.evalCode(`register(() => exposed.a.b.c);`);
+    expect(cb.current?.()).toBe(0);
+    expect(called).toEqual(["a", "b"]);
+
+    obj.c = 1;
+    expect(cb.current?.()).toBe(1); // this line causes an error when context is disposed
+    expect(called).toEqual(["a", "b", "a", "b"]);
+
+    arena.dispose();
+    // ctx.dispose(); // reports an error
   });
 });