@agoric/async-flow 0.1.1-dev-16095c5.0

package/test/bad-host.test.js

@@ -0,0 +1,205 @@
+// eslint-disable-next-line import/order
+import {
+  test,
+  getBaggage,
+  annihilate,
+  nextLife,
+} from './prepare-test-env-ava.js';
+
+import { Fail } from '@endo/errors';
+import { M } from '@endo/patterns';
+import { makePromiseKit } from '@endo/promise-kit';
+import { eventLoopIteration } from '@agoric/internal/src/testing-utils.js';
+import { prepareVowTools } 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 { prepareAsyncFlowTools } from '../src/async-flow.js';
+
+const nonPassableFunc = () => 'non-passable-function';
+harden(nonPassableFunc);
+const guestCreatedPromise = harden(Promise.resolve('guest-created'));
+let badResult;
+
+/**
+ * @param {Zone} zone
+ */
+const prepareBadHost = zone =>
+  zone.exoClass(
+    'BadHost',
+    M.interface('BadHost', {}, { defaultGuards: 'raw' }),
+    () => ({}),
+    {
+      badMethod(_badArg = undefined) {
+        return badResult;
+      },
+    },
+  );
+
+/** @typedef {ReturnType<ReturnType<prepareBadHost>>} BadHost */
+
+/**
+ * @param {any} t
+ * @param {Zone} zone
+ */
+const testBadHostFirstPlay = async (t, zone) => {
+  t.log('badHost firstPlay started');
+  const vowTools = prepareVowTools(zone);
+  const { asyncFlow, adminAsyncFlow } = prepareAsyncFlowTools(zone, {
+    vowTools,
+  });
+  const makeBadHost = prepareBadHost(zone);
+  const { makeVowKit } = vowTools;
+
+  const { vow: v1, resolver: _r1 } = zone.makeOnce('v1', () => makeVowKit());
+  // purposely violate rule that guestMethod is closed.
+  const { promise: promiseStep, resolve: resolveStep } = makePromiseKit();
+
+  const { guestMethod } = {
+    async guestMethod(badGuest, _p1) {
+      // nothing bad yet baseline
+      t.is(badGuest.badMethod(), undefined);
+
+      t.throws(() => badGuest.badMethod(guestCreatedPromise), {
+        message:
+          'In a Failed state: see getFailures() or getOptFatalProblem() for more information',
+      });
+
+      resolveStep(true);
+      t.log('  badHost firstPlay about to return "bogus"');
+      // Must not settle outcomeVow
+      return 'bogus';
+    },
+  };
+
+  const wrapperFunc = asyncFlow(zone, 'AsyncFlow1', guestMethod);
+
+  const badHost = zone.makeOnce('badHost', () => makeBadHost());
+
+  const outcomeV = zone.makeOnce('outcomeV', () => wrapperFunc(badHost, v1));
+
+  const flow = adminAsyncFlow.getFlowForOutcomeVow(outcomeV);
+  await promiseStep;
+
+  const fatalProblem = flow.getOptFatalProblem();
+  t.throws(
+    () => {
+      throw fatalProblem;
+    },
+    {
+      message: '[3]: [0]: cannot yet send guest promises "[Promise]"',
+    },
+  );
+
+  t.deepEqual(flow.dump(), [
+    ['checkCall', badHost, 'badMethod', [], 0],
+    ['doReturn', 0, undefined],
+    // Notice that the bad call was not recorded in the log
+  ]);
+  t.log('badHost firstPlay done');
+};
+
+/**
+ * @param {any} t
+ * @param {Zone} zone
+ */
+const testBadHostReplay1 = async (t, zone) => {
+  t.log('badHost replay1 started');
+  const vowTools = prepareVowTools(zone);
+  const { asyncFlow, adminAsyncFlow } = prepareAsyncFlowTools(zone, {
+    vowTools,
+  });
+  prepareBadHost(zone);
+
+  // const { vow: v1, resolver: r1 } = zone.makeOnce('v1', () => Fail`need v1`);
+  // purposely violate rule that guestMethod is closed.
+  const { promise: promiseStep, resolve: resolveStep } = makePromiseKit();
+
+  const { guestMethod } = {
+    async guestMethod(badGuest, p1) {
+      // nothing bad yet baseline
+      t.is(badGuest.badMethod(), undefined);
+
+      // purposely violate rule that guestMethod is closed.
+      badResult = nonPassableFunc;
+
+      let gErr;
+      try {
+        badGuest.badMethod();
+      } catch (err) {
+        gErr = err;
+      }
+      t.throws(
+        () => {
+          throw gErr;
+        },
+        {
+          message:
+            'converting badMethod result: Remotables must be explicitly declared: "[Function nonPassableFunc]"',
+        },
+      );
+      t.log('  badHost replay1 guest error caused by host error', gErr);
+
+      // show that flow is not Failed by host error
+      badResult = 'fine';
+      t.is(badGuest.badMethod(), 'fine');
+
+      resolveStep(true);
+      t.log('  badHost replay1 to hang awaiting p1');
+      // awaiting a promise that won't be resolved until next incarnation
+      await p1;
+      t.fail('must not reach here in replay 1');
+    },
+  };
+
+  asyncFlow(zone, 'AsyncFlow1', guestMethod);
+
+  const badHost = zone.makeOnce('badHost', () => Fail`need badHost`);
+
+  const outcomeV = zone.makeOnce('outcomeV', () => Fail`need outcomeV`);
+
+  const flow = adminAsyncFlow.getFlowForOutcomeVow(outcomeV);
+  await promiseStep;
+
+  const logDump = flow.dump();
+
+  t.deepEqual(logDump, [
+    ['checkCall', badHost, 'badMethod', [], 0],
+    ['doReturn', 0, undefined],
+    ['checkCall', badHost, 'badMethod', [], 2],
+    [
+      'doThrow',
+      2,
+      Error(
+        'converting badMethod result: Remotables must be explicitly declared: "[Function nonPassableFunc]"',
+      ),
+    ],
+    ['checkCall', badHost, 'badMethod', [], 4],
+    ['doReturn', 4, 'fine'],
+  ]);
+  t.log('badHost replay1 done');
+};
+
+test.serial('test heap async-flow bad host', async t => {
+  const zone = makeHeapZone('heapRoot');
+  return testBadHostFirstPlay(t, zone);
+});
+
+test.serial('test virtual async-flow bad host', async t => {
+  annihilate();
+  const zone = makeVirtualZone('virtualRoot');
+  return testBadHostFirstPlay(t, zone);
+});
+
+test.serial('test durable async-flow bad host', async t => {
+  annihilate();
+  const zone1 = makeDurableZone(getBaggage(), 'durableRoot');
+  await testBadHostFirstPlay(t, zone1);
+
+  await eventLoopIteration();
+
+  nextLife();
+  const zone3 = makeDurableZone(getBaggage(), 'durableRoot');
+  return testBadHostReplay1(t, zone3);
+});

package/test/bijection.test.js

@@ -0,0 +1,118 @@
+// 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';
+
+/**
+ * @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.init(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.init(g1, h2), {
+    message:
+      'guestToHost key already bound: "[Alleged: g1]" -> "[Alleged: h1]" vs "[Alleged: h2]"',
+  });
+  t.throws(() => bij.init(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.init(g2, h2);
+  t.true(bij.has(g2, h2));
+
+  t.false(bij.has(g3, h3));
+  bij.init(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.init(g1, h1);
+  t.true(bij.has(g1, h1));
+  bij.reset();
+  t.false(bij.has(g1, h1));
+});

package/test/convert.test.js

@@ -0,0 +1,127 @@
+// 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';
+
+/**
+ * @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/equate.test.js

@@ -0,0 +1,116 @@
+// 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';
+
+/**
+ * @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.init(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.init(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,112 @@
+// 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';
+
+/**
+ * @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('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');
+};