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

package/test/{test-liveslots-mock-gc.js → liveslots-mock-gc.test.js}

@@ -1,16 +1,17 @@
+// @ts-nocheck
 import test from 'ava';
-import '@endo/init/debug.js';
 
 import { Far } from '@endo/marshal';
+import { kslot, kser } from '@agoric/kmarshal';
 import { makeLiveSlots } from '../src/liveslots.js';
 import { parseVatSlot } from '../src/parseVatSlots.js';
-import { kslot, kser } from './kmarshal.js';
 import { buildSyscall } from './liveslots-helpers.js';
 import {
   makeMessage,
   makeStartVat,
   makeBringOutYourDead,
   makeResolve,
+  makeRetireImports,
 } from './util.js';
 import { makeMockGC } from './mock-gc.js';
 
@@ -465,3 +466,101 @@ for (const firstType of ['object', 'collection']) {
 }
 
 // test('double-free', doublefreetest, { firstType: 'object', lastType: 'collection', order: 'first->last' });
+
+test('retirement', async t => {
+  const { syscall, fakestore, log } = buildSyscall();
+  const gcTools = makeMockGC();
+
+  // A is a weak collection, with one entry, whose key is B (a
+  // Presence). We drop the RAM pillar for B and do a BOYD, which
+  // should provoke a syscall.dropImports. Then, when we delete A (by
+  // dropping the RAM pillar), the next BOYD should see a
+  // `syscall.retireImports`.
+
+  let weakmapA;
+  let presenceB;
+
+  function buildRootObject(vatPowers) {
+    const { VatData } = vatPowers;
+    const { makeScalarBigWeakMapStore } = VatData;
+
+    weakmapA = makeScalarBigWeakMapStore();
+
+    return Far('root', {
+      add: p => {
+        presenceB = p;
+        weakmapA.init(presenceB, 'value');
+      },
+    });
+  }
+
+  const makeNS = () => ({ buildRootObject });
+  const ls = makeLiveSlots(syscall, 'vatA', {}, {}, gcTools, undefined, makeNS);
+  const { dispatch, testHooks } = ls;
+  const { valToSlot } = testHooks;
+
+  await dispatch(makeStartVat(kser()));
+  log.length = 0;
+  const weakmapAvref = valToSlot.get(weakmapA);
+  const { subid } = parseVatSlot(weakmapAvref);
+  const collectionID = String(subid);
+
+  const rootA = 'o+0';
+  const presenceBvref = 'o-1';
+  await dispatch(makeMessage(rootA, 'add', [kslot(presenceBvref)]));
+  log.length = 0;
+
+  // the fact that weakmapA can recognize presenceA is recorded in a
+  // vatstore key
+  const recognizerKey = `vom.ir.${presenceBvref}|${collectionID}`;
+  t.is(fakestore.get(recognizerKey), '1');
+
+  // tell mockGC that userspace has dropped presenceB
+  gcTools.kill(presenceB);
+  gcTools.flushAllFRs();
+
+  await dispatch(makeBringOutYourDead());
+  const priorKey = `vom.ir.${presenceBvref}|`;
+
+  t.deepEqual(log.splice(0), [
+    // when a Presence is dropped, scanForDeadObjects can't drop the
+    // underlying vref import until it knows that virtual data isn't
+    // holding a reference, so we expect a refcount check
+    { type: 'vatstoreGet', key: `vom.rc.${presenceBvref}`, result: undefined },
+
+    // the vref is now in importsToDrop, but since this commonly means
+    // it can be retired too, scanForDeadObjects goes ahead and checks
+    // for recognizers
+    { type: 'vatstoreGetNextKey', priorKey, result: recognizerKey },
+
+    // it found a recognizer, so the vref cannot be retired
+    // yet. scanForDeadObjects finishes the BOYD by emitting the
+    // dropImports, but should keep watching for an opportunity to
+    // retire it too
+    { type: 'dropImports', slots: [presenceBvref] },
+  ]);
+
+  // now tell mockGC that we're dropping the weakmap too
+  gcTools.kill(weakmapA);
+  gcTools.flushAllFRs();
+
+  // this will provoke the deletion of the collection and all its
+  // data. It should *also* trigger a syscall.retireImports of the
+  // no-longer-recognizable key
+  await dispatch(makeBringOutYourDead());
+  const retires = log.filter(e => e.type === 'retireImports');
+
+  t.deepEqual(retires, [{ type: 'retireImports', slots: [presenceBvref] }]);
+
+  // If the bug is present, the vat won't send `syscall.retireImports`
+  // to the kernel. In a full system, that means the kernel can
+  // eventually send a `dispatch.retireImports` into the vat, if/when
+  // the object's hosting vat decides to drop it. Make sure that won't
+  // cause a crash.
+
+  if (!retires.length) {
+    console.log(`testing kernel's dispatch.retireImports`);
+    await dispatch(makeRetireImports(presenceBvref));
+    console.log(`dispatch.retireImports did not crash`);
+  }
+});

