quickjs-emscripten-sync 1.1.0 → 1.4.0

package/src/index.test.ts

@@ -1,40 +1,129 @@
 import { getQuickJS } from "quickjs-emscripten";
-import Arena from ".";
+import { describe, expect, test, vi } from "vitest";
+
+import { Arena } from ".";
+import { isWrapped } from "./wrapper";
+
+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);
+    const ctx = (await getQuickJS()).newContext();
+    const arena = new Arena(ctx, { isMarshalable: true });
 
     const result = arena.evalCode(
-      `({ a: 1, b: a => Math.floor(a), c: () => { throw new Error("hoge") } })`
+      `({
+        a: 1,
+        b: a => Math.floor(a),
+        c: () => { throw new Error("hoge") },
+        d: (yourFavoriteNumber) => ({
+          myFavoriteNumber: 42,
+          yourFavoriteNumber,
+        }),
+        get e() {
+          return { a: 1 };
+        }
+      })`
     );
     expect(result).toEqual({
       a: 1,
       b: expect.any(Function),
       c: expect.any(Function),
+      d: expect.any(Function),
+      e: { a: 1 },
     });
     expect(result.b(1.1)).toBe(1);
     expect(() => result.c()).toThrow("hoge");
+    expect(result.d(1)).toStrictEqual({
+      myFavoriteNumber: 42,
+      yourFavoriteNumber: 1,
+    });
+    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);
+    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("class", async () => {
-    const vm = (await getQuickJS()).createVm();
-    const arena = new Arena(vm);
+    const ctx = (await getQuickJS()).newContext();
+    const arena = new Arena(ctx, { isMarshalable: true });
 
     const instance = arena.evalCode(`{
       globalThis.Cls = class D {
@@ -45,7 +134,7 @@ describe("evalCode", () => {
           return ++this.a;
         }
       };
-  
+
       new Cls(100);
     }`);
     const Cls = arena.evalCode(`globalThis.Cls`);
@@ -55,12 +144,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);
+    const ctx = (await getQuickJS()).newContext();
+    const arena = new Arena(ctx, { isMarshalable: true });
 
     const obj = arena.evalCode(`globalThis.AAA = { a: 1 }`);
 
@@ -71,47 +160,109 @@ 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);
+    const ctx = (await getQuickJS()).newContext();
+    const arena = new Arena(ctx, { isMarshalable: true });
 
