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

package/test/replay-membrane-settlement.test.js

@@ -0,0 +1,154 @@
+// eslint-disable-next-line import/order
+import {
+  test,
+  getBaggage,
+  annihilate,
+  nextLife,
+} from './prepare-test-env-ava.js';
+
+import { Fail } from '@endo/errors';
+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 { prepareLogStore } from '../src/log-store.js';
+import { prepareBijection } from '../src/bijection.js';
+import { makeReplayMembrane } from '../src/replay-membrane.js';
+
+const watchWake = _vowish => {};
+const panic = problem => Fail`panic over ${problem}`;
+
+/**
+ * @param {Zone} zone
+ */
+const preparePingee = zone =>
+  zone.exoClass('Pingee', undefined, () => ({}), {
+    ping() {},
+  });
+
+/**
+ * @param {any} t
+ * @param {Zone} zone
+ */
+const testFirstPlay = async (t, zone) => {
+  const vowTools = prepareVowTools(zone);
+  const { makeVowKit } = vowTools;
+  const makeLogStore = prepareLogStore(zone);
+  const makeBijection = prepareBijection(zone);
+  const makePingee = preparePingee(zone);
+  const { vow: v1, resolver: r1 } = zone.makeOnce('v1', () => makeVowKit());
+  const { vow: _v2, resolver: _r2 } = zone.makeOnce('v2', () => makeVowKit());
+
+  const log = zone.makeOnce('log', () => makeLogStore());
+  const bij = zone.makeOnce('bij', makeBijection);
+
+  const mem = makeReplayMembrane(log, bij, vowTools, watchWake, panic);
+
+  const p1 = mem.hostToGuest(v1);
+  t.deepEqual(log.dump(), []);
+
+  const pingee = zone.makeOnce('pingee', () => makePingee());
+  const guestPingee = mem.hostToGuest(pingee);
+  t.deepEqual(log.dump(), []);
+
+  guestPingee.ping();
+  t.deepEqual(log.dump(), [
+    // keep on separate lines
+    ['checkCall', pingee, 'ping', [], 0],
+    ['doReturn', 0, undefined],
+  ]);
+
+  r1.resolve('x');
+  t.is(await p1, 'x');
+
+  t.deepEqual(log.dump(), [
+    ['checkCall', pingee, 'ping', [], 0],
+    ['doReturn', 0, undefined],
+    ['doFulfill', v1, 'x'],
+  ]);
+};
+
+/**
+ * @param {any} t
+ * @param {Zone} zone
+ */
+const testReplay = async (t, zone) => {
+  const vowTools = prepareVowTools(zone);
+  prepareLogStore(zone);
+  prepareBijection(zone);
+  preparePingee(zone);
+  const { vow: v1 } = zone.makeOnce('v1', () => Fail`need v1`);
+  const { vow: v2, resolver: r2 } = zone.makeOnce('v2', () => Fail`need v2`);
+
+  const log = /** @type {LogStore} */ (
+    zone.makeOnce('log', () => Fail`need log`)
+  );
+  const bij = /** @type {Bijection} */ (
+    zone.makeOnce('bij', () => Fail`need bij`)
+  );
+
+  const pingee = zone.makeOnce('pingee', () => Fail`need pingee`);
+
+  t.deepEqual(log.dump(), [
+    ['checkCall', pingee, 'ping', [], 0],
+    ['doReturn', 0, undefined],
+    ['doFulfill', v1, 'x'],
+  ]);
+
+  const mem = makeReplayMembrane(log, bij, vowTools, watchWake, panic);
+  t.true(log.isReplaying());
+  t.is(log.getIndex(), 0);
+
+  const guestPingee = mem.hostToGuest(pingee);
+  const p2 = mem.hostToGuest(v2);
+  // @ts-expect-error TS doesn't know that r2 is a resolver
+  r2.resolve('y');
+  await eventLoopIteration();
+
+  const p1 = mem.hostToGuest(v1);
+  mem.wake();
+  t.true(log.isReplaying());
+  t.is(log.getIndex(), 0);
+  t.deepEqual(log.dump(), [
+    ['checkCall', pingee, 'ping', [], 0],
+    ['doReturn', 0, undefined],
+    ['doFulfill', v1, 'x'],
+  ]);
+
+  guestPingee.ping();
+  t.is(await p1, 'x');
+  t.is(await p2, 'y');
+  t.false(log.isReplaying());
+
+  t.deepEqual(log.dump(), [
+    ['checkCall', pingee, 'ping', [], 0],
+    ['doReturn', 0, undefined],
+    ['doFulfill', v1, 'x'],
+    ['doFulfill', v2, 'y'],
+  ]);
+};
+
+test.serial('test heap replay-membrane settlement', async t => {
+  const zone = makeHeapZone('heapRoot');
+  return testFirstPlay(t, zone);
+});
+
+test.serial('test virtual replay-membrane settlement', async t => {
+  annihilate();
+  const zone = makeVirtualZone('virtualRoot');
+  return testFirstPlay(t, zone);
+});
+
+test.serial('test durable replay-membrane settlement', async t => {
+  annihilate();
+
+  nextLife();
+  const zone1 = makeDurableZone(getBaggage(), 'durableRoot');
+  await testFirstPlay(t, zone1);
+
+  nextLife();
+  const zone3 = makeDurableZone(getBaggage(), 'durableRoot');
+  return testReplay(t, zone3);
+});

