@agoric/async-flow 0.1.1-calypso-dev-84eb287.0

package/test/bijection.test.js

@@ -0,0 +1,124 @@
+// eslint-disable-next-line import/order
+import {
+  test,
+  getBaggage,
+  annihilate,
+  nextLife,
+} from './prepare-test-env-ava.js';
+
+import { Far } from '@endo/pass-style';
+import { prepareVowTools } from '@agoric/vow';
+import { isVow, toPassableCap } from '@agoric/vow/src/vow-utils.js';
+import { makeHeapZone } from '@agoric/zone/heap.js';
+import { makeVirtualZone } from '@agoric/zone/virtual.js';
+import { makeDurableZone } from '@agoric/zone/durable.js';
+
+import { prepareBijection } from '../src/bijection.js';
+
+/**
+ * @import {PromiseKit} from '@endo/promise-kit'
+ * @import {Zone} from '@agoric/base-zone'
+ * @import {Ephemera} from './types.js';
+ */
+
+/**
+ * @param {any} t
+ * @param {Zone} zone
+ */
+const testBijection = (t, zone) => {
+  const { makeVowKit } = prepareVowTools(zone);
+  const makeBijection = prepareBijection(zone);
+  const bij = zone.makeOnce('bij', makeBijection);
+
+  const h1 = zone.exo('h1', undefined, {});
+  const h2 = zone.exo('h2', undefined, {});
+  const h3 = zone.makeOnce('h3', () => makeVowKit().vow);
+  t.true(isVow(h3));
+
+  const g1 = Far('g1', {});
+  const g2 = Far('g2', {});
+  const g3 = harden(Promise.resolve('g3'));
+
+  t.false(bij.has(g1, h1));
+  t.throws(() => bij.guestToHost(g1), {
+    message: 'guestToHost key not found: "[Alleged: g1]"',
+  });
+  t.throws(() => bij.hostToGuest(h1), {
+    message: 'hostToGuest key not found: "[Alleged: h1]"',
+  });
+  t.false(bij.hasGuest(g1));
+  t.false(bij.hasHost(h1));
+  t.false(bij.hasGuest(h1));
+  t.false(bij.hasHost(g1));
+
+  bij.unwrapInit(g1, h1);
+
+  t.true(bij.has(g1, h1));
+  t.is(toPassableCap(bij.guestToHost(g1)), toPassableCap(h1));
+  t.is(bij.hostToGuest(h1), g1);
+  t.true(bij.hasGuest(g1));
+  t.true(bij.hasHost(h1));
+  t.false(bij.hasGuest(h1));
+  t.false(bij.hasHost(g1));
+
+  t.throws(() => bij.unwrapInit(g1, h2), {
+    message:
+      'guestToHost key already bound: "[Alleged: g1]" -> "[Alleged: h1]" vs "[Alleged: h2]"',
+  });
+  t.throws(() => bij.unwrapInit(g2, h1), {
+    message:
+      'hostToGuest key already bound: "[Alleged: h1]" -> "[Alleged: g1]" vs "[Alleged: g2]"',
+  });
+  t.throws(() => bij.has(g1, h2), {
+    message:
+      'internal: g->h "[Alleged: g1]" -> "[Alleged: h2]" vs "[Alleged: h1]"',
+  });
+  t.false(bij.has(g2, h2));
+  bij.unwrapInit(g2, h2);
+  t.true(bij.has(g2, h2));
+
+  t.false(bij.has(g3, h3));
+  bij.unwrapInit(g3, h3);
+  t.true(bij.has(g3, h3));
+  t.false(bij.has(h3, g3));
+};
+
+test('test heap bijection', t => {
+  const zone = makeHeapZone('heapRoot');
+  testBijection(t, zone);
+});
+
+test.serial('test virtual bijection', t => {
+  annihilate();
+  const zone = makeVirtualZone('virtualRoot');
+  testBijection(t, zone);
+});
+
+test.serial('test durable bijection', t => {
+  annihilate();
+
+  nextLife();
+  const zone1 = makeDurableZone(getBaggage(), 'durableRoot');
+  testBijection(t, zone1);
+
+  // Bijections persist but revive empty since all the guests disappear anyway
+
+  nextLife();
+  const zone2 = makeDurableZone(getBaggage(), 'durableRoot');
+  testBijection(t, zone2);
+});
+
+test('test heap bijection reset', t => {
+  const zone = makeHeapZone('heapRoot');
+  const makeBijection = prepareBijection(zone);
+  const bij = makeBijection();
+
+  const h1 = zone.exo('h1', undefined, {});
+  const g1 = Far('g1', {});
+
+  t.false(bij.has(g1, h1));
+  bij.unwrapInit(g1, h1);
+  t.true(bij.has(g1, h1));
+  bij.reset();
+  t.false(bij.has(g1, h1));
+});