package/test/{test-liveslots-real-gc.js → liveslots-real-gc.test.js}

@@ -1,12 +1,12 @@
-/* global WeakRef */
+// @ts-nocheck
+/* global process */
 import test from 'ava';
-import '@endo/init/debug.js';
 
 import { Far } from '@endo/marshal';
 import { makePromiseKit } from '@endo/promise-kit';
+import { kslot, kser } from '@agoric/kmarshal';
 import engineGC from './engine-gc.js';
-import { makeGcAndFinalize } from './gc-and-finalize.js';
-import { kslot, kser } from './kmarshal.js';
+import { watchCollected, makeGcAndFinalize } from './gc-and-finalize.js';
 import { buildSyscall, makeDispatch } from './liveslots-helpers.js';
 import {
   makeMessage,
@@ -28,13 +28,13 @@ const gcAndFinalize = makeGcAndFinalize(engineGC);
 
 test.serial('liveslots retains pending exported promise', async t => {
   const { log, syscall } = buildSyscall();
-  let watch;
+  let collected;
   const success = [];
   function build(_vatPowers) {
     const root = Far('root', {
       make() {
         const pk = makePromiseKit();
-        watch = new WeakRef(pk.promise);
+        collected = watchCollected(pk.promise);
         // we export the Promise, but do not retain resolve/reject
         return [pk.promise];
       },
@@ -55,7 +55,7 @@ test.serial('liveslots retains pending exported promise', async t => {
   const resultP = 'p-1';
   await dispatch(makeMessage(rootA, 'make', [], resultP));
   await gcAndFinalize();
-  t.truthy(watch.deref(), 'Promise not retained');
+  t.false(collected.result, 'Promise retained');
   t.is(log[0].type, 'resolve');
   const res0 = log[0].resolutions[0];
   t.is(res0[0], resultP);
@@ -66,13 +66,13 @@ test.serial('liveslots retains pending exported promise', async t => {
 
 test.serial('liveslots retains device nodes', async t => {
   const { syscall } = buildSyscall();
-  let watch;
+  let collected;
   const recognize = new WeakSet(); // real WeakSet
   const success = [];
   function build(_vatPowers) {
     const root = Far('root', {
       first(dn) {
-        watch = new WeakRef(dn);
+        collected = watchCollected(dn);
         recognize.add(dn);
       },
       second(dn) {
@@ -87,25 +87,24 @@ test.serial('liveslots retains device nodes', async t => {
   const device = 'd-1';
   await dispatch(makeMessage(rootA, 'first', [kslot(device)]));
   await gcAndFinalize();
-  t.truthy(watch.deref(), 'Device node not retained');
+  t.false(collected.result, 'Device node retained');
   await dispatch(makeMessage(rootA, 'second', [kslot(device)]));
   t.deepEqual(success, [true]);
 });
 
 test.serial('GC syscall.dropImports', async t => {
   const { log, syscall } = buildSyscall();
-  let wr;
+  let collected;
   function build(_vatPowers) {
-    // eslint-disable-next-line no-unused-vars
-    let presence1;
+    const holder = new Set();
     const root = Far('root', {
       one(arg) {
-        presence1 = arg;
-        wr = new WeakRef(arg);
+        holder.add(arg);
+        collected = watchCollected(arg);
       },
       two() {},
       three() {
-        presence1 = undefined; // drops the import
+        holder.clear(); // drops the import
       },
     });
     return root;
@@ -121,19 +120,29 @@ test.serial('GC syscall.dropImports', async t => {
   // rp1 = root~.one(arg)
   await dispatch(makeMessage(rootA, 'one', [kslot(arg)]));
   await dispatch(makeBringOutYourDead());
-  t.truthy(wr.deref());
+  t.false(collected.result);
 
   // an intermediate message will trigger GC, but the presence is still held
   await dispatch(makeMessage(rootA, 'two', []));
   await dispatch(makeBringOutYourDead());
-  t.truthy(wr.deref());
+  t.false(collected.result);
 
   // now tell the vat to drop the 'arg' presence we gave them earlier
   await dispatch(makeMessage(rootA, 'three', []));
   await dispatch(makeBringOutYourDead());
 
+  const isV8 =
+    typeof process !== 'undefined' && 'v8' in (process.versions || {});
+
   // the presence itself should be gone
-  t.falsy(wr.deref());
+  if (!collected.result) {
+    if (isV8) {
+      // Flake in v8/node: https://github.com/Agoric/agoric-sdk/issues/8883
+      t.log('skipping flake in v8');
+      return;
+    }
+    t.fail('import not collected');
+  }
 
   // first it will check that there are no VO's holding onto it
   const l2 = log.shift();
@@ -246,12 +255,12 @@ test.serial('GC dispatch.retireExports', async t => {
 
 test.serial('GC dispatch.dropExports', async t => {
   const { log, syscall } = buildSyscall();
-  let wr;
+  let collected;
   function build(_vatPowers) {
     const root = Far('root', {
       one() {
         const ex1 = Far('export', {});
-        wr = new WeakRef(ex1);
+        collected = watchCollected(ex1);
         return ex1;
         // ex1 goes out of scope, dropping last userspace strongref
       },
@@ -285,19 +294,27 @@ test.serial('GC dispatch.dropExports', async t => {
 
   // the exported Remotable should be held in place by exportedRemotables
   // until we tell the vat we don't need it any more
-  t.truthy(wr.deref());
+  t.false(collected.result);
 
   // an intermediate message will trigger GC, but the presence is still held
   await dispatch(makeMessage(rootA, 'two', []));
   await dispatch(makeBringOutYourDead());
-  t.truthy(wr.deref());
+  t.false(collected.result);
 
   // now tell the vat we don't need a strong reference to that export.
   await dispatch(makeDropExports(ex1));
   await dispatch(makeBringOutYourDead());
 
   // that should allow ex1 to be collected
-  t.falsy(wr.deref());
+  t.true(collected.result);
+
+  // upon collection, the vat should scan for local recognizers (weak
+  // collection keys) in case any need to be dropped, and find none
+  t.deepEqual(log.shift(), {
+    type: 'vatstoreGetNextKey',
+    priorKey: `vom.ir.${ex1}|`,
+    result: 'vom.rc.o+d6/1',
+  });
 
   // and once it's collected, the vat should emit `syscall.retireExport`
   // because nobody else will be able to recognize it again
@@ -313,19 +330,19 @@ test.serial(
   'GC dispatch.retireExports inhibits syscall.retireExports',
   async t => {
     const { log, syscall } = buildSyscall();
-    let wr;
+    let collected;
     function build(_vatPowers) {
-      let ex1;
+      const holder = new Set();
       const root = Far('root', {
         hold() {
-          ex1 = Far('export', {});
-          wr = new WeakRef(ex1);
+          const ex1 = Far('export', {});
+          holder.add(ex1);
+          collected = watchCollected(ex1);
           return ex1;
         },
         two() {},
         drop() {
-          // eslint-disable-next-line no-unused-vars
-          ex1 = undefined; // drop the last userspace strongref
+          holder.clear(); // drop the last userspace strongref
         },
       });
       return root;
@@ -356,19 +373,19 @@ test.serial(
 
     // the exported Remotable should be held in place by exportedRemotables
     // until we tell the vat we don't need it any more
-    t.truthy(wr.deref());
+    t.false(collected.result);
 
     // an intermediate message will trigger GC, but the presence is still held
     await dispatch(makeMessage(rootA, 'two', []));
     await dispatch(makeBringOutYourDead());
-    t.truthy(wr.deref());
+    t.false(collected.result);
 
     // now tell the vat we don't need a strong reference to that export.
     await dispatch(makeDropExports(ex1));
     await dispatch(makeBringOutYourDead());
 
     // that removes the liveslots strongref, but the vat's remains in place
-    t.truthy(wr.deref());
+    t.false(collected.result);
 
     // now the kernel tells the vat we can't even recognize the export
     await dispatch(makeRetireExports(ex1));
@@ -376,17 +393,25 @@ test.serial(
 
     // that ought to delete the table entry, but doesn't affect the vat
     // strongref
-    t.truthy(wr.deref());
+    t.false(collected.result);
 
     // now tell the vat to drop its strongref
     await dispatch(makeMessage(rootA, 'drop', []));
     await dispatch(makeBringOutYourDead());
 
     // which should let the export be collected
-    t.falsy(wr.deref());
+    t.true(collected.result);
+
+    // the vat should scan for local recognizers (weak collection
+    // keys) in case any need to be dropped, and find none
+    t.deepEqual(log.shift(), {
+      type: 'vatstoreGetNextKey',
+      priorKey: 'vom.ir.o+10|',
+      result: 'vom.rc.o+d6/1',
+    });
 
-    // the vat should *not* emit `syscall.retireExport`, because it already
-    // received a dispatch.retireExport
+    // the vat should *not* emit `syscall.retireExport`, because it
+    // already received a dispatch.retireExport
     t.deepEqual(log, []);
   },
 );

package/test/{test-liveslots.js → liveslots.test.js}

@@ -1,13 +1,13 @@
+// @ts-nocheck
 import test from 'ava';
-import '@endo/init/debug.js';
 
+import { Fail } from '@endo/errors';
 import { E } from '@endo/eventual-send';
 import { Far } from '@endo/marshal';
 import { makePromiseKit } from '@endo/promise-kit';
-import { Fail } from '@agoric/assert';
+import { kslot, kser, kunser } from '@agoric/kmarshal';
 import { M } from '@agoric/store';
 import { makeLiveSlots, makeMarshaller } from '../src/liveslots.js';
-import { kslot, kser, kunser } from './kmarshal.js';
 import { buildSyscall, makeDispatch } from './liveslots-helpers.js';
 import { makeMessage, makeStartVat, makeResolve, makeReject } from './util.js';
 import { makeMockGC } from './mock-gc.js';
@@ -45,14 +45,14 @@ test('calls', async t => {
 
   // root!one() // sendOnly
   await dispatch(makeMessage(rootA, 'one', ['args']));
-  t.deepEqual(log.shift(), 'one');
+  t.is(log.shift(), 'one');
 
   // pr = makePromise()
   // root!two(pr.promise)
   // pr.resolve('result')
   await dispatch(makeMessage(rootA, 'two', [kslot('p-1')]));
   t.deepEqual(log.shift(), { type: 'subscribe', target: 'p-1' });
-  t.deepEqual(log.shift(), 'two true');
+  t.is(log.shift(), 'two true');
 
   await dispatch(makeResolve('p-1', kser('result')));
   t.deepEqual(log.shift(), ['res', 'result']);
@@ -63,7 +63,7 @@ test('calls', async t => {
 
   await dispatch(makeMessage(rootA, 'two', [kslot('p-2')]));
   t.deepEqual(log.shift(), { type: 'subscribe', target: 'p-2' });
-  t.deepEqual(log.shift(), 'two true');
+  t.is(log.shift(), 'two true');
 
   await dispatch(makeReject('p-2', kser('rejection')));
   t.deepEqual(log.shift(), ['rej', 'rejection']);
@@ -99,7 +99,7 @@ test('liveslots pipelines to syscall.send', async t => {
   // for x!pipe1(), a second pipelined to the result promise of it, and a
   // third pipelined to the result of the second.
 
-  t.deepEqual(log.shift(), 'sent p1p2p3');
+  t.is(log.shift(), 'sent p1p2p3');
   t.deepEqual(log.shift(), {
     type: 'send',
     targetSlot: x,
@@ -656,8 +656,7 @@ test('capdata size limit on syscalls', async t => {
   };
 
   const send = op => dispatch(makeMessage(rootA, op, [kslot(target)], rp));
-  const expectFail = () =>
-    t.deepEqual(log.shift(), 'fail: syscall capdata too large');
+  const expectFail = () => t.is(log.shift(), 'fail: syscall capdata too large');
   const expectVoidReturn = () =>
     t.deepEqual(log.shift(), {
       type: 'resolve',
@@ -906,7 +905,7 @@ test('disable disavow', async t => {
 
   // root~.one() // sendOnly
   await dispatch(makeMessage(rootA, 'one', []));
-  t.deepEqual(log.shift(), false);
+  t.is(log.shift(), false);
   t.deepEqual(log, []);
 });
 
@@ -967,7 +966,7 @@ test('disavow', async t => {
   // root~.one(import1) // sendOnly
   await dispatch(makeMessage(rootA, 'one', [kslot(import1)]));
   t.deepEqual(log.shift(), { type: 'dropImports', slots: [import1] });
-  t.deepEqual(log.shift(), 'disavowed pres1');
+  t.is(log.shift(), 'disavowed pres1');
 
   function loggedError(re) {
     const l = log.shift();
@@ -975,11 +974,11 @@ test('disavow', async t => {
     t.truthy(re.test(l.message));
   }
   loggedError(/attempt to disavow unknown/);
-  t.deepEqual(log.shift(), 'tried duplicate disavow');
+  t.is(log.shift(), 'tried duplicate disavow');
   loggedError(/attempt to disavow unknown/);
-  t.deepEqual(log.shift(), 'tried to disavow Promise');
+  t.is(log.shift(), 'tried to disavow Promise');
   loggedError(/attempt to disavow an export/);
-  t.deepEqual(log.shift(), 'tried to disavow export');
+  t.is(log.shift(), 'tried to disavow export');
   const msg = log.shift();
   t.like(msg, {
     type: 'exit',
@@ -987,7 +986,7 @@ test('disavow', async t => {
   });
   expectError(t, msg.info, /this Presence has been disavowed/);
   t.deepEqual(log.shift(), Error('this Presence has been disavowed'));
-  t.deepEqual(log.shift(), 'tried to send to disavowed');
+  t.is(log.shift(), 'tried to send to disavowed');
   t.deepEqual(log, []);
 });
 

package/test/mock-gc.js

@@ -1,3 +1,4 @@
+// @ts-nocheck
 import { waitUntilQuiescent } from './waitUntilQuiescent.js';
 import { makeDummyMeterControl } from './dummyMeterControl.js';
 

package/test/storeGC/{test-lifecycle.js → lifecycle.test.js}

@@ -1,12 +1,12 @@
+// @ts-nocheck
 import test from 'ava';
-import '@endo/init/debug.js';
 
+import { kslot, kunser } from '@agoric/kmarshal';
 import {
   setupTestLiveslots,
   findSyscallsByType,
 } from '../liveslots-helpers.js';
 import { buildRootObject, mainHeldIdx, mapRef } from '../gc-helpers.js';
-import { kslot, kunser } from '../kmarshal.js';
 import { parseVatSlot } from '../../src/parseVatSlots.js';
 
 // These tests follow the model described in

package/test/storeGC/{test-refcount-management.js → refcount-management.test.js}

@@ -1,6 +1,6 @@
 import test from 'ava';
-import '@endo/init/debug.js';
 
+import { kslot } from '@agoric/kmarshal';
 import {
   findSyscallsByType,
   setupTestLiveslots,
@@ -12,7 +12,6 @@ import {
   refValString,
   assertCollectionDeleted,
 } from '../gc-helpers.js';
-import { kslot } from '../kmarshal.js';
 import { vstr } from '../util.js';
 
 // These tests follow the model described in

package/test/storeGC/{test-scalar-store-kind.js → scalar-store-kind.test.js}

@@ -1,5 +1,4 @@
 import test from 'ava';
-import '@endo/init/debug.js';
 
 import { setupTestLiveslots } from '../liveslots-helpers.js';
 import { buildRootObject, mapRef } from '../gc-helpers.js';

package/test/storeGC/{test-weak-key.js → weak-key.test.js}

@@ -1,6 +1,6 @@
 import test from 'ava';
-import '@endo/init/debug.js';
 
+import { kslot } from '@agoric/kmarshal';
 import { setupTestLiveslots } from '../liveslots-helpers.js';
 import {
   buildRootObject,
@@ -8,7 +8,6 @@ import {
   assertCollectionDeleted,
   deduceCollectionID,
 } from '../gc-helpers.js';
-import { kslot } from '../kmarshal.js';
 import { vstr } from '../util.js';
 
 // These tests follow the model described in test-virtualObjectGC.js

package/test/strict-test-env-upgrade.test.js

@@ -0,0 +1,94 @@
+/* global globalThis */
+// eslint-disable-next-line import/order
+import { annihilate, startLife } from '../tools/prepare-strict-test-env.js';
+
+import test from 'ava';
+
+import { makeUpgradeDisconnection } from '@agoric/internal/src/upgrade-api.js';
+import { makeExoUtils } from './exo-utils.js';
+
+test.serial('kind redefinition enforced', async t => {
+  annihilate();
+
+  const { prepareExoClass } = makeExoUtils(globalThis.VatData);
+
+  await startLife(async baggage => {
+    const makeTestExo = prepareExoClass(
+      baggage,
+      'TestExo',
+      undefined,
+      () => ({}),
+      {
+        foo() {
+          return 'bar';
+        },
+      },
+    );
+
+    baggage.init('testExo', makeTestExo());
+  });
+
+  await t.throwsAsync(
+    async () =>
+      startLife(async () => {
+        // Not redefining the kind here
+      }),
+    { message: 'defineDurableKind not called for tags: [TestExo]' },
+  );
+
+  await startLife(async baggage => {
+    prepareExoClass(baggage, 'TestExo', undefined, () => ({}), {
+      foo() {
+        return 'baz';
+      },
+    });
+
+    t.is(baggage.get('testExo').foo(), 'baz');
+  });
+});
+
+test.serial('decided promise rejected', async t => {
+  annihilate();
+
+  const { prepareExo } = makeExoUtils(globalThis.VatData);
+  const { watchPromise } = globalThis.VatData;
+
+  t.plan(1);
+
+  await startLife(async baggage => {
+    const watcher = prepareExo(
+      baggage,
+      'DurablePromiseTestWatcher',
+      undefined,
+      {
+        onFulfilled(value) {
+          t.fail(
+            `First incarnation watcher onFulfilled triggered with value ${value}`,
+          );
+        },
+        onRejected(reason) {
+          t.fail(
+            `First incarnation watcher onRejected triggered with reason ${reason}`,
+          );
+        },
+      },
+    );
+
+    const never = harden(new Promise(() => {}));
+
+    watchPromise(never, watcher);
+  });
+
+  await startLife(async baggage => {
+    prepareExo(baggage, 'DurablePromiseTestWatcher', undefined, {
+      onFulfilled(value) {
+        t.fail(
+          `Second incarnation watcher onFulfilled triggered with value ${value}`,
+        );
+      },
+      onRejected(reason) {
+        t.deepEqual(reason, makeUpgradeDisconnection('vat upgraded', 1));
+      },
+    });
+  });
+});

package/test/util.js

@@ -1,5 +1,5 @@
+import { kser } from '@agoric/kmarshal';
 import { vstr } from './vat-util.js';
-import { kser } from './kmarshal.js';
 
 export { vstr };
 
@@ -48,7 +48,7 @@ export function buildDispatch(onDispatchCallback) {
 
 /**
  * @param {unknown} target
- * @param {string} method
+ * @param {string | symbol} method
  * @param {any[]} args
  * @param {unknown} result
  */