quickjs-emscripten-sync 1.1.0 → 1.4.0

package/src/wrapper.test.ts

@@ -1,4 +1,6 @@
 import { QuickJSHandle, getQuickJS } from "quickjs-emscripten";
+import { expect, test, vi } from "vitest";
+
 import {
   wrap,
   unwrap,
@@ -8,22 +10,22 @@ import {
   isHandleWrapped,
   SyncMode,
 } from "./wrapper";
-import { call, eq, send } from "./vmutil";
+import { call, eq, json } from "./vmutil";
 
 test("wrap, unwrap, isWrapped", async () => {
-  const vm = (await getQuickJS()).createVm();
+  const ctx = (await getQuickJS()).newContext();
   const target = { a: 1 };
-  const handle = vm.unwrapResult(vm.evalCode(`({ a: 1 })`));
+  const handle = ctx.unwrapResult(ctx.evalCode(`({ a: 1 })`));
   const proxyKeySymbol = Symbol();
-  const proxyKeySymbolHandle = vm.unwrapResult(vm.evalCode(`Symbol()`));
-  const marshal = jest.fn();
-  const syncMode = jest.fn();
+  const proxyKeySymbolHandle = ctx.unwrapResult(ctx.evalCode(`Symbol()`));
+  const marshal = vi.fn();
+  const syncMode = vi.fn();
 
   expect(isWrapped(target, proxyKeySymbol)).toBe(false);
   expect(unwrap(target, proxyKeySymbol)).toBe(target);
 
   const wrapped = wrap(
-    vm,
+    ctx,
     target,
     proxyKeySymbol,
     proxyKeySymbolHandle,
@@ -37,25 +39,37 @@ test("wrap, unwrap, isWrapped", async () => {
   expect(unwrap(wrapped, proxyKeySymbol)).toBe(target);
 
   expect(
-    wrap(vm, wrapped, proxyKeySymbol, proxyKeySymbolHandle, marshal, syncMode)
+    wrap(ctx, wrapped, proxyKeySymbol, proxyKeySymbolHandle, marshal, syncMode)
   ).toBe(wrapped);
 
+  // promise cannot be wrapped
+  expect(
+    wrap(
+      ctx,
+      Promise.resolve(1),
+      proxyKeySymbol,
+      proxyKeySymbolHandle,
+      marshal,
+      syncMode
+    )
+  ).toBeUndefined();
+
   proxyKeySymbolHandle.dispose();
   handle.dispose();
-  vm.dispose();
+  ctx.dispose();
 });
 
 test("wrap without sync", async () => {
-  const vm = (await getQuickJS()).createVm();
+  const ctx = (await getQuickJS()).newContext();
   const target = { a: 1 };
-  const handle = vm.unwrapResult(vm.evalCode(`({ a: 1 })`));
+  const handle = ctx.unwrapResult(ctx.evalCode(`({ a: 1 })`));
   const proxyKeySymbol = Symbol();
-  const proxyKeySymbolHandle = vm.unwrapResult(vm.evalCode(`Symbol()`));
-  const marshal = jest.fn();
-  const syncMode = jest.fn();
+  const proxyKeySymbolHandle = ctx.unwrapResult(ctx.evalCode(`Symbol()`));
+  const marshal = vi.fn();
+  const syncMode = vi.fn();
 
   const wrapped = wrap(
-    vm,
+    ctx,
     target,
     proxyKeySymbol,
     proxyKeySymbolHandle,
@@ -70,29 +84,33 @@ test("wrap without sync", async () => {
   wrapped.a = 2;
 
   expect(target.a).toBe(2);
-  expect(vm.dump(vm.getProp(handle, "a"))).toBe(1); // not synced
+  expect(ctx.dump(ctx.getProp(handle, "a"))).toBe(1); // not synced
   expect(marshal).toBeCalledTimes(0);
   expect(syncMode).toBeCalledTimes(1);
   expect(syncMode).toBeCalledWith(wrapped);
 
   proxyKeySymbolHandle.dispose();
   handle.dispose();
-  vm.dispose();
+  ctx.dispose();
+
+  wrapped.a = 3; // no error even if vm is disposed
+  expect(wrapped.a).toBe(3);
 });
 
 test("wrap with both sync", async () => {
-  const vm = (await getQuickJS()).createVm();
+  const ctx = (await getQuickJS()).newContext();
   const target = { a: 1 } as { a?: number };
-  const handle = vm.unwrapResult(vm.evalCode(`({ a: 1 })`));
+  const handle = ctx.unwrapResult(ctx.evalCode(`({ a: 1 })`));
   const proxyKeySymbol = Symbol();
-  const proxyKeySymbolHandle = vm.unwrapResult(vm.evalCode(`Symbol()`));
-  const marshal = jest.fn(
-    (t: any): QuickJSHandle => (t === wrapped ? handle : send(vm, t))
-  );
-  const syncMode = jest.fn((): SyncMode => "both");
+  const proxyKeySymbolHandle = ctx.unwrapResult(ctx.evalCode(`Symbol()`));
+  const marshal = vi.fn((t: any): [QuickJSHandle, boolean] => [
+    t === wrapped ? handle : json(ctx, t),
+    false,
+  ]);
+  const syncMode = vi.fn((): SyncMode => "both");
 
   const wrapped = wrap(
-    vm,
+    ctx,
     target,
     proxyKeySymbol,
     proxyKeySymbolHandle,
@@ -107,7 +125,7 @@ test("wrap with both sync", async () => {
   wrapped.a = 2;
 
   expect(target.a).toBe(2);
-  expect(vm.dump(vm.getProp(handle, "a"))).toBe(2); // synced
+  expect(ctx.dump(ctx.getProp(handle, "a"))).toBe(2); // synced
   expect(marshal).toBeCalledTimes(3);
   expect(marshal).toBeCalledWith(2);
   expect(marshal).toBeCalledWith("a");
@@ -116,26 +134,30 @@ test("wrap with both sync", async () => {
 
   delete wrapped.a;
   expect(target.a).toBe(undefined);
-  expect(vm.dump(vm.getProp(handle, "a"))).toBe(undefined); // synced
+  expect(ctx.dump(ctx.getProp(handle, "a"))).toBe(undefined); // synced
 
   proxyKeySymbolHandle.dispose();
   handle.dispose();
-  vm.dispose();
+  ctx.dispose();
+
+  wrapped.a = 3; // no error even if vm is disposed
+  expect(wrapped.a).toBe(3);
 });
 
 test("wrap with vm sync", async () => {
-  const vm = (await getQuickJS()).createVm();
+  const ctx = (await getQuickJS()).newContext();
   const target = { a: 1 } as { a?: number };
-  const handle = vm.unwrapResult(vm.evalCode(`({ a: 1 })`));
+  const handle = ctx.unwrapResult(ctx.evalCode(`({ a: 1 })`));
   const proxyKeySymbol = Symbol();
-  const proxyKeySymbolHandle = vm.unwrapResult(vm.evalCode(`Symbol()`));
-  const marshal = jest.fn(
-    (t: any): QuickJSHandle => (t === wrapped ? handle : send(vm, t))
-  );
-  const syncMode = jest.fn((): SyncMode => "vm");
+  const proxyKeySymbolHandle = ctx.unwrapResult(ctx.evalCode(`Symbol()`));
+  const marshal = vi.fn((t: any): [QuickJSHandle, boolean] => [
+    t === wrapped ? handle : json(ctx, t),
+    false,
+  ]);
+  const syncMode = vi.fn((): SyncMode => "vm");
 
   const wrapped = wrap(
-    vm,
+    ctx,
     target,
     proxyKeySymbol,
     proxyKeySymbolHandle,
@@ -150,7 +172,7 @@ test("wrap with vm sync", async () => {
   wrapped.a = 2;
 
   expect(target.a).toBe(1); // not set
-  expect(vm.dump(vm.getProp(handle, "a"))).toBe(2); // synced
+  expect(ctx.dump(ctx.getProp(handle, "a"))).toBe(2); // synced
   expect(marshal).toBeCalledTimes(3);
   expect(marshal).toBeCalledWith(2);
   expect(marshal).toBeCalledWith("a");
@@ -159,30 +181,33 @@ test("wrap with vm sync", async () => {
 
   delete wrapped.a;
   expect(target.a).toBe(1); // not deleted
-  expect(vm.dump(vm.getProp(handle, "a"))).toBe(undefined); // synced
+  expect(ctx.dump(ctx.getProp(handle, "a"))).toBe(undefined); // synced
 
   proxyKeySymbolHandle.dispose();
   handle.dispose();
-  vm.dispose();
+  ctx.dispose();
+
+  wrapped.a = 3; // no error even after vm is disposed
+  expect(wrapped.a).toBe(1); // vm mode cannot modify obj in host
 });
 
 test("wrapHandle, unwrapHandle, isHandleWrapped", async () => {
-  const vm = (await getQuickJS()).createVm();
+  const ctx = (await getQuickJS()).newContext();
   const target = { a: 1 };
-  const handle = vm.unwrapResult(vm.evalCode(`({ a: 1 })`));
+  const handle = ctx.unwrapResult(ctx.evalCode(`({ a: 1 })`));
   const proxyKeySymbol = Symbol();
-  const proxyKeySymbolHandle = vm.unwrapResult(vm.evalCode(`Symbol()`));
-  const unmarshal = jest.fn();
-  const syncMode = jest.fn();
+  const proxyKeySymbolHandle = ctx.unwrapResult(ctx.evalCode(`Symbol()`));
+  const unmarshal = vi.fn();
+  const syncMode = vi.fn();
 
-  expect(isHandleWrapped(vm, handle, proxyKeySymbolHandle)).toBe(false);
-  expect(unwrapHandle(vm, handle, proxyKeySymbolHandle)).toEqual([
+  expect(isHandleWrapped(ctx, handle, proxyKeySymbolHandle)).toBe(false);
+  expect(unwrapHandle(ctx, handle, proxyKeySymbolHandle)).toEqual([
     handle,
     false,
   ]);
 
   const [wrapped, w] = wrapHandle(
-    vm,
+    ctx,
     handle,
     proxyKeySymbol,
     proxyKeySymbolHandle,
@@ -191,18 +216,22 @@ test("wrapHandle, unwrapHandle, isHandleWrapped", async () => {
   );
   if (!wrapped || !w) throw new Error("wrapped is undefined");
 
-  expect(vm.dump(wrapped)).toEqual(target); // vm.dump does not support proxies
-  expect(vm.dump(vm.getProp(wrapped, "a"))).toBe(1);
-  expect(isHandleWrapped(vm, wrapped, proxyKeySymbolHandle)).toBe(true);
+  expect(ctx.dump(wrapped)).toEqual(target); // vm.dump does not support proxies
+  expect(ctx.dump(ctx.getProp(wrapped, "a"))).toBe(1);
+  expect(isHandleWrapped(ctx, wrapped, proxyKeySymbolHandle)).toBe(true);
 
-  const [handle2, unwrapped2] = unwrapHandle(vm, wrapped, proxyKeySymbolHandle);
+  const [handle2, unwrapped2] = unwrapHandle(
+    ctx,
+    wrapped,
+    proxyKeySymbolHandle
+  );
   expect(unwrapped2).toBe(true);
-  handle2.consume(h => {
-    expect(eq(vm, handle, h)).toBe(true);
+  handle2.consume((h) => {
+    expect(eq(ctx, handle, h)).toBe(true);
   });
 
   const [wrapped2] = wrapHandle(
-    vm,
+    ctx,
     wrapped,
     proxyKeySymbol,
     proxyKeySymbolHandle,
@@ -211,25 +240,32 @@ test("wrapHandle, unwrapHandle, isHandleWrapped", async () => {
   );
   expect(wrapped2 === wrapped).toBe(true);
 
+  // promise cannot be wrapped
+  const deferred = ctx.newPromise();
+  expect(isHandleWrapped(ctx, deferred.handle, proxyKeySymbolHandle)).toBe(
+    true
+  );
+
+  deferred.dispose();
   wrapped.dispose();
   handle.dispose();
   proxyKeySymbolHandle.dispose();
-  vm.dispose();
+  ctx.dispose();
 });
 
 test("wrapHandle without sync", async () => {
-  const vm = (await getQuickJS()).createVm();
+  const ctx = (await getQuickJS()).newContext();
   const target = { a: 1 };
-  const handle = vm.unwrapResult(vm.evalCode(`({ a: 1 })`));
+  const handle = ctx.unwrapResult(ctx.evalCode(`({ a: 1 })`));
   const proxyKeySymbol = Symbol();
-  const proxyKeySymbolHandle = vm.unwrapResult(vm.evalCode(`Symbol()`));
-  const unmarshal = jest.fn((h: QuickJSHandle) =>
-    wrapped && eq(vm, h, wrapped) ? target : vm.dump(h)
+  const proxyKeySymbolHandle = ctx.unwrapResult(ctx.evalCode(`Symbol()`));
+  const unmarshal = vi.fn((h: QuickJSHandle) =>
+    wrapped && eq(ctx, h, wrapped) ? target : ctx.dump(h)
   );
-  const syncMode = jest.fn();
+  const syncMode = vi.fn();
 
   const [wrapped, w] = wrapHandle(
-    vm,
+    ctx,
     handle,
     proxyKeySymbol,
     proxyKeySymbolHandle,
@@ -241,9 +277,9 @@ test("wrapHandle without sync", async () => {
   expect(unmarshal).toBeCalledTimes(0);
   expect(syncMode).toBeCalledTimes(0);
 
-  call(vm, `a => a.a = 2`, undefined, wrapped);
+  call(ctx, `a => a.a = 2`, undefined, wrapped);
 
-  expect(vm.dump(vm.getProp(handle, "a"))).toBe(2);
+  expect(ctx.dump(ctx.getProp(handle, "a"))).toBe(2);
   expect(target.a).toBe(1); // not synced
   expect(unmarshal).toBeCalledTimes(1);
   expect(unmarshal).toReturnWith(target);
@@ -253,22 +289,22 @@ test("wrapHandle without sync", async () => {
   wrapped.dispose();
   handle.dispose();
   proxyKeySymbolHandle.dispose();
-  vm.dispose();
+  ctx.dispose();
 });
 
 test("wrapHandle with both sync", async () => {
-  const vm = (await getQuickJS()).createVm();
+  const ctx = (await getQuickJS()).newContext();
   const target = { a: 1 };
-  const handle = vm.unwrapResult(vm.evalCode(`({ a: 1 })`));
+  const handle = ctx.unwrapResult(ctx.evalCode(`({ a: 1 })`));
   const proxyKeySymbol = Symbol();
-  const proxyKeySymbolHandle = vm.unwrapResult(vm.evalCode(`Symbol()`));
-  const unmarshal = jest.fn((h: QuickJSHandle) => {
-    return wrapped && eq(vm, h, wrapped) ? target : vm.dump(h);
+  const proxyKeySymbolHandle = ctx.unwrapResult(ctx.evalCode(`Symbol()`));
+  const unmarshal = vi.fn((h: QuickJSHandle) => {
+    return wrapped && eq(ctx, h, wrapped) ? target : ctx.dump(h);
   });
-  const syncMode = jest.fn((): SyncMode => "both");
+  const syncMode = vi.fn((): SyncMode => "both");
 
   const [wrapped, w] = wrapHandle(
-    vm,
+    ctx,
     handle,
     proxyKeySymbol,
     proxyKeySymbolHandle,
@@ -280,9 +316,9 @@ test("wrapHandle with both sync", async () => {
   expect(unmarshal).toBeCalledTimes(0);
   expect(syncMode).toBeCalledTimes(0);
 
-  call(vm, `a => a.a = 2`, undefined, wrapped);
+  call(ctx, `a => a.a = 2`, undefined, wrapped);
 
-  expect(vm.dump(vm.getProp(handle, "a"))).toBe(2);
+  expect(ctx.dump(ctx.getProp(handle, "a"))).toBe(2);
   expect(target.a).toBe(2); // synced
   expect(unmarshal).toBeCalledTimes(4);
   expect(unmarshal).toReturnWith(target); // twice
@@ -291,13 +327,13 @@ test("wrapHandle with both sync", async () => {
   expect(syncMode).toBeCalledTimes(1);
   expect(syncMode).toBeCalledWith(target);
 
-  call(vm, `a => { delete a.a; }`, undefined, wrapped);
-  expect(vm.dump(vm.getProp(handle, "a"))).toBe(undefined);
+  call(ctx, `a => { delete a.a; }`, undefined, wrapped);
+  expect(ctx.dump(ctx.getProp(handle, "a"))).toBe(undefined);
   expect(target.a).toBe(undefined); // synced
 
   // changing __proto__ will be blocked
-  call(vm, `a => { a.__proto__ = null; }`, undefined, wrapped);
-  expect(vm.dump(call(vm, `Object.getPrototypeOf`, undefined, handle))).toBe(
+  call(ctx, `a => { a.__proto__ = null; }`, undefined, wrapped);
+  expect(ctx.dump(call(ctx, `Object.getPrototypeOf`, undefined, handle))).toBe(
     null
   );
   expect(Object.getPrototypeOf(target)).toBe(Object.prototype); // not changed
@@ -305,22 +341,22 @@ test("wrapHandle with both sync", async () => {
   wrapped.dispose();
   handle.dispose();
   proxyKeySymbolHandle.dispose();
-  vm.dispose();
+  ctx.dispose();
 });
 
 test("wrapHandle with host sync", async () => {
-  const vm = (await getQuickJS()).createVm();
+  const ctx = (await getQuickJS()).newContext();
   const target = { a: 1 };
-  const handle = vm.unwrapResult(vm.evalCode(`({ a: 1 })`));
+  const handle = ctx.unwrapResult(ctx.evalCode(`({ a: 1 })`));
   const proxyKeySymbol = Symbol();
-  const proxyKeySymbolHandle = vm.unwrapResult(vm.evalCode(`Symbol()`));
-  const unmarshal = jest.fn((handle: QuickJSHandle) =>
-    wrapped && eq(vm, handle, wrapped) ? target : vm.dump(handle)
+  const proxyKeySymbolHandle = ctx.unwrapResult(ctx.evalCode(`Symbol()`));
+  const unmarshal = vi.fn((handle: QuickJSHandle) =>
+    wrapped && eq(ctx, handle, wrapped) ? target : ctx.dump(handle)
   );
-  const syncMode = jest.fn((): SyncMode => "host");
+  const syncMode = vi.fn((): SyncMode => "host");
 
   const [wrapped, w] = wrapHandle(
-    vm,
+    ctx,
     handle,
     proxyKeySymbol,
     proxyKeySymbolHandle,
@@ -332,9 +368,9 @@ test("wrapHandle with host sync", async () => {
   expect(unmarshal).toBeCalledTimes(0);
   expect(syncMode).toBeCalledTimes(0);
 
-  call(vm, `a => a.a = 2`, undefined, wrapped);
+  call(ctx, `a => a.a = 2`, undefined, wrapped);
 
-  expect(vm.dump(vm.getProp(handle, "a"))).toBe(1); // not set
+  expect(ctx.dump(ctx.getProp(handle, "a"))).toBe(1); // not set
   expect(target.a).toBe(2); // synced
   expect(unmarshal).toBeCalledTimes(4);
   expect(unmarshal).toReturnWith(target); // twice
@@ -343,33 +379,33 @@ test("wrapHandle with host sync", async () => {
   expect(syncMode).toBeCalledTimes(1);
   expect(syncMode).toBeCalledWith(target);
 
-  call(vm, `a => delete a.a`, undefined, handle);
-  expect(vm.dump(vm.getProp(handle, "a"))).toBe(undefined);
+  call(ctx, `a => delete a.a`, undefined, handle);
+  expect(ctx.dump(ctx.getProp(handle, "a"))).toBe(undefined);
   expect(target.a).toBe(2); // not synced
 
   wrapped.dispose();
   handle.dispose();
   proxyKeySymbolHandle.dispose();
-  vm.dispose();
+  ctx.dispose();
 });
 
 test("wrap and wrapHandle", async () => {
-  const vm = (await getQuickJS()).createVm();
+  const ctx = (await getQuickJS()).newContext();
   const target = { a: 1 };
-  const handle = vm.unwrapResult(vm.evalCode(`({ a: 1 })`));
+  const handle = ctx.unwrapResult(ctx.evalCode(`({ a: 1 })`));
   const proxyKeySymbol = Symbol();
-  const proxyKeySymbolHandle = vm.unwrapResult(vm.evalCode(`Symbol()`));
-  const marshal = jest.fn(
-    (t: any): QuickJSHandle =>
-      wrappedHandle && t === wrapped ? wrappedHandle : send(vm, t)
-  );
-  const unmarshal = jest.fn((handle: QuickJSHandle) =>
-    wrappedHandle && eq(vm, handle, wrappedHandle) ? wrapped : vm.dump(handle)
+  const proxyKeySymbolHandle = ctx.unwrapResult(ctx.evalCode(`Symbol()`));
+  const marshal = vi.fn((t: any): [QuickJSHandle, boolean] => [
+    wrappedHandle && t === wrapped ? wrappedHandle : json(ctx, t),
+    false,
+  ]);
+  const unmarshal = vi.fn((handle: QuickJSHandle) =>
+    wrappedHandle && eq(ctx, handle, wrappedHandle) ? wrapped : ctx.dump(handle)
   );
-  const syncMode = jest.fn((): SyncMode => "both");
+  const syncMode = vi.fn((): SyncMode => "both");
 
   const wrapped = wrap(
-    vm,
+    ctx,
     target,
     proxyKeySymbol,
     proxyKeySymbolHandle,
@@ -378,7 +414,7 @@ test("wrap and wrapHandle", async () => {
   );
   if (!wrapped) throw new Error("wrapped is undefined");
   const [wrappedHandle, w] = wrapHandle(
-    vm,
+    ctx,
     handle,
     proxyKeySymbol,
     proxyKeySymbolHandle,
@@ -387,9 +423,9 @@ test("wrap and wrapHandle", async () => {
   );
   if (!wrappedHandle || !w) throw new Error("wrappedHandle is undefined");
 
-  call(vm, `a => a.a = 2`, undefined, wrappedHandle);
+  call(ctx, `a => a.a = 2`, undefined, wrappedHandle);
 
-  expect(vm.dump(vm.getProp(handle, "a"))).toBe(2);
+  expect(ctx.dump(ctx.getProp(handle, "a"))).toBe(2);
   expect(target.a).toBe(2);
   expect(marshal).toBeCalledTimes(0);
   expect(unmarshal).toBeCalledTimes(4);
@@ -402,7 +438,7 @@ test("wrap and wrapHandle", async () => {
 
   wrapped.a = 3;
 
-  expect(vm.dump(vm.getProp(handle, "a"))).toBe(3);
+  expect(ctx.dump(ctx.getProp(handle, "a"))).toBe(3);
   expect(target.a).toBe(3);
   expect(marshal).toBeCalledTimes(3);
   expect(marshal).toBeCalledWith(wrapped);
@@ -413,31 +449,31 @@ test("wrap and wrapHandle", async () => {
   wrappedHandle.dispose();
   handle.dispose();
   proxyKeySymbolHandle.dispose();
-  vm.dispose();
+  ctx.dispose();
 });
 
 test("non object", async () => {
-  const vm = (await getQuickJS()).createVm();
+  const ctx = (await getQuickJS()).newContext();
   const target = 1;
-  const handle = vm.newNumber(1);
+  const handle = ctx.newNumber(1);
   const proxyKeySymbol = Symbol();
-  const proxyKeySymbolHandle = vm.unwrapResult(vm.evalCode(`Symbol()`));
+  const proxyKeySymbolHandle = ctx.unwrapResult(ctx.evalCode(`Symbol()`));
 
   expect(
-    wrap(vm, target, proxyKeySymbol, proxyKeySymbolHandle, jest.fn(), jest.fn())
+    wrap(ctx, target, proxyKeySymbol, proxyKeySymbolHandle, vi.fn(), vi.fn())
   ).toBe(undefined);
 
   expect(
     wrapHandle(
-      vm,
+      ctx,
       handle,
       proxyKeySymbol,
       proxyKeySymbolHandle,
-      jest.fn(),
-      jest.fn()
+      vi.fn(),
+      vi.fn()
     )
   ).toEqual([undefined, false]);
 
   proxyKeySymbolHandle.dispose();
-  vm.dispose();
+  ctx.dispose();
 });