package/test/convert.test.js

@@ -0,0 +1,132 @@
+// eslint-disable-next-line import/order
+import {
+  test,
+  getBaggage,
+  annihilate,
+  nextLife,
+  asyncFlowVerbose,
+} from './prepare-test-env-ava.js';
+
+import { X, makeError, q } from '@endo/errors';
+import { Far, getInterfaceOf, makeTagged, passStyleOf } from '@endo/pass-style';
+import { prepareVowTools } from '@agoric/vow';
+import { isVow } from '@agoric/vow/src/vow-utils.js';
+import { makeHeapZone } from '@agoric/zone/heap.js';
+import { makeVirtualZone } from '@agoric/zone/virtual.js';
+import { makeDurableZone } from '@agoric/zone/durable.js';
+
+import { makeConvertKit } from '../src/convert.js';
+import { prepareBijection } from '../src/bijection.js';
+
+/**
+ * @import {PromiseKit} from '@endo/promise-kit'
+ * @import {Zone} from '@agoric/base-zone'
+ */
+
+/**
+ * @param {any} t
+ * @param {Zone} zone
+ * @param {boolean} [showOnConsole]
+ */
+const testConvert = (t, zone, showOnConsole = false) => {
+  const { makeVowKit } = prepareVowTools(zone);
+  const makeBijection = prepareBijection(zone);
+  const bij = zone.makeOnce('bij', makeBijection);
+
+  const makeGuestForHostRemotable = hRem => {
+    const iface = getInterfaceOf(hRem);
+    return Far(`${iface} guest wrapper`, {});
+  };
+
+  const makeGuestForHostVow = _hVow => Promise.resolve('guest P');
+
+  const { guestToHost, hostToGuest } = makeConvertKit(
+    bij,
+    makeGuestForHostRemotable,
+    makeGuestForHostVow,
+  );
+
+  t.is(hostToGuest(8), 8);
+  const h1 = zone.exo('h1', undefined, {});
+  const h2 = zone.exo('h2', undefined, {});
+  const h3 = zone.makeOnce('h3', () => makeVowKit().vow);
+  t.true(isVow(h3));
+
+  const g1 = hostToGuest(h1);
+  const g2 = hostToGuest(h2);
+  const g3 = hostToGuest(h3);
+  t.is(passStyleOf(g1), 'remotable');
+  t.is(passStyleOf(g2), 'remotable');
+  t.is(passStyleOf(g3), 'promise');
+  t.not(g1, g2);
+  t.is(hostToGuest(h1), g1);
+  t.is(hostToGuest(h2), g2);
+  t.is(hostToGuest(h3), g3);
+
+  const h4 = makeError(X`open ${'redacted'} ${q('quoted')}`);
+  const g4a = hostToGuest(h4);
+  const g4b = hostToGuest(h4);
+  t.not(g4a, g4b);
+  t.deepEqual(g4a, g4b);
+
+  t.is(guestToHost(g1), h1);
+  t.is(guestToHost(g2), h2);
+  t.is(guestToHost(g3), h3);
+
+  t.deepEqual(guestToHost(harden([g1, g3])), [h1, h3]);
+  t.deepEqual(hostToGuest(harden([h1, h3])), [g1, g3]);
+  t.deepEqual(guestToHost(harden(URIError('msg'))), URIError('msg'));
+  t.deepEqual(hostToGuest(harden(URIError('msg'))), URIError('msg'));
+
+  // guestToHost and hostToGuest does its own hardening
+  t.deepEqual(guestToHost([g1, g3]), [h1, h3]);
+  t.deepEqual(hostToGuest([h1, h3]), [g1, g3]);
+  t.deepEqual(guestToHost(URIError('msg')), URIError('msg'));
+  t.deepEqual(hostToGuest(URIError('msg')), URIError('msg'));
+
+  t.deepEqual(guestToHost({ o1: g1, o2: g2 }), { o1: h1, o2: h2 });
+  t.deepEqual(hostToGuest({ o1: h1, o2: h2 }), { o1: g1, o2: g2 });
+  t.deepEqual(guestToHost(makeTagged('t', g1)), makeTagged('t', h1));
+  t.deepEqual(hostToGuest(makeTagged('t', h1)), makeTagged('t', g1));
+
+  const gErr1 = makeError(X`error ${'redacted message'}`, URIError);
+  const hErr1 = guestToHost(gErr1);
+  const gErr2 = hostToGuest(hErr1);
+
+  t.not(gErr1, hErr1);
+  t.not(hErr1, gErr2);
+  t.not(gErr1, gErr2);
+  t.is(gErr1.name, 'URIError');
+  t.is(hErr1.name, 'URIError');
+  t.is(gErr2.name, 'URIError');
+
+  if (showOnConsole) {
+    t.log('gErr2', gErr2);
+  }
+};
+
+test('test heap convert', t => {
+  const zone = makeHeapZone('heapRoot');
+  testConvert(t, zone, asyncFlowVerbose());
+});
+
+test.serial('test virtual convert', t => {
+  annihilate();
+  const zone = makeVirtualZone('virtualRoot');
+  testConvert(t, zone);
+});
+
+test.serial('test durable convert', t => {
+  annihilate();
+
+  nextLife();
+  const zone1 = makeDurableZone(getBaggage(), 'durableRoot');
+  testConvert(t, zone1);
+
+  // These converters keep their state only in the bijection,
+  // which loses all its memory between incarnations.
+
+  nextLife();
+  const zone2 = makeDurableZone(getBaggage(), 'durableRoot');
+  testConvert(t, zone2);
+});

