@agoric/swingset-liveslots 0.10.3-other-dev-8f8782b.0 → 0.10.3-other-dev-3eb1a1d.0

package/test/vat-environment.test.js

@@ -0,0 +1,65 @@
+// @ts-nocheck
+import '@endo/init/debug.js';
+import test from 'ava';
+import { Far } from '@endo/marshal';
+import { kser } from '@agoric/kmarshal';
+import { passStyleOf } from '@endo/pass-style';
+import { PassStyleOfEndowmentSymbol } from '@endo/pass-style/endow.js';
+import { makeLiveSlots } from '../src/index.js';
+import { makeStartVat } from './util.js';
+import { buildSyscall } from './liveslots-helpers.js';
+import { makeMockGC } from './mock-gc.js';
+
+test('vat globals', async t => {
+  const { syscall } = buildSyscall();
+  const gcTools = makeMockGC();
+  const buildRootObject = () => Far('root', {});
+  let called = 0;
+  let vatGlobals;
+  let inescapableGlobalProperties;
+  const vatNS = harden({ buildRootObject });
+  // buildVatNamespace
+  const bVN = async (vG, iGP) => {
+    called += 1;
+    vatGlobals = vG;
+    inescapableGlobalProperties = iGP;
+    return vatNS;
+  };
+
+  const ls = makeLiveSlots(syscall, 'vatA', {}, {}, gcTools, undefined, bVN);
+  t.is(called, 0); // not called yet
+  await ls.dispatch(makeStartVat(kser()));
+  t.is(called, 1);
+  t.truthy(vatGlobals);
+
+  // 'harden' is provided by SES (installed by the lockdown bundle),
+  // not liveslots
+  t.is(typeof vatGlobals.harden, 'undefined');
+
+  // but liveslots provides VatData
+  t.is(typeof vatGlobals.VatData, 'object');
+  t.is(typeof vatGlobals.VatData, 'object');
+  t.is(typeof vatGlobals.VatData.defineKind, 'function');
+  t.is(typeof vatGlobals.VatData.defineKindMulti, 'function');
+  t.is(typeof vatGlobals.VatData.defineDurableKind, 'function');
+  t.is(typeof vatGlobals.VatData.defineDurableKindMulti, 'function');
+  t.is(typeof vatGlobals.VatData.makeKindHandle, 'function');
+  t.is(typeof vatGlobals.VatData.canBeDurable, 'function');
+  t.is(typeof vatGlobals.VatData.providePromiseWatcher, 'function');
+  t.is(typeof vatGlobals.VatData.watchPromise, 'function');
+  t.is(typeof vatGlobals.VatData.makeScalarBigMapStore, 'function');
+  t.is(typeof vatGlobals.VatData.makeScalarBigWeakMapStore, 'function');
+  t.is(typeof vatGlobals.VatData.makeScalarBigSetStore, 'function');
+  t.is(typeof vatGlobals.VatData.makeScalarBigWeakSetStore, 'function');
+
+  t.is(typeof inescapableGlobalProperties.WeakMap, 'function');
+  t.not(inescapableGlobalProperties.WeakMap, WeakMap);
+  t.is(typeof inescapableGlobalProperties.WeakSet, 'function');
+  t.not(inescapableGlobalProperties.WeakSet, WeakSet);
+  t.is(
+    typeof inescapableGlobalProperties[PassStyleOfEndowmentSymbol],
+    'function',
+  );
+  // this is the passStyleOf created by liveslots, with a real WeakMap
+  t.is(inescapableGlobalProperties[PassStyleOfEndowmentSymbol], passStyleOf);
+});

package/test/vat-util.js

@@ -1,8 +1,8 @@
 // this file is imported by some test vats, so don't import any non-pure
 // modules
 