package/test/replay-membrane-zombie.test.js

@@ -0,0 +1,158 @@
+// eslint-disable-next-line import/order
+import {
+  test,
+  getBaggage,
+  annihilate,
+  nextLife,
+} from './prepare-test-env-ava.js';
+
+import { Fail } from '@endo/errors';
+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 { prepareLogStore } from '../src/log-store.js';
+import { prepareBijection } from '../src/bijection.js';
+import { makeReplayMembrane } from '../src/replay-membrane.js';
+
+const watchWake = _vowish => {};
+const panic = problem => Fail`panic over ${problem}`;
+
+/**
+ * @param {any} t
+ * @param {Zone} zone
+ */
+const testMissingStop = async (t, zone) => {
+  const vowTools = prepareVowTools(zone);
+  const { makeVowKit } = vowTools;
+  const makeLogStore = prepareLogStore(zone);
+  const makeBijection = prepareBijection(zone);
+
+  const log = makeLogStore();
+  const bij = makeBijection();
+
+  const memA = makeReplayMembrane(log, bij, vowTools, watchWake, panic);
+
+  const { vow: v1, resolver: r1 } = makeVowKit();
+
+  const p1A = memA.hostToGuest(v1);
+  t.true(bij.has(p1A, v1));
+
+  await eventLoopIteration();
+
+  t.deepEqual(log.dump(), []);
+
+  // do all the steps to drop an old membrane and set up a new membrane,
+  // except stopping the old membrane,
+  // to demonstate why `makeGuestForHostVow` also tests`stopped`.
+  log.reset();
+  bij.reset();
+  const memB = makeReplayMembrane(log, bij, vowTools, watchWake, panic);
+
+  const p1B = memB.hostToGuest(v1);
+  t.true(bij.has(p1B, v1));
+  t.false(bij.hasGuest(p1A));
+
+  await eventLoopIteration();
+
+  t.deepEqual(log.dump(), []);
+
+  r1.resolve('x');
+
+  await eventLoopIteration();
+
+  t.deepEqual(log.dump(), [
+    // keep line break
+    ['doFulfill', v1, 'x'],
+    ['doFulfill', v1, 'x'], // this duplication is wrong, is the point
+  ]);
+};
+
+/**
+ * @param {any} t
+ * @param {Zone} zone
+ */
+const testProperStop = async (t, zone) => {
+  const vowTools = prepareVowTools(zone);
+  const { makeVowKit } = vowTools;
+  const makeLogStore = prepareLogStore(zone);
+  const makeBijection = prepareBijection(zone);
+
+  const log = makeLogStore();
+  const bij = makeBijection();
+
+  const memA = makeReplayMembrane(log, bij, vowTools, watchWake, panic);
+
+  const { vow: v1, resolver: r1 } = makeVowKit();
+
+  const p1A = memA.hostToGuest(v1);
+  t.true(bij.has(p1A, v1));
+
+  await eventLoopIteration();
+
+  t.deepEqual(log.dump(), []);
+
+  // do all the steps to drop an old membrane and set up a new membrane,
+  // including stopping the old membrane,
+  // to demonstate why `makeGuestForHostVow` also tests`stopped`.
+  log.reset();
+  bij.reset();
+  memA.stop(); // the point
+  const memB = makeReplayMembrane(log, bij, vowTools, watchWake, panic);
+
+  const p1B = memB.hostToGuest(v1);
+  t.true(bij.has(p1B, v1));
+  t.false(bij.hasGuest(p1A));
+
+  await eventLoopIteration();
+
+  t.deepEqual(log.dump(), []);
+
+  r1.resolve('x');
+
+  await eventLoopIteration();
+
+  t.deepEqual(log.dump(), [
+    // keep line break
+    ['doFulfill', v1, 'x'],
+  ]);
+};
+
+test.serial('test heap replay-membrane missing stop', async t => {
+  const zone = makeHeapZone('heapRoot');
+  return testMissingStop(t, zone);
+});
+
+test.serial('test heap replay-membrane proper stop', async t => {
+  annihilate();
+  const zone = makeHeapZone('heapRoot');
+  return testProperStop(t, zone);
+});
+
+test.serial('test virtual replay-membrane missing stop', async t => {
+  annihilate();
+  const zone = makeVirtualZone('virtualRoot');
+  return testMissingStop(t, zone);
+});
+
+test.serial('test virtual replay-membrane proper stop', async t => {
+  annihilate();
+  const zone = makeVirtualZone('virtualRoot');
+  return testProperStop(t, zone);
+});
+
+test.serial('test durable replay-membrane missing stop', async t => {
+  annihilate();
+  nextLife();
+  const zone = makeDurableZone(getBaggage(), 'durableRoot');
+  return testMissingStop(t, zone);
+});
+
+test.serial('test durable replay-membrane proper stop', async t => {
+  annihilate();
+  nextLife();
+  const zone = makeDurableZone(getBaggage(), 'durableRoot');
+  return testProperStop(t, zone);
+});