package/test/endowments.test.js

@@ -0,0 +1,157 @@
+// eslint-disable-next-line import/order
+import {
+  test,
+  getBaggage,
+  annihilate,
+  nextLife,
+} from './prepare-test-env-ava.js';
+
+import { Far, getInterfaceOf, isPassable, passStyleOf } from '@endo/pass-style';
+import { prepareVowTools } from '@agoric/vow';
+import { isVow } from '@agoric/vow/src/vow-utils.js';
+import { makeHeapZone } from '@agoric/zone/heap.js';
+import { makeVirtualZone } from '@agoric/zone/virtual.js';
+import { makeDurableZone } from '@agoric/zone/durable.js';
+
+import { forwardingMethods, prepareEndowmentTools } from '../src/endowments.js';
+import { makeConvertKit } from '../src/convert.js';
+import { prepareBijection } from '../src/bijection.js';
+
+const { ownKeys } = Reflect;
+
+const testEndowmentPlay = async (t, zone, gen, isDurable) => {
+  const vowTools = prepareVowTools(zone);
+  const { when } = vowTools;
+  const { prepareEndowment, unwrap } = prepareEndowmentTools(zone, {
+    vowTools,
+  });
+
+  const endowment = harden({
+    promise: Promise.resolve(`${gen} promise`),
+    storable: {
+      emptyRecord: {},
+      primitive: 'foo',
+      null: null,
+      undefined,
+      exo: zone.exo('AnExo', undefined, {
+        name() {
+          return `${gen} exo`;
+        },
+      }),
+      error: URIError(`${gen} error`),
+    },
+    far: Far('AFar', {
+      name: () => `${gen} far`,
+    }),
+    function() {
+      return `${gen} function`;
+    },
+    array: [() => `${gen} f1`, () => `${gen} f2`],
+    state: {
+      // So the concrete keys differ by gen
+      get [`${gen}_foo`]() {
+        return `${gen} foo`;
+      },
+      get [`${gen}_bar`]() {
+        return `${gen} bar`;
+      },
+    },
+  });
+
+  const wrapped = prepareEndowment(zone, 't1', endowment);
+
+  t.is(passStyleOf(wrapped), 'copyRecord');
+  t.is(passStyleOf(wrapped.promise), 'tagged');
+  t.true(isVow(wrapped.promise));
+  t.is(endowment.storable, wrapped.storable);
+  t.deepEqual(ownKeys(endowment), ownKeys(wrapped));
+  t.deepEqual(ownKeys(endowment.storable), ownKeys(wrapped.storable));
+  t.is(passStyleOf(wrapped.storable), 'copyRecord');
+  t.is(wrapped.storable.exo.name(), `${gen} exo`);
+  if (isDurable) {
+    t.not(endowment.far, wrapped.far); // since not durably storable
+  } else {
+    t.is(endowment.far, wrapped.far); // storable in heap, virtual
+  }
+  t.is(passStyleOf(wrapped.far), 'remotable');
+  t.is(wrapped.far.name(), `${gen} far`);
+  t.is(passStyleOf(wrapped.function), 'remotable');
+  t.is(wrapped.function.apply([]), `${gen} function`);
+  t.is(passStyleOf(wrapped.array), 'copyArray');
+  t.is(passStyleOf(wrapped.array[0]), 'remotable');
+  t.is(wrapped.array[0].apply([]), `${gen} f1`);
+  t.is(passStyleOf(wrapped.state), 'remotable');
+  t.is(endowment.state[`${gen}_foo`], `${gen} foo`);
+  t.is(wrapped.state.get(`${gen}_foo`), `${gen} foo`);
+
+  const makeBijection = prepareBijection(zone, unwrap);
+  const bij = zone.makeOnce('bij', makeBijection);
+
+  const makeGuestForHostRemotable = hRem => {
+    const iface = getInterfaceOf(hRem);
+    return Far(`${iface} guest wrapper`, forwardingMethods(hRem));
+  };
+
+  const makeGuestForHostVow = hVow => {
+    return when(hVow);
+  };
+
+  const {
+    // guestToHost,
+    hostToGuest,
+  } = makeConvertKit(bij, makeGuestForHostRemotable, makeGuestForHostVow);
+
+  const unwrapped = hostToGuest(wrapped);
+
+  t.false(isPassable(unwrapped));
+  t.is(passStyleOf(unwrapped.promise), 'promise');
+  t.is(await unwrapped.promise, `${gen} promise`);
+  t.not(wrapped.storable, unwrapped.storable);
+  t.is(passStyleOf(unwrapped.storable), 'copyRecord');
+  t.deepEqual(ownKeys(wrapped), ownKeys(unwrapped));
+  t.deepEqual(ownKeys(wrapped.storable), ownKeys(unwrapped.storable));
+  t.not(wrapped.storable.exo, unwrapped.storable.exo);
+  t.is(unwrapped.storable.exo.name(), `${gen} exo`);
+  t.is(passStyleOf(unwrapped.far), 'remotable');
+  t.is(unwrapped.far.name(), `${gen} far`);
+  t.false(isPassable(unwrapped.function));
+  t.is(typeof unwrapped.function, 'function');
+  t.is(unwrapped.function(), `${gen} function`);
+  t.is(unwrapped.array[0](), `${gen} f1`);
+  t.false(isPassable(unwrapped.state));
+  t.is(typeof unwrapped.state, 'object');
+  t.is(unwrapped.state[`${gen}_foo`], `${gen} foo`);
+};
+
+const testEndowmentBadReplay = async (_t, _zone, _gen, _isDurable) => {
+  // FIXME TODO This upgrade should fail since it doesn't re-prepare
+  // everything. Only after that's fixed does it make sense to
+  // expand this to test insufficient re-preparation.
+};
+
+await test.serial('test heap endowments', async t => {
+  const zone = makeHeapZone('heapRoot');
+  return testEndowmentPlay(t, zone, 'first', false);
+});
+
+test.serial('test virtual endowments', async t => {
+  annihilate();
+  const zone = makeVirtualZone('virtualRoot');
+  return testEndowmentPlay(t, zone, 'first', false);
+});
+
+test.serial('test durable endowments', async t => {
+  annihilate();
+
+  nextLife();
+  const zone1 = makeDurableZone(getBaggage(), 'durableRoot');
+  await testEndowmentPlay(t, zone1, 'first', true);
+
+  nextLife();
+  const zone2 = makeDurableZone(getBaggage(), 'durableRoot');
+  await testEndowmentBadReplay(t, zone2, '2nd', true);
+
+  nextLife();
+  const zone3 = makeDurableZone(getBaggage(), 'durableRoot');
+  return testEndowmentPlay(t, zone3, '3rd', true);
+});