-import { Fail } from '@agoric/assert';
-import { kser, kunser } from './kmarshal.js';
+import { Fail } from '@endo/errors';
+import { kser, kunser } from '@agoric/kmarshal';
 
 export function extractMessage(vatDeliverObject) {
   const [type, ...vdoargs] = vatDeliverObject;

package/test/virtual-objects/{test-cease-recognition.js → cease-recognition.test.js}

@@ -1,6 +1,6 @@
+// @ts-nocheck
 /* global FinalizationRegistry WeakRef */
 import test from 'ava';
-import '@endo/init/debug.js';
 
 import { buildSyscall } from '../liveslots-helpers.js';
 import { makeVirtualReferenceManager } from '../../src/virtualReferences.js';
@@ -38,7 +38,7 @@ function weakKeyCheck(t, log, vref) {
   t.true(result === undefined || !result.startsWith(prefix), `ew:${result}`);
 }
 
-test('only enumerate virtual objects', async t => {
+test('only enumerate virtual objects', t => {
   const { log, vrm } = makeVRM();
 
   // retiring a plain Remotable does a is-it-a-weak-key chck

package/test/virtual-objects/{test-cross-facet.js → cross-facet.test.js}

@@ -1,5 +1,4 @@
 import test from 'ava';
-import '@endo/init/debug.js';
 
 import { makeFakeVirtualObjectManager } from '../../tools/fakeVirtualSupport.js';
 
@@ -15,7 +14,7 @@ function attack2(mut1, immut2) {
   Reflect.apply(mutableProto.set, immut2, [6]);
 }
 
-test('forbid cross-facet prototype attack', async t => {
+test('forbid cross-facet prototype attack', t => {
   const vom = makeFakeVirtualObjectManager();
   const init = () => ({ value: 0 });
   const behavior = {
@@ -34,10 +33,12 @@ test('forbid cross-facet prototype attack', async t => {
   thing2.mutable.set(2);
 
   t.throws(() => attack1(thing1.mutable, thing2.immutable), {
-    message: /^illegal cross-facet access/,
+    message:
+      '"In \\"set\\" method of (thing mutable)" may only be applied to a valid instance: "[Alleged: thing immutable]"',
   });
   t.throws(() => attack2(thing1.mutable, thing2.immutable), {
-    message: /^illegal cross-facet access/,
+    message:
+      '"In \\"set\\" method of (thing mutable)" may only be applied to a valid instance: "[Alleged: thing immutable]"',
   });
   t.is(thing1.immutable.get(), 1);
   t.is(thing2.immutable.get(), 2);

package/test/virtual-objects/{test-empty-data.js → empty-data.test.js}

@@ -1,9 +1,8 @@
 import test from 'ava';
-import '@endo/init/debug.js';
 
 import { makeFakeVirtualObjectManager } from '../../tools/fakeVirtualSupport.js';
 
-test('non-object initial data message', async t => {
+test('non-object initial data message', t => {
   const vom = makeFakeVirtualObjectManager();
   const goodInit = () => ({ value: 0 });
   // 'badInit' is  () =>  { value: 0 }

package/test/virtual-objects/{test-facets.js → facets.test.js}

@@ -1,9 +1,8 @@
 import test from 'ava';
-import '@endo/init/debug.js';
 
 import { makeFakeVirtualObjectManager } from '../../tools/fakeVirtualSupport.js';
 
-test('facets', async t => {
+test('facets', t => {
   const vom = makeFakeVirtualObjectManager();
   const init = () => ({ value: 0 });
   const behavior = {

package/test/virtual-objects/{test-kind-changes.js → kind-changes.test.js}

@@ -1,10 +1,10 @@
+// @ts-nocheck
 import test from 'ava';
-import '@endo/init/debug.js';
 import { Far } from '@endo/marshal';
+import { kser } from '@agoric/kmarshal';
 import { makeFakeVirtualStuff } from '../../tools/fakeVirtualSupport.js';
 import { makeLiveSlots } from '../../src/liveslots.js';
 import { parseVatSlot } from '../../src/parseVatSlots.js';
-import { kser } from '../kmarshal.js';
 import { buildSyscall } from '../liveslots-helpers.js';
 import { makeStartVat, makeMessage } from '../util.js';
 import { makeMockGC } from '../mock-gc.js';

package/test/virtual-objects/{test-reachable-vrefs.js → reachable-vrefs.test.js}

@@ -1,5 +1,5 @@
+// @ts-nocheck
 import test from 'ava';
-import '@endo/init/debug.js';
 
 import { Remotable } from '@endo/marshal';
 import { initEmpty } from '@agoric/store';
@@ -7,7 +7,7 @@ import { initEmpty } from '@agoric/store';
 import { makeVatSlot } from '../../src/parseVatSlots.js';
 import { makeFakeVirtualStuff } from '../../tools/fakeVirtualSupport.js';
 
-test('VOM tracks reachable vrefs', async t => {
+test('VOM tracks reachable vrefs', t => {
   const { vom, vrm, cm } = makeFakeVirtualStuff();
   const { defineKind } = vom;
   const { makeScalarBigWeakMapStore } = cm;

package/test/virtual-objects/{test-rep-tostring.js → rep-tostring.test.js}

@@ -1,22 +1,20 @@
 import test from 'ava';
-import '@endo/init/debug.js';
 // this sets process.env.DEBUG = 'label-instances'
 import './set-debug-label-instances.js';
 
 import { passStyleOf } from '@endo/far';
 
 // this samples it
+import { q } from '@endo/errors';
 import { makeFakeVirtualStuff } from '../../tools/fakeVirtualSupport.js';
 // all tests in this file will be run with DEBUG='label-instances'
 import { parseVatSlot } from '../../src/parseVatSlots.js';
 
-const { quote: q } = assert;
-
 const init = () => ({});
 const behavior = {};
 const facets = { foo: {}, bar: {} };
 
-test('representatives with label-instances', async t => {
+test('representatives with label-instances', t => {
   const { fakeStuff, vom } = makeFakeVirtualStuff();
   const { getSlotForVal } = fakeStuff;
   const makeThing = vom.defineKind('thing', init, behavior);
@@ -33,7 +31,7 @@ test('representatives with label-instances', async t => {
   t.is(`${q(thing2)}`, `"[Alleged: thing#${thing2vref}]"`);
 });
 
-test('facets with label-instances', async t => {
+test('facets with label-instances', t => {
   const { fakeStuff, vom } = makeFakeVirtualStuff();
   const { getSlotForVal } = fakeStuff;
   const makeThings = vom.defineKindMulti('thing', init, facets);

package/test/virtual-objects/{test-retain-remotable.js → retain-remotable.test.js}

@@ -1,56 +1,57 @@
-/* global WeakRef */
+// @ts-nocheck
 import test from 'ava';
-import '@endo/init/debug.js';
 
 import { Far } from '@endo/marshal';
 import { initEmpty } from '@agoric/store';
 
 import engineGC from '../engine-gc.js';
-import { makeGcAndFinalize } from '../gc-and-finalize.js';
+import { makeGcAndFinalize, watchCollected } from '../gc-and-finalize.js';
 import { makeFakeVirtualStuff } from '../../tools/fakeVirtualSupport.js';
 
-function makeHeld() {
-  const held = Far('held');
-  const wr = new WeakRef(held);
+function makeStashKit(name = 'held') {
+  const held = Far(name);
+  const collected = watchCollected(held);
   const ws = new WeakSet(); // note: real WeakSet, not vref-aware
   ws.add(held);
   function isHeld(obj) {
     return ws.has(obj);
   }
-  return { held, wr, isHeld };
+  function isCollected() {
+    return collected.result;
+  }
+  return { held, isCollected, isHeld };
 }
 
 function prepareEphemeral(vom) {
-  const ephemeral = Far('ephemeral');
-  vom.registerEntry('o+12345', ephemeral);
-  const wr = new WeakRef(ephemeral);
-  return { wr };
+  const { held, isCollected } = makeStashKit('ephemeral');
+  vom.registerEntry('o+12345', held);
+  return { isCollected };
 }
 
 function stashRemotableOne(weakStore, key1) {
-  const { held, wr, isHeld } = makeHeld();
+  const { held, isCollected, isHeld } = makeStashKit();
   weakStore.init(key1, held);
-  return { wr, isHeld };
+  return { isCollected, isHeld };
 }
 
 function stashRemotableTwo(weakStore, key1) {
-  const { held, wr, isHeld } = makeHeld();
+  const { held, isCollected, isHeld } = makeStashKit();
   weakStore.init(key1, 'initial');
   weakStore.set(key1, held);
-  return { wr, isHeld };
+  return { isCollected, isHeld };
 }
 
 function stashRemotableThree(holderMaker) {
-  const { held, wr, isHeld } = makeHeld();
+  const { held, isCollected, isHeld } = makeStashKit();
   const holder = holderMaker(held);
-  return { wr, isHeld, holder };
+  return { isCollected, isHeld, holder };
 }
 
 function stashRemotableFour(holderMaker) {
-  const { held, wr, isHeld } = makeHeld();
+  const { held, isCollected, isHeld } = makeStashKit();
   const holder = holderMaker('initial');
   holder.setHeld(held);
-  return { wr, isHeld, holder };
+  return { isCollected, isHeld, holder };
 }
 
 test('remotables retained by virtualized data', async t => {
@@ -74,7 +75,7 @@ test('remotables retained by virtualized data', async t => {
   // false positive in the subsequent test
   const stash0 = prepareEphemeral(vom);
   await gcAndFinalize();
-  t.falsy(stash0.wr.deref(), `caution: fake VOM didn't release Remotable`);
+  t.true(stash0.isCollected(), `caution: fake VOM didn't release Remotable`);
 
   // stash a Remotable in the value of a weakStore
   const key1 = makeKey();
@@ -84,14 +85,14 @@ test('remotables retained by virtualized data', async t => {
   // Representatives or Presences, so the value is not holding a strong
   // reference to the Remotable. The VOM is supposed to keep it alive, via
   // reachableRemotables.
-  t.truthy(stash1.wr.deref());
+  t.false(stash1.isCollected());
   t.truthy(stash1.isHeld(weakStore.get(key1)));
 
   // do the same, but exercise weakStore.set instead of .init
   const key2 = makeKey();
   const stash2 = stashRemotableTwo(weakStore, key2);
   await gcAndFinalize();
-  t.truthy(stash2.wr.deref());
+  t.false(stash2.isCollected());
   t.truthy(stash2.isHeld(weakStore.get(key2)));
 
   // now stash a Remotable in the state of a virtual object during init()
@@ -100,12 +101,12 @@ test('remotables retained by virtualized data', async t => {
   // Each state property is virtualized upon write (via the generated
   // setters). So again we rely on the VOM to keep the Remotable alive in
   // case someone retrieves it again.
-  t.truthy(stash3.wr.deref());
+  t.false(stash3.isCollected());
   t.truthy(stash3.isHeld(stash3.holder.getHeld()));
 
   // same, but stash after init()
   const stash4 = stashRemotableFour(makeHolder);
   await gcAndFinalize();
-  t.truthy(stash4.wr.deref());
+  t.false(stash4.isCollected());
   t.truthy(stash4.isHeld(stash4.holder.getHeld()));
 });

package/test/virtual-objects/set-debug-label-instances.js

@@ -1,4 +1,4 @@
-/* global process */
+/* eslint-env node */
 
 // put this in a separate module, so we can make it happen before
 // importing virtualObjectManager.js

package/test/virtual-objects/{test-state-shape.js → state-shape.test.js}

@@ -1,10 +1,10 @@
+// @ts-nocheck
 import test from 'ava';
-import '@endo/init/debug.js';
 
 import { Far } from '@endo/marshal';
+import { kser, kslot } from '@agoric/kmarshal';
 import { M } from '@agoric/store';
 import { makeLiveSlots } from '../../src/liveslots.js';
-import { kser, kslot } from '../kmarshal.js';
 import { buildSyscall } from '../liveslots-helpers.js';
 import { makeStartVat, makeMessage } from '../util.js';
 import { makeMockGC } from '../mock-gc.js';

package/test/virtual-objects/{test-virtualObjectGC.js → virtualObjectGC.test.js}

@@ -1,12 +1,12 @@
+// @ts-nocheck
 import test from 'ava';
-import '@endo/init/debug.js';
 
 import { Far } from '@endo/marshal';
+import { krefOf, kser, kslot } from '@agoric/kmarshal';
 import {
   setupTestLiveslots,
   findSyscallsByType,
 } from '../liveslots-helpers.js';
-import { krefOf, kser, kslot } from '../kmarshal.js';
 import { parseVatSlot } from '../../src/parseVatSlots.js';
 
 // Legs: