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

package/test/{test-vo-test-harness.js → vo-test-harness.test.js}

@@ -1,6 +1,5 @@
 import test from 'ava';
-import '@endo/init/debug.js';
-import { runVOTest } from '../tools/vo-test-harness.js';
+import { makeSpy, runVOTest } from '../tools/vo-test-harness.js';
 
 async function voTestTest(t, mode) {
   let makeThing;
@@ -37,8 +36,6 @@ async function voTestTest(t, mode) {
   await runVOTest(t, prepare, makeTestThing, testTestThing);
 }
 
-// Note: these first two are not marked "test.failing" because
-// something is wrong and we need to fix it. Rather, they are
 // confirming that the voTestTest harness would catch problems during
 // downstream tests that use the harness, if those problems arose in
 // the "before" or "after" phases, and reported by the downstream test
@@ -48,20 +45,26 @@ async function voTestTest(t, mode) {
 // fails, otherwise the harness is not doing its job, and is hiding
 // real test failures in some downstream client package.
 
-test.failing('fail during "before" phase', async t => {
-  await voTestTest(t, 'before');
+test('fail during "before" phase', async t => {
+  const tSpy = makeSpy(t);
+  await voTestTest(tSpy, 'before');
+  t.is(tSpy.failureMessage, 'deliberate failure in before phase');
 });
 
-test.failing('fail during "after" phase', async t => {
-  await voTestTest(t, 'after');
+test('fail during "after" phase', async t => {
+  const tSpy = makeSpy(t);
+  await voTestTest(tSpy, 'after');
+  t.is(tSpy.failureMessage, 'deliberate failure in after phase');
 });
 
 // Similarly, this test makes sure that our harness can detect when
 // the downstream test misbehaves and holds on to the object they were
 // supposed to drop.
 
-test.failing('fail due to held object', async t => {
-  await voTestTest(t, 'hold');
+test('fail due to held object', async t => {
+  const tSpy = makeSpy(t);
+  await voTestTest(tSpy, 'hold');
+  t.is(tSpy.falsyMessage, 'somebody continues to hold test object');
 });
 
 test.serial('succeed', async t => {

package/test/{test-vpid-liveslots.js → vpid-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 { makePromiseKit } from '@endo/promise-kit';
-import { Fail } from '@agoric/assert';
 import { Far } from '@endo/marshal';
+import { kser, kslot } from '@agoric/kmarshal';
 import { buildSyscall, makeDispatch } from './liveslots-helpers.js';
 import { makeMessage, makeResolve, makeReject } from './util.js';
-import { kser, kslot } from './kmarshal.js';
 
 function hush(p) {
   p.then(
@@ -293,7 +293,6 @@ async function doVatResolveCase23(t, which, mode, stalls) {
         // another few turns. We wait some number of turns before using p1
         // again, to exercise as many race conditions as possible.
         for (let i = 0; i < stalls; i += 1) {
-          // eslint-disable-next-line no-await-in-loop
           await Promise.resolve();
         }
 
@@ -858,7 +857,7 @@ test('inter-vat circular promise references', async t => {
     let r;
     return Far('root', {
       genPromise() {
-        [p, r] = makePR();
+        void ([p, r] = makePR());
         return p;
       },
       usePromise(pa) {
@@ -899,3 +898,104 @@ test('inter-vat circular promise references', async t => {
   // });
   // t.deepEqual(log, []);
 });
+
+test('accept previously allocated promise', async t => {
+  function build(vatPowers, vatParameters) {
+    const { target } = vatParameters;
+    return Far('root', {
+      call() {
+        const promise = E(target).foo();
+        // wrap to avoid adoption
+        return { promise };
+      },
+      async waitFor(promise2) {
+        // if we're in the same incarnation as the `E(target).foo()`, this
+        // `promise2` will be the same JS Promise as the `promise` above
+        const v = await promise2;
+        return v;
+      },
+    });
+  }
+
+  let log;
+  let syscall;
+  let dispatch;
+
+  const kvStore = new Map();
+  ({ log, syscall } = buildSyscall({ kvStore }));
+
+  const target = 'o-1';
+  ({ dispatch } = await makeDispatch(
+    syscall,
+    build,
+    'reimport-promise',
+    {},
+    { target: kslot(target) },
+  ));
+  log.length = 0; // assume pre-build vatstore operations are correct
+
+  const root = 'o+0';
+  const callResultP = 'p-1';
+  const waitForResultP = 'p-2';
+  const expectedP1 = 'p+5';
+
+  await dispatch(makeMessage(root, 'call', [], callResultP));
+
+  // The vat should send 'foo', subscribe to the result promise, and resolve with that promise
+  t.deepEqual(log.splice(0, 3), [
+    {
+      type: 'send',
+      targetSlot: target,
+      methargs: kser(['foo', []]),
+      resultSlot: expectedP1,
+    },
+    { type: 'subscribe', target: expectedP1 },
+    {
+      type: 'resolve',
+      resolutions: [[callResultP, false, kser({ promise: kslot(expectedP1) })]],
+    },
+  ]);
+  matchIDCounterSet(t, log);
+  t.deepEqual(log, []);
+
+  // snapshot the store at this point
+  const clonedStore = new Map(kvStore);
+
+  const verifyPromiseReImport = async shouldSubscribe => {
+    await dispatch(
+      makeMessage(root, 'waitFor', [kslot(expectedP1)], waitForResultP),
+    );
+
+    // The vat will only subscribe if it was upgraded; if the vat still
+    // remembers it, receiving the vref will merely look it up in slotToVal and
+    // not create a new Promise (and trigger a subscribe)
+    if (shouldSubscribe) {
+      t.deepEqual(log.shift(), { type: 'subscribe', target: expectedP1 });
+    }
+
+    // waitFor will suspend until promise is resolved
+    t.deepEqual(log, []);
+
+    // Resolution propagates the value to the waitFor result
+    await dispatch(makeResolve(expectedP1, kser('success')));
+    t.deepEqual(log.shift(), {
+      type: 'resolve',
+      resolutions: [[waitForResultP, false, kser('success')]],
+    });
+    t.deepEqual(log, []);
+  };
+
+  await verifyPromiseReImport(false);
+  ({ log, syscall } = buildSyscall({ kvStore: clonedStore }));
+  ({ dispatch } = await makeDispatch(
+    syscall,
+    build,
+    'reimport-promise-v2',
+    {},
+    {},
+  ));
+  log.length = 0;
+
+  // verify this works the same in the restarted vat
+  await verifyPromiseReImport(true);
+});

package/test/waitUntilQuiescent.d.ts

@@ -0,0 +1,3 @@
+/** @import {PromiseKit} from '@endo/promise-kit' */
+export function waitUntilQuiescent(): Promise<void>;
+//# sourceMappingURL=waitUntilQuiescent.d.ts.map

package/test/waitUntilQuiescent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"waitUntilQuiescent.d.ts","sourceRoot":"","sources":["waitUntilQuiescent.js"],"names":[],"mappings":"AAGA,oDAAoD;AAKpD,oDAWC"}

package/test/waitUntilQuiescent.js

@@ -1,6 +1,7 @@
 /* global setImmediate */
 import { makePromiseKit } from '@endo/promise-kit';
-/** @template T @typedef {import('@endo/promise-kit').PromiseKit<T>} PromiseKit */
+
+/** @import {PromiseKit} from '@endo/promise-kit' */
 
 // This can only be imported from the Start Compartment, where 'setImmediate'
 // is available.

package/test/weakset-dropped-remotable.test.js

@@ -0,0 +1,50 @@
+import test from 'ava';
+import { Far } from '@endo/marshal';
+import { kser, kslot } from '@agoric/kmarshal';
+import { makeLiveSlots } from '../src/liveslots.js';
+import { buildSyscall } from './liveslots-helpers.js';
+import { makeStartVat, makeMessage, makeBringOutYourDead } from './util.js';
+import { makeMockGC } from './mock-gc.js';
+
+// Test for https://github.com/Agoric/agoric-sdk/issues/9956
+
+test('delete remotable key from weakset', async t => {
+  const { syscall, log } = buildSyscall();
+  const gcTools = makeMockGC();
+  const rem = Far('remotable', {});
+
+  function buildRootObject(vatPowers) {
+    const { VatData } = vatPowers;
+    const { makeScalarBigWeakMapStore } = VatData;
+    const wms = makeScalarBigWeakMapStore();
+    return Far('root', {
+      store: p => {
+        wms.init(rem, p);
+        gcTools.kill(p);
+      },
+    });
+  }
+
+  const makeNS = () => ({ buildRootObject });
+  const ls = makeLiveSlots(syscall, 'vatA', {}, {}, gcTools, undefined, makeNS);
+  const { dispatch } = ls;
+  await dispatch(makeStartVat(kser()));
+
+  await dispatch(makeMessage('o+0', 'store', [kslot('o-1')]));
+
+  // pretend the Remotable was dropped from RAM
+  log.length = 0;
+  gcTools.kill(rem);
+  gcTools.flushAllFRs();
+  await dispatch(makeBringOutYourDead());
+
+  // that ought to emit a drop and retire for the presence
+  const gcCalls = log.filter(
+    l => l.type === 'dropImports' || l.type === 'retireImports',
+  );
+  t.deepEqual(gcCalls, [
+    { type: 'dropImports', slots: ['o-1'] },
+    { type: 'retireImports', slots: ['o-1'] },
+  ]);
+  log.length = 0;
+});

package/tools/fakeCollectionManager.d.ts

@@ -0,0 +1,14 @@
+export function makeFakeCollectionManager(vrm: any, fakeStuff: any, _options?: {}): {
+    getValForSlot: any;
+    setValForSlot: any;
+    registerEntry: any;
+    deleteEntry: any;
+    dumpStore: any;
+    makeScalarBigMapStore: <K, V>(label?: string, options?: StoreOptions) => MapStore<K, V>;
+    makeScalarBigWeakMapStore: <K, V>(label?: string, options?: StoreOptions) => WeakMapStore<K, V>;
+    makeScalarBigSetStore: <K>(label?: string, options?: StoreOptions) => SetStore<K>;
+    makeScalarBigWeakSetStore: <K>(label?: string, options?: StoreOptions) => WeakSetStore<K>;
+    provideBaggage: () => any;
+    flushSchemaCache: () => void;
+};
+//# sourceMappingURL=fakeCollectionManager.d.ts.map

package/tools/fakeCollectionManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fakeCollectionManager.d.ts","sourceRoot":"","sources":["fakeCollectionManager.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;EAyCC"}

package/tools/fakeCollectionManager.js

@@ -0,0 +1,44 @@
+import { makeCollectionManager } from '../src/collectionManager.js';
+
+export function makeFakeCollectionManager(vrm, fakeStuff, _options = {}) {
+  const {
+    makeScalarBigMapStore,
+    makeScalarBigWeakMapStore,
+    makeScalarBigSetStore,
+    makeScalarBigWeakSetStore,
+    provideBaggage,
+    initializeStoreKindInfo,
+    flushSchemaCache,
+  } = makeCollectionManager(
+    fakeStuff.syscall,
+    vrm,
+    fakeStuff.allocateExportID,
+    fakeStuff.allocateCollectionID,
+    fakeStuff.convertValToSlot,
+    fakeStuff.convertSlotToVal,
+    fakeStuff.registerEntry,
+    fakeStuff.marshal.serialize,
+    fakeStuff.marshal.unserialize,
+    fakeStuff.assertAcceptableSyscallCapdataSize,
+  );
+  initializeStoreKindInfo();
+
+  const normalCM = {
+    makeScalarBigMapStore,
+    makeScalarBigWeakMapStore,
+    makeScalarBigSetStore,
+    makeScalarBigWeakSetStore,
+    provideBaggage,
+    flushSchemaCache,
+  };
+
+  const debugTools = {
+    getValForSlot: fakeStuff.getValForSlot,
+    setValForSlot: fakeStuff.setValForSlot,
+    registerEntry: fakeStuff.registerEntry,
+    deleteEntry: fakeStuff.deleteEntry,
+    dumpStore: fakeStuff.dumpStore,
+  };
+
+  return harden({ ...normalCM, ...debugTools });
+}

package/tools/fakeVirtualObjectManager.d.ts

@@ -0,0 +1,32 @@
+export function makeFakeVirtualObjectManager(vrm: any, fakeStuff: any): {
+    getValForSlot: any;
+    setValForSlot: any;
+    registerEntry: any;
+    deleteEntry: any;
+    flushStateCache: () => void;
+    dumpStore: any;
+    initializeKindHandleKind: () => void;
+    defineKind: <P extends Array<any>, S, F>(tag: string, init: (...args: P) => S, facet: F, options?: import("../src/vatDataTypes.js").DefineKindOptions<import("../src/vatDataTypes.js").KindContext<S, F>>) => (...args: P) => import("../src/vatDataTypes.js").KindFacet<F>;
+    defineKindMulti: <P extends Array<any>, S, B>(tag: string, init: (...args: P) => S, behavior: B, options?: import("../src/vatDataTypes.js").DefineKindOptions<import("../src/vatDataTypes.js").MultiKindContext<S, B>>) => (...args: P) => import("../src/vatDataTypes.js").KindFacets<B>;
+    defineDurableKind: <P extends Array<any>, S, F>(kindHandle: import("../src/vatDataTypes.js").DurableKindHandle, init: (...args: P) => S, facet: F, options?: import("../src/vatDataTypes.js").DefineKindOptions<import("../src/vatDataTypes.js").KindContext<S, F>>) => (...args: P) => import("../src/vatDataTypes.js").KindFacet<F>;
+    defineDurableKindMulti: <P extends Array<any>, S, B>(kindHandle: import("../src/vatDataTypes.js").DurableKindHandle, init: (...args: P) => S, behavior: B, options?: import("../src/vatDataTypes.js").DefineKindOptions<import("../src/vatDataTypes.js").MultiKindContext<S, B>>) => (...args: P) => import("../src/vatDataTypes.js").KindFacets<B>;
+    makeKindHandle: (tag: string) => import("../src/vatDataTypes.js").DurableKindHandle;
+    canBeDurable: (specimen: any) => boolean;
+    insistAllDurableKindsReconnected: () => void;
+    VirtualObjectAwareWeakMap: {
+        new (): {
+            has(key: any): any;
+            get(key: any): any;
+            set(key: any, value: any): /*elided*/ any;
+            delete(key: any): any;
+        };
+    };
+    VirtualObjectAwareWeakSet: {
+        new (): {
+            has(value: any): any;
+            add(value: any): /*elided*/ any;
+            delete(value: any): any;
+        };
+    };
+};
+//# sourceMappingURL=fakeVirtualObjectManager.d.ts.map

package/tools/fakeVirtualObjectManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fakeVirtualObjectManager.d.ts","sourceRoot":"","sources":["fakeVirtualObjectManager.js"],"names":[],"mappings":"AAaA;;;;;;;;iEAiDywJ,GAAG,+IAAyF,GAAG;sEAAkK,GAAG,uJAAiG,GAAG;2HAAyQ,GAAG,+IAAyF,GAAG;gIAA2L,GAAG,uJAAiG,GAAG;;;;;;;;;;;;;;;;;;;EAD1vL"}

package/tools/fakeVirtualObjectManager.js

@@ -0,0 +1,62 @@
+import { makeVirtualObjectManager } from '../src/virtualObjectManager.js';
+
+// Note: `fakeVirtualObjectManager` is something of a misnomer here.  The
+// virtual object manager being used to implement this realized by the actual
+// virtual object manager code.  What's being faked is everything else the
+// virtual object manager is embedded in, i.e., the kernel and the rest of
+// liveslots.  In particular, this module can be (and is, and is intended to be)
+// used for unit tests for the virtual object manager itself.  What you get back
+// from `makeFakeVirtualObjectManager` can't be used to program as if you were
+// running in a vat because the rest of the vat environment is not present, but
+// it *will* execute virtual object manager operations in the same way that the
+// real one will because underneath it *is* the real one.
+
+export function makeFakeVirtualObjectManager(vrm, fakeStuff) {
+  const {
+    initializeKindHandleKind,
+    defineKind,
+    defineKindMulti,
+    defineDurableKind,
+    defineDurableKindMulti,
+    makeKindHandle,
+    VirtualObjectAwareWeakMap,
+    VirtualObjectAwareWeakSet,
+    flushStateCache,
+    canBeDurable,
+    insistAllDurableKindsReconnected,
+  } = makeVirtualObjectManager(
+    fakeStuff.syscall,
+    vrm,
+    fakeStuff.allocateExportID,
+    fakeStuff.getSlotForVal,
+    fakeStuff.requiredValForSlot,
+    fakeStuff.registerEntry,
+    fakeStuff.marshal.serialize,
+    fakeStuff.marshal.unserialize,
+    fakeStuff.assertAcceptableSyscallCapdataSize,
+  );
+
+  const normalVOM = {
+    initializeKindHandleKind,
+    defineKind,
+    defineKindMulti,
+    defineDurableKind,
+    defineDurableKindMulti,
+    makeKindHandle,
+    canBeDurable,
+    insistAllDurableKindsReconnected,
+    VirtualObjectAwareWeakMap,
+    VirtualObjectAwareWeakSet,
+  };
+
+  const debugTools = {
+    getValForSlot: fakeStuff.getValForSlot,
+    setValForSlot: fakeStuff.setValForSlot,
+    registerEntry: fakeStuff.registerEntry,
+    deleteEntry: fakeStuff.deleteEntry,
+    flushStateCache,
+    dumpStore: fakeStuff.dumpStore,
+  };
+
+  return harden({ ...normalVOM, ...debugTools });
+}