package/test/equate.test.js

@@ -0,0 +1,120 @@
+// eslint-disable-next-line import/order
+import {
+  test,
+  getBaggage,
+  annihilate,
+  nextLife,
+  asyncFlowVerbose,
+} from './prepare-test-env-ava.js';
+
+import { X, makeError } from '@endo/errors';
+import { Far } from '@endo/pass-style';
+import { prepareVowTools } from '@agoric/vow';
+import { isVow } from '@agoric/vow/src/vow-utils.js';
+import { makeHeapZone } from '@agoric/zone/heap.js';
+import { makeVirtualZone } from '@agoric/zone/virtual.js';
+import { makeDurableZone } from '@agoric/zone/durable.js';
+
+import { prepareBijection } from '../src/bijection.js';
+import { makeEquate } from '../src/equate.js';
+
+/**
+ * @import {Zone} from '@agoric/base-zone'
+ */
+
+/**
+ * @param {any} t
+ * @param {Zone} zone
+ * @param {boolean} [showOnConsole]
+ */
+const testEquate = (t, zone, showOnConsole = false) => {
+  const { makeVowKit } = prepareVowTools(zone);
+  const makeBijection = prepareBijection(zone);
+  const bij = zone.makeOnce('bij', makeBijection);
+
+  t.throws(() => zone.makeOnce('equate', () => makeEquate(bij)), {
+    message: 'maker return value "[Function equate]" is not storable',
+  });
+
+  const equate = makeEquate(bij);
+
+  equate(8, 8);
+  t.throws(() => equate(8, 9), {
+    message: 'unequal 8 vs 9',
+  });
+
+  const h1 = zone.exo('h1', undefined, {});
+  const h2 = zone.makeOnce('h2', () => makeVowKit().vow);
+  t.true(isVow(h2));
+
+  const g1 = Far('g1', {});
+  const g2 = harden(Promise.resolve('g2'));
+
+  t.throws(() => equate(g1, h1), {
+    message:
+      'cannot yet send guest remotables to host "[Alleged: g1]" vs "[Alleged: h1]"',
+  });
+  bij.unwrapInit(g1, h1);
+  t.notThrows(() => equate(g1, h1));
+  t.throws(() => equate(g1, h2), {
+    message: 'internal: g->h "[Alleged: g1]" -> "[Vow]" vs "[Alleged: h1]"',
+  });
+  t.throws(() => equate(g2, h1), {
+    message: 'internal: unexpected h->g "[Alleged: h1]" -> "[Alleged: g1]"',
+  });
+  bij.unwrapInit(g2, h2);
+  equate(g2, h2);
+
+  t.throws(() => equate(g1, h2), {
+    message: 'internal: g->h "[Alleged: g1]" -> "[Vow]" vs "[Alleged: h1]"',
+  });
+  t.throws(() => equate(g2, h1), {
+    message: 'internal: g->h "[Promise]" -> "[Alleged: h1]" vs "[Vow]"',
+  });
+
+  equate(harden([g1, g2]), harden([h1, h2]));
+  t.throws(() => equate(harden([g1, g2]), harden([h1, h1])), {
+    message: '[1]: internal: g->h "[Promise]" -> "[Alleged: h1]" vs "[Vow]"',
+  });
+
+  const gErr1 = harden(makeError(X`error ${'redacted message'}`, URIError));
+  const hErr1 = harden(makeError(X`another message`, URIError));
+  const gErr2 = harden(makeError(X`another error`, TypeError));
+
+  equate(gErr1, hErr1);
+  t.throws(() => equate(gErr2, hErr1), {
+    message: 'error name: unequal "TypeError" vs "URIError"',
+  });
+
+  if (showOnConsole) {
+    // To see the annotation chain. Once we're synced with the next ses-ava,
+    // change this to a t.log, so we will see the annotation chain in context.
+    t.log('hErr1', hErr1);
+  }
+};
+
+test('test heap equate', t => {
+  const zone = makeHeapZone('heapRoot');
+  testEquate(t, zone, asyncFlowVerbose());
+});
+
+test.serial('test virtual equate', t => {
+  annihilate();
+  const zone = makeVirtualZone('virtualRoot');
+  testEquate(t, zone);
+});
+
+test.serial('test durable equate', t => {
+  annihilate();
+
+  nextLife();
+  const zone1 = makeDurableZone(getBaggage(), 'durableRoot');
+  testEquate(t, zone1);
+
+  // equate keeps its state only in the bijection,
+  // which loses all its memory between incarnations.
+
+  nextLife();
+  const zone2 = makeDurableZone(getBaggage(), 'durableRoot');
+  testEquate(t, zone2);
+});