package/test/replay-membrane.test.js

@@ -0,0 +1,271 @@
+// eslint-disable-next-line import/order
+import {
+  test,
+  getBaggage,
+  annihilate,
+  nextLife,
+  asyncFlowVerbose,
+} from './prepare-test-env-ava.js';
+
+import { Fail } from '@endo/errors';
+import { isPromise } from '@endo/promise-kit';
+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 { prepareLogStore } from '../src/log-store.js';
+import { prepareBijection } from '../src/bijection.js';
+import { makeReplayMembrane } from '../src/replay-membrane.js';
+
+const watchWake = _vowish => {};
+const panic = problem => Fail`panic over ${problem}`;
+
+/**
+ * @param {Zone} zone
+ * @param {number} [k]
+ */
+const prepareOrchestra = (zone, k = 1) =>
+  zone.exoClass(
+    'Orchestra',
+    undefined,
+    (factor, vow, resolver) => ({ factor, vow, resolver }),
+    {
+      scale(n) {
+        const { state } = this;
+        return k * state.factor * n;
+      },
+      vow() {
+        const { state } = this;
+        return state.vow;
+      },
+      resolve(x) {
+        const { state } = this;
+        state.resolver.resolve(x);
+      },
+    },
+  );
+
+/**
+ * @param {any} t
+ * @param {Zone} zone
+ * @param {boolean} [showOnConsole]
+ */
+const testFirstPlay = async (t, zone, showOnConsole = false) => {
+  const vowTools = prepareVowTools(zone);
+  const { makeVowKit } = vowTools;
+  const makeLogStore = prepareLogStore(zone);
+  const makeBijection = prepareBijection(zone);
+  const makeOrchestra = prepareOrchestra(zone);
+  const { vow: v1, resolver: r1 } = makeVowKit();
+  const { vow: v2, resolver: r2 } = makeVowKit();
+
+  const log = zone.makeOnce('log', () => makeLogStore());
+  const bij = zone.makeOnce('bij', makeBijection);
+
+  const mem = makeReplayMembrane(log, bij, vowTools, watchWake, panic);
+
+  const g1 = mem.hostToGuest(v1);
+  t.true(isPromise(g1));
+  r1.resolve('x');
+  t.is(await g1, 'x');
+
+  const hOrch7 = makeOrchestra(7, v2, r2);
+  t.false(bij.hasHost(hOrch7));
+  const gOrch7 = mem.hostToGuest(hOrch7);
+  t.true(bij.has(gOrch7, hOrch7));
+
+  const prod = gOrch7.scale(3);
+  t.is(prod, 21);
+
+  let gErr;
+  try {
+    gOrch7.scale(9n);
+  } catch (e) {
+    gErr = e;
+  }
+
+  // TODO make E work across the membrane *well*
+  // TODO also try E on remote promise
+  // const prodP = E(gOrch7).scale(33);
+  // t.is(await prodP, 231);
+  // const badP = E(gOrch7).scale(99n);
+  // let gErr1;
+  // try {
+  //   await badP;
+  // } catch (e) {
+  //   gErr1 = e;
+  // }
+  // t.is(gErr1.name, 'TypeError');
+
+  t.deepEqual(log.dump(), [
+    ['doFulfill', v1, 'x'],
+    ['checkCall', hOrch7, 'scale', [3], 1],
+    ['doReturn', 1, 21],
+    ['checkCall', hOrch7, 'scale', [9n], 3],
+    ['doThrow', 3, mem.guestToHost(gErr)],
+  ]);
+
+  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('gErr', gErr);
+  }
+};
+
+/**
+ * @param {any} t
+ * @param {Zone} zone
+ */
+const testBadReplay = async (t, zone) => {
+  const vowTools = prepareVowTools(zone);
+  prepareLogStore(zone);
+  prepareBijection(zone);
+  prepareOrchestra(zone);
+
+  const log = /** @type {LogStore} */ (
+    zone.makeOnce('log', () => Fail`need log`)
+  );
+  const bij = /** @type {Bijection} */ (
+    zone.makeOnce('bij', () => Fail`need bij`)
+  );
+
+  const dump = log.dump();
+  const v1 = dump[0][1];
+  const hOrch7 = dump[1][1];
+  const hErr = dump[4][2];
+
+  t.false(bij.hasHost(hOrch7));
+
+  t.deepEqual(dump, [
+    ['doFulfill', v1, 'x'],
+    ['checkCall', hOrch7, 'scale', [3], 1],
+    ['doReturn', 1, 21],
+    ['checkCall', hOrch7, 'scale', [9n], 3],
+    ['doThrow', 3, hErr],
+  ]);
+
+  const mem = makeReplayMembrane(log, bij, vowTools, watchWake, panic);
+
+  const g1 = mem.hostToGuest(v1);
+  mem.wake();
+  t.is(await g1, 'x');
+  const gOrch7 = mem.hostToGuest(hOrch7);
+  t.true(bij.has(gOrch7, hOrch7));
+
+  // failure of guest to reproduce behavior from previous incarnations
+  t.throws(() => gOrch7.scale(4), {
+    message: /^panic over "\[Error: replay/,
+  });
+};
+
+/**
+ * @param {any} t
+ * @param {Zone} zone
+ */
+const testGoodReplay = async (t, zone) => {
+  const vowTools = prepareVowTools(zone);
+  prepareLogStore(zone);
+  prepareBijection(zone);
+  prepareOrchestra(zone, 2); // 2 is new incarnation behavior change
+
+  const log = /** @type {LogStore} */ (
+    zone.makeOnce('log', () => Fail`need log`)
+  );
+  const bij = /** @type {Bijection} */ (
+    zone.makeOnce('bij', () => Fail`need bij`)
+  );
+
+  const dump = log.dump();
+  const v1 = dump[0][1];
+  const hOrch7 = dump[1][1];
+  const hErr = dump[4][2];
+
+  t.false(bij.hasHost(hOrch7));
+
+  t.deepEqual(dump, [
+    ['doFulfill', v1, 'x'],
+    ['checkCall', hOrch7, 'scale', [3], 1],
+    ['doReturn', 1, 21],
+    ['checkCall', hOrch7, 'scale', [9n], 3],
+    ['doThrow', 3, hErr],
+  ]);
+
+  const oldLogLen = dump.length;
+
+  const mem = makeReplayMembrane(log, bij, vowTools, watchWake, panic);
+
+  const g1 = mem.hostToGuest(v1);
+  mem.wake();
+  t.is(await g1, 'x');
+  const gOrch7 = mem.hostToGuest(hOrch7);
+  t.true(bij.has(gOrch7, hOrch7));
+
+  // replay
+  const prodA = gOrch7.scale(3);
+  t.is(prodA, 21); // According to log of earlier incarnations
+  // let gErr;
+  try {
+    gOrch7.scale(9n);
+  } catch (e) {
+    // gErr = e;
+  }
+
+  // new play
+  const prodB = gOrch7.scale(3);
+  t.is(prodB, 42); // According to new incarnation behavior
+
+  const g2 = gOrch7.vow();
+  const h2 = mem.guestToHost(g2);
+  t.true(isPromise(g2));
+  const pairA = [gOrch7, g1];
+  gOrch7.resolve(pairA);
+  const pairB = await g2;
+  const [gOrchB, gB] = pairB;
+  t.not(pairB, pairA);
+  t.is(gOrchB, gOrch7);
+  t.is(gB, g1);
+
+  t.deepEqual(log.dump(), [
+    ['doFulfill', v1, 'x'],
+    ['checkCall', hOrch7, 'scale', [3], 1],
+    ['doReturn', 1, 21],
+    ['checkCall', hOrch7, 'scale', [9n], 3],
+    ['doThrow', 3, hErr],
+
+    ['checkCall', hOrch7, 'scale', [3], oldLogLen],
+    ['doReturn', oldLogLen, 42],
+    ['checkCall', hOrch7, 'vow', [], oldLogLen + 2],
+    ['doReturn', oldLogLen + 2, h2],
+    ['checkCall', hOrch7, 'resolve', [[hOrch7, v1]], oldLogLen + 4],
+    ['doReturn', oldLogLen + 4, undefined],
+    ['doFulfill', h2, [hOrch7, v1]],
+  ]);
+};
+
+test.serial('test heap replay-membrane', async t => {
+  const zone = makeHeapZone('heapRoot');
+  return testFirstPlay(t, zone, asyncFlowVerbose());
+});
+
+test.serial('test virtual replay-membrane', async t => {
+  annihilate();
+  const zone = makeVirtualZone('virtualRoot');
+  return testFirstPlay(t, zone);
+});
+
+test.serial('test durable replay-membrane', async t => {
+  annihilate();
+
+  nextLife();
+  const zone1 = makeDurableZone(getBaggage(), 'durableRoot');
+  await testFirstPlay(t, zone1);
+
+  nextLife();
+  const zone2 = makeDurableZone(getBaggage(), 'durableRoot');
+  await testBadReplay(t, zone2);
+
+  nextLife();
+  const zone3 = makeDurableZone(getBaggage(), 'durableRoot');
+  return testGoodReplay(t, zone3);
+});

package/tsconfig.build.json

@@ -0,0 +1,11 @@
+{
+    "extends": [
+        "./tsconfig.json",
+        "../../tsconfig-build-options.json"
+    ],
+    "exclude": [
+        "scripts",
+        "test",
+        "**/exports.js",
+    ]
+}

package/tsconfig.json

@@ -0,0 +1,13 @@
+// This file can contain .js-specific Typescript compiler config.
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "maxNodeModuleJsDepth": 2,
+  },
+  "include": [
+    "*.js",
+    "scripts",
+    "src/**/*.js",
+    "test/**/*.js",
+  ],
+}

package/typedoc.json

@@ -0,0 +1,8 @@
+{
+    "extends": [
+        "../../typedoc.base.json"
+    ],
+    "entryPoints": [
+        "index.js",
+    ]
+}