-    arena.expose({
-      obj: {
-        a: 1,
-        b: (a: number) => Math.floor(a),
-        c: () => {
-          throw new Error("hoge");
-        },
+    const obj = {
+      a: 1,
+      b: (a: number) => Math.floor(a),
+      c: () => {
+        throw new Error("hoge");
+      },
+      d: (yourFavoriteNumber: number) => ({
+        myFavoriteNumber: 42,
+        yourFavoriteNumber,
+      }),
+      get e() {
+        return { a: 1 };
       },
+    };
+    arena.expose({
+      obj,
     });
 
+    expect(arena.evalCode(`obj`)).toBe(obj);
     expect(arena.evalCode(`obj.a`)).toBe(1);
     expect(arena.evalCode(`obj.b(1.1)`)).toBe(1);
     expect(() => arena.evalCode(`obj.c()`)).toThrow("hoge");
+    expect(arena.evalCode(`obj.d(1)`)).toStrictEqual({
+      myFavoriteNumber: 42,
+      yourFavoriteNumber: 1,
+    });
+    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);
+    const ctx = (await getQuickJS()).newContext();
+    const arena = new Arena(ctx, { isMarshalable: true });
 
-    arena.expose({ Math });
-    expect(arena.evalCode(`Math.floor(1.1)`)).toBe(1);
+    arena.expose({ Math2: Math });
+    expect(arena.evalCode(`Math`)).not.toBe(Math);
+    expect(arena.evalCode(`Math2`)).toBe(Math);
+    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);
+    const ctx = (await getQuickJS()).newContext();
+    const arena = new Arena(ctx, { isMarshalable: true });
 
     class D {
       a: number;
@@ -125,19 +276,22 @@ describe("expose without sync", () => {
       }
     }
 
-    arena.expose({ D, d: new D(100) });
+    const d = new D(100);
+    arena.expose({ D, d });
+    expect(arena.evalCode(`D`)).toBe(D);
+    expect(arena.evalCode(`d`)).toBe(d);
     expect(arena.evalCode(`d instanceof D`)).toBe(true);
     expect(arena.evalCode(`d.a`)).toBe(101);
     expect(arena.evalCode(`d.foo()`)).toBe(102);
     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);
+    const ctx = (await getQuickJS()).newContext();
+    const arena = new Arena(ctx, { isMarshalable: true });
 
     const obj = {
       a: 1,
@@ -148,7 +302,11 @@ describe("expose without sync", () => {
     };
     arena.expose({ obj });
 
+    expect(arena.evalCode(`obj`)).toBe(obj);
+    expect(arena.evalCode(`obj.a`)).toBe(1);
+    expect(arena.evalCode(`obj.b`)).toBe(obj.b);
     expect(arena.evalCode(`obj.b(1.1)`)).toBe(1);
+    expect(arena.evalCode(`obj.c`)).toBe(obj.c);
     expect(arena.evalCode(`obj.c()`)).toBe(1);
     expect(arena.evalCode(`obj.a`)).toBe(2);
     expect(obj.a).toBe(2);
@@ -165,14 +323,14 @@ describe("expose without sync", () => {
     expect(arena.evalCode(`obj.a`)).toBe(100);
 
     arena.dispose();
-    vm.dispose();
+    ctx.dispose();
   });
 });
 
 describe("expose with sync", () => {
-  test("object and function", async () => {
-    const vm = (await getQuickJS()).createVm();
-    const arena = new Arena(vm);
+  test("sync before expose", async () => {
+    const ctx = (await getQuickJS()).newContext();
+    const arena = new Arena(ctx, { isMarshalable: true });
 
     const obj = {
       a: 1,
@@ -184,7 +342,61 @@ describe("expose with sync", () => {
     const obj2 = arena.sync(obj);
     arena.expose({ obj: obj2 });
 
+    const obj3 = arena.evalCode(`obj`);
+    expect(obj3).toBe(obj2);
+    expect(arena.evalCode(`obj.c`)).not.toBe(obj.c); // wrapped object
+    expect(arena.evalCode(`obj.b`)).not.toBe(obj2.b); // wrapped object
+    expect(arena.evalCode(`obj.b`)).not.toBe(obj3.b); // wrapped object
+    expect(arena.evalCode(`obj.b(1.1)`)).toBe(1);
+    expect(arena.evalCode(`obj.a`)).toBe(1);
+    expect(arena.evalCode(`obj.c`)).not.toBe(obj.c); // wrapped object
+    expect(arena.evalCode(`obj.c`)).not.toBe(obj2.c); // wrapped object
+    expect(arena.evalCode(`obj.c`)).not.toBe(obj3.c); // wrapped object
+    expect(arena.evalCode(`obj.c()`)).toBe(1);
+    expect(arena.evalCode(`obj.a`)).toBe(2);
+    expect(obj.a).toBe(2);
+    expect(arena.evalCode(`obj.c()`)).toBe(2);
+    expect(arena.evalCode(`obj.a`)).toBe(3);
+    expect(obj.a).toBe(3);
+
+    expect(obj).not.toBe(obj2);
+    obj2.a = 10;
+    expect(obj.a).toBe(10);
+    expect(arena.evalCode(`obj.a`)).toBe(10); // affected
+
+    arena.evalCode(`obj.a = 100`);
+    expect(obj.a).toBe(100); // affected
+    expect(arena.evalCode(`obj.a`)).toBe(100);
+
+    arena.dispose();
+    ctx.dispose();
+  });
+
+  test("sync after expose", async () => {
+    const ctx = (await getQuickJS()).newContext();
+    const arena = new Arena(ctx, { isMarshalable: true });
+
+    const obj = {
+      a: 1,
+      b: (a: number) => Math.floor(a),
+      c() {
+        return this.a++;
+      },
+    };
+    arena.expose({ obj });
+    const obj2 = arena.sync(obj);
+
+    const obj3 = arena.evalCode(`obj`);
+    expect(obj3).not.toBe(obj); // wrapped object
+    expect(obj3).not.toBe(obj2); // wrapped object
+    expect(arena.evalCode(`obj.c`)).not.toBe(obj.c); // wrapped object
+    expect(arena.evalCode(`obj.b`)).not.toBe(obj2.b); // wrapped object
+    expect(arena.evalCode(`obj.b`)).not.toBe(obj3.b); // wrapped object
     expect(arena.evalCode(`obj.b(1.1)`)).toBe(1);
+    expect(arena.evalCode(`obj.a`)).toBe(1);
+    expect(arena.evalCode(`obj.c`)).not.toBe(obj.c); // wrapped object
+    expect(arena.evalCode(`obj.c`)).not.toBe(obj2.c); // wrapped object
+    expect(arena.evalCode(`obj.c`)).not.toBe(obj3.c); // wrapped object
     expect(arena.evalCode(`obj.c()`)).toBe(1);
     expect(arena.evalCode(`obj.a`)).toBe(2);
     expect(obj.a).toBe(2);
@@ -202,17 +414,18 @@ 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);
+  const ctx = (await getQuickJS()).newContext();
+  const arena = new Arena(ctx, { isMarshalable: true });
 
   const obj = arena.evalCode(`({ a: 1, b: 1 })`);
   arena.expose({ obj });
 
+  expect(obj).toBe(obj);
   expect(obj.a).toBe(1);
   expect(arena.evalCode(`obj.a`)).toBe(1);
   expect(obj.b).toBe(1);
@@ -233,35 +446,47 @@ 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);
+  const ctx = (await getQuickJS()).newContext();
+  const arena = new Arena(ctx, { isMarshalable: true });
 
   const obj = { a: 1 };
-  const obj2 = arena.sync(obj);
-  arena.expose({ obj: obj2 });
-  const obj3 = arena.evalCode(`obj`);
+  arena.expose({ obj });
+  const obj2 = arena.evalCode(`obj`);
 
-  expect(obj3).toBe(obj2);
+  expect(obj2).toBe(obj);
 
-  obj3.a = 2;
+  obj2.a = 2;
   expect(obj.a).toBe(2);
-  expect(arena.evalCode(`obj.a`)).toBe(2);
+  expect(arena.evalCode(`obj.a`)).toBe(1);
+
+  arena.evalCode("obj.a = 3");
+  expect(obj.a).toBe(2);
+  expect(arena.evalCode(`obj.a`)).toBe(3);
 
-  arena.evalCode("obj.a = 4");
-  expect(obj.a).toBe(4);
-  expect(arena.evalCode(`obj.a`)).toBe(4);
+  arena.dispose();
+  ctx.dispose();
+});
+
+test("evalCode -> expose -> evalCode", async () => {
+  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);
+  arena.expose({ obj });
+  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, { registeredObjects: [] });
+  const ctx = (await getQuickJS()).newContext();
+  const arena = new Arena(ctx, { isMarshalable: true, registeredObjects: [] });
 
   arena.register(Math, `Math`);
   expect(arena.evalCode(`Math`)).toBe(Math);
@@ -276,12 +501,13 @@ 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"]],
   });
 
@@ -291,17 +517,93 @@ test("registeredObjects option", async () => {
   );
 
   arena.dispose();
-  vm.dispose();
+  ctx.dispose();
 });
 
-test("isMarshalable option", async () => {
-  const vm = (await getQuickJS()).createVm();
-  const arena = new Arena(vm, {
-    isMarshalable: o => o !== globalThis,
+describe("isMarshalable option", () => {
+  test("false", async () => {
+    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);
+    arena.expose({ aaa: globalThis });
+    expect(arena.evalCode(`aaa`)).toBeUndefined();
+
+    arena.dispose();
+    ctx.dispose();
   });
 
-  expect(arena.evalCode(`s => s === undefined`)(globalThis)).toBe(true);
+  test("json", async () => {
+    const ctx = (await getQuickJS()).newContext();
+    const arena = new Arena(ctx, { isMarshalable: "json" });
 
-  arena.dispose();
-  vm.dispose();
+    const obj = { a: () => {}, b: new Date(), c: [() => {}, 1] };
+    const objJSON = { b: obj.b.toISOString(), c: [null, 1] };
+    const objJSON2 = arena.evalCode(`a => a`)(obj);
+    expect(objJSON2).toStrictEqual(objJSON);
+    arena.expose({ obj });
+    const exposedObj = arena.evalCode(`obj`);
+    expect(exposedObj).toStrictEqual(objJSON);
+    expect(exposedObj).not.toBe(objJSON2);
+
+    arena.dispose();
+    ctx.dispose();
+  });
+
+  test("conditional", async () => {
+    const ctx = (await getQuickJS()).newContext();
+    const arena = new Arena(ctx, {
+      isMarshalable: (o) => o !== globalThis,
+    });
+
+    const obj = { a: 1 };
+    expect(arena.evalCode(`s => s === undefined`)(globalThis)).toBe(true);
+    expect(arena.evalCode(`s => s === undefined`)(obj)).toBe(false);
+    arena.expose({ aaa: globalThis, bbb: obj });
+    expect(arena.evalCode(`aaa`)).toBeUndefined();
+    expect(arena.evalCode(`bbb`)).toBe(obj);
+
+    arena.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
+  });
 });