package/test/log-store.test.js

@@ -0,0 +1,120 @@
+// eslint-disable-next-line import/order
+import {
+  test,
+  getBaggage,
+  annihilate,
+  nextLife,
+} from './prepare-test-env-ava.js';
+
+import { Fail } from '@endo/errors';
+import { prepareVowTools, toPassableCap } from '@agoric/vow';
+import { makeHeapZone } from '@agoric/zone/heap.js';
+import { makeVirtualZone } from '@agoric/zone/virtual.js';
+import { makeDurableZone } from '@agoric/zone/durable.js';
+
+import { prepareLogStore } from '../src/log-store.js';
+
+/**
+ * @import {PromiseKit} from '@endo/promise-kit'
+ * @import {Zone} from '@agoric/base-zone'
+ * @import {Vow, VowTools} from '@agoric/vow'
+ * @import {LogStore} from '../src/log-store.js';
+ * @import {Bijection} from '../src/bijection.js';
+ */
+
+/**
+ * @param {any} t
+ * @param {Zone} zone
+ */
+const testLogStorePlay = async (t, zone) => {
+  const { makeVowKit } = prepareVowTools(zone);
+  const makeLogStore = prepareLogStore(zone);
+
+  const log = zone.makeOnce('log', () => makeLogStore());
+  const v1 = zone.makeOnce('v1', () => makeVowKit().vow);
+  const v2 = zone.makeOnce('v2', () => makeVowKit().vow);
+
+  t.is(log.getIndex(), 0);
+  t.is(log.getLength(), 0);
+  t.throws(() => log.pushEntry(['bogus']), {
+    message:
+      /^In "pushEntry" method of \(LogStore\): arg 0: \["bogus"\] - Must match one of/,
+  });
+  t.false(log.isReplaying());
+  t.is(await log.promiseReplayDone(), undefined);
+
+  t.is(log.pushEntry(harden(['doFulfill', v1, 'x'])), 1);
+  t.is(log.pushEntry(harden(['doReject', v2, 'y'])), 2);
+  t.deepEqual(log.dump(), [
+    ['doFulfill', v1, 'x'],
+    ['doReject', v2, 'y'],
+  ]);
+  // Because t.deepEqual is too tolerant
+  // @ts-expect-error data dependent typing
+  t.is(toPassableCap(log.dump()[0][1]), toPassableCap(v1));
+  // @ts-expect-error data dependent typing
+  t.is(toPassableCap(log.dump()[1][1]), toPassableCap(v2));
+
+  t.is(log.getIndex(), 2);
+  t.is(log.getLength(), 2);
+  t.false(log.isReplaying());
+  t.is(await log.promiseReplayDone(), undefined);
+};
+
+/**
+ * @param {any} t
+ * @param {Zone} zone
+ */
+const testLogStoreReplay = async (t, zone) => {
+  prepareVowTools(zone);
+  prepareLogStore(zone);
+
+  const log = /** @type {LogStore} */ (
+    zone.makeOnce('log', () => Fail`need log`)
+  );
+  const v1 = /** @type {Vow} */ (zone.makeOnce('v1', () => Fail`need v1`));
+  const v2 = /** @type {Vow} */ (zone.makeOnce('v2', () => Fail`need v2`));
+
+  t.is(log.getIndex(), 0);
+  t.is(log.getLength(), 2);
+  t.true(log.isReplaying());
+
+  t.deepEqual(log.dump(), [
+    ['doFulfill', v1, 'x'],
+    ['doReject', v2, 'y'],
+  ]);
+  // Because t.deepEqual is too tolerant
+  // @ts-expect-error data dependent typing
+  t.is(toPassableCap(log.dump()[0][1]), toPassableCap(v1));
+  // @ts-expect-error data dependent typing
+  t.is(toPassableCap(log.dump()[1][1]), toPassableCap(v2));
+
+  t.deepEqual(log.nextEntry(), ['doFulfill', v1, 'x']);
+  t.deepEqual(log.nextEntry(), ['doReject', v2, 'y']);
+  t.is(log.getIndex(), 2);
+  t.false(log.isReplaying());
+  t.is(await log.promiseReplayDone(), undefined);
+};
+
+await test.serial('test heap log-store', async t => {
+  const zone = makeHeapZone('heapRoot');
+  return testLogStorePlay(t, zone);
+});
+
+test.serial('test virtual log-store', async t => {
+  annihilate();
+  const zone = makeVirtualZone('virtualRoot');
+  return testLogStorePlay(t, zone);
+});
+
+test.serial('test durable log-store', async t => {
+  annihilate();
+
+  nextLife();
+  const zone1 = makeDurableZone(getBaggage(), 'durableRoot');
+  await testLogStorePlay(t, zone1);
+
+  nextLife();
+  const zone2 = makeDurableZone(getBaggage(), 'durableRoot');
+  return testLogStoreReplay(t, zone2);
+});

package/test/prepare-test-env-ava.js

@@ -0,0 +1,28 @@
+import '@agoric/swingset-liveslots/tools/prepare-test-env.js';
+import { wrapTest } from '@endo/ses-ava';
+import rawTest from 'ava';
+
+import { environmentOptionsListHas } from '@endo/env-options';
+import { reincarnate } from '@agoric/swingset-liveslots/tools/setup-vat-data.js';
+
+export const test = wrapTest(rawTest);
+
+/** @type {ReturnType<typeof reincarnate>} */
+let incarnation;
+
+export const annihilate = () => {
+  incarnation = reincarnate({ relaxDurabilityRules: false });
+};
+
+export const getBaggage = () => {
+  return incarnation.fakeVomKit.cm.provideBaggage();
+};
+
+export const nextLife = () => {
+  incarnation = reincarnate(incarnation);
+};
+
+export const asyncFlowVerbose = () => {
+  // TODO figure out how we really want to control this.
+  return environmentOptionsListHas('DEBUG', 'async-flow-verbose');
+};