@agoric/internal 0.3.3-dev-cbcea8c.0.cbcea8c → 0.3.3-dev-04baeed.0.04baeed

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agoric/internal",
-  "version": "0.3.3-dev-cbcea8c.0.cbcea8c",
+  "version": "0.3.3-dev-04baeed.0.04baeed",
   "description": "Externally unsupported utilities internal to agoric-sdk",
   "repository": {
     "type": "git",
@@ -24,7 +24,7 @@
     "lint:types": "yarn run -T tsgo --tsBuildInfoFile tsconfig.tsgo.tsbuildinfo"
   },
   "dependencies": {
-    "@agoric/base-zone": "0.1.1-dev-cbcea8c.0.cbcea8c",
+    "@agoric/base-zone": "0.1.1-dev-04baeed.0.04baeed",
     "@endo/cache-map": "^1.1.0",
     "@endo/common": "^1.4.0",
     "@endo/compartment-mapper": "^2.3.0",
@@ -42,7 +42,7 @@
     "jessie.js": "^0.3.4"
   },
   "devDependencies": {
-    "@agoric/cosmic-proto": "0.4.1-dev-cbcea8c.0.cbcea8c",
+    "@agoric/cosmic-proto": "0.4.1-dev-04baeed.0.04baeed",
     "@endo/exo": "^1.7.0",
     "@endo/init": "^1.1.13",
     "@endo/ses-ava": "^1.4.2",
@@ -70,5 +70,5 @@
   "typeCoverage": {
     "atLeast": 92.84
   },
-  "gitHead": "cbcea8c2415f2c9c4bc1ea9ff90730f2773bafaa"
+  "gitHead": "04baeedd0adc9b2480dd9d272e8daffebc408662"
 }

package/src/testing-utils.d.ts

@@ -14,7 +14,10 @@
  */
 export const eventLoopIteration: () => Promise<void>;
 export function inspectMapStore(store: MapStore): object;
-export function testInterruptedSteps<Input = any, Context = unknown>(t: AvaT<Context>, allSteps: readonly TestStep<Input>[], doInterrupt?: (t: AvaT<Context>) => ERef<void>): Promise<void>;
+export function testInterruptedSteps<Input = any, Context = unknown>(t: AvaT<Context>, allSteps: readonly TestStep<Input>[], doInterrupt?: (t: AvaT<Context>) => ERef<void>, { setup, postcondition }?: {
+    setup?: ((t: AvaT<Context>) => Partial<Input> | PromiseLike<Partial<Input>>) | undefined;
+    postcondition?: ((t: AvaT<Context>, accum: Partial<Input>, label: string) => ERef<void>) | undefined;
+}): Promise<void>;
 export type TestStep<Input = any> = readonly [stepName: string, fn: (input: Partial<Input>, label: string) => Partial<Input> | PromiseLike<Partial<Input>>];
 import type { MapStore } from '@agoric/store';
 import type { ExecutionContext as AvaT } from 'ava';

package/src/testing-utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"testing-utils.d.ts","sourceRoot":"","sources":["testing-utils.js"],"names":[],"mappings":"AACA;;;;GAIG;AAEH;;;;;;;;GAQG;AACH,iCAFU,MAAM,OAAO,CAAC,IAAI,CAAC,CAGmB;AAgBzC,uCAHI,QAAQ,GACN,MAAM,CAsBlB;AAqBM,qCANO,KAAK,QACL,OAAO,eACV,KAAK,OAAO,CAAC,YACb,SAAS,QAAQ,CAAC,KAAK,CAAC,EAAE,gBAC1B,CAAC,CAAC,EAAE,KAAK,OAAO,CAAC,KAAK,KAAK,IAAI,CAAC,iBA8D1C;qBA7Ea,KAAK,UACN,SAAS,CACjB,QAAQ,EAAE,MAAM,EAChB,EAAE,EAAE,CAAC,KAAK,EAAE,OAAO,CAAC,KAAK,CAAC,EAAE,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC,KAAK,CAAC,GAAG,WAAW,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAC3F;8BA3DuB,eAAe;8CACC,KAAK;0BACzB,qBAAqB"}
+{"version":3,"file":"testing-utils.d.ts","sourceRoot":"","sources":["testing-utils.js"],"names":[],"mappings":"AACA;;;;GAIG;AAEH;;;;;;;;GAQG;AACH,iCAFU,MAAM,OAAO,CAAC,IAAI,CAAC,CAGmB;AAgBzC,uCAHI,QAAQ,GACN,MAAM,CAsBlB;AAwCM,qCAjBO,KAAK,QACL,OAAO,eACV,KAAK,OAAO,CAAC,YACb,SAAS,QAAQ,CAAC,KAAK,CAAC,EAAE,gBAC1B,CAAC,CAAC,EAAE,KAAK,OAAO,CAAC,KAAK,KAAK,IAAI,CAAC,6BAExC;IAAqF,KAAK,QAA9E,KAAK,OAAO,CAAC,KAAK,OAAO,CAAC,KAAK,CAAC,GAAG,WAAW,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;IAMe,aAAa,QAA1F,KAAK,OAAO,CAAC,SAAS,OAAO,CAAC,KAAK,CAAC,SAAS,MAAM,KAAK,KAAK,IAAI,CAAC;CAIhF,iBAoFA;qBAvHa,KAAK,UACN,SAAS,CACjB,QAAQ,EAAE,MAAM,EAChB,EAAE,EAAE,CAAC,KAAK,EAAE,OAAO,CAAC,KAAK,CAAC,EAAE,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC,KAAK,CAAC,GAAG,WAAW,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAC3F;8BA3DuB,eAAe;8CACC,KAAK;0BACzB,qBAAqB"}

package/src/testing-utils.js

@@ -66,13 +66,37 @@ harden(inspectMapStore);
  * For each step, run to just before that point and pause for continuation after
  * interrupt.
  *
+ * `allSteps` should contain only steps that are meaningful interruption
+ * boundaries — i.e. that leave durable in-flight state whose recovery across an
+ * interrupt is worth asserting. Each step in `allSteps` runs `allSteps.length +
+ * 2` times, so the total work is quadratic in the number of steps; keep the
+ * list to the genuinely mutating steps. Use `options.setup` for non-mutating
+ * fixtures and `options.postcondition` for non-mutating outcome assertions so
+ * they don't inflate the boundary count.
+ *
  * @template [Input=any]
  * @template [Context=unknown]
  * @param {AvaT<Context>} t
  * @param {readonly TestStep<Input>[]} allSteps
  * @param {(t: AvaT<Context>) => ERef<void>} [doInterrupt]
+ * @param {object} [options]
+ * @param {(t: AvaT<Context>) => Partial<Input> | PromiseLike<Partial<Input>>} [options.setup]
+ *   Produce the initial accumulator at the start of each run. Runs are never
+ *   interrupted around setup, so use it for fixtures (e.g. funding a wallet)
+ *   that are not themselves part of the interruption-resilience contract. It is
+ *   invoked once per run, so it may create per-run state (e.g. a single-use
+ *   actor) safely.
+ * @param {(t: AvaT<Context>, accum: Partial<Input>, label: string) => ERef<void>} [options.postcondition]
+ *   Assert the outcome after each run that completes all of its steps (the
+ *   pre-interrupt run, the post-interrupt run, and each resumed run). Use for
+ *   non-mutating outcome checks that need not be interruption boundaries.
  */
-export const testInterruptedSteps = async (t, allSteps, doInterrupt) => {
+export const testInterruptedSteps = async (
+  t,
+  allSteps,
+  doInterrupt,
+  { setup, postcondition } = {},
+) => {
   /**
    * @typedef {{
    *   label: string;
@@ -80,16 +104,20 @@ export const testInterruptedSteps = async (t, allSteps, doInterrupt) => {
    * }} RunState
    */
 
+  /** @returns {Promise<Partial<Input>>} */
+  const freshAccum = async () => (setup ? setup(t) : {});
+
   /**
    * @param {string} label
    * @param {readonly TestStep<Input>[]} steps
-   * @param {RunState} [runState]
+   * @param {RunState} [runState] when omitted, a fresh run is started, seeding
+   *   the accumulator from `setup`.
    * @returns {Promise<RunState>}
    */
-  const runSteps = async (label, steps, runState = { label, accum: {} }) => {
+  const runSteps = async (label, steps, runState) => {
     await null;
-    let accum = runState.accum;
-    const runLabel = runState.label;
+    let accum = runState ? runState.accum : await freshAccum();
+    const runLabel = runState ? runState.label : label;
     for (const [stepName, fn] of steps) {
       await t.notThrowsAsync(async () => {
         accum = await fn(accum, runLabel);
@@ -98,8 +126,20 @@ export const testInterruptedSteps = async (t, allSteps, doInterrupt) => {
     return { label: runLabel, accum };
   };
 
+  /**
+   * @param {RunState} runState
+   * @returns {Promise<RunState>}
+   */
+  const complete = async runState => {
+    await null;
+    if (postcondition) {
+      await postcondition(t, runState.accum, runState.label);
+    }
+    return runState;
+  };
+
   // Sanity check
-  await runSteps('pre-interrupt', allSteps);
+  await complete(await runSteps('pre-interrupt', allSteps));
   if (!doInterrupt) {
     return;
   }
@@ -116,7 +156,7 @@ export const testInterruptedSteps = async (t, allSteps, doInterrupt) => {
     const runState = await runSteps(
       `pre-${beforeStepName}`,
       allSteps.slice(0, i),
-      { label: `pause-before-${beforeStepName}`, accum: {} },
+      { label: `pause-before-${beforeStepName}`, accum: await freshAccum() },
     );
     pausedRuns.push({ runState, remainingSteps: allSteps.slice(i) });
   }
@@ -125,12 +165,14 @@ export const testInterruptedSteps = async (t, allSteps, doInterrupt) => {
   await doInterrupt(t);
 
   // Verify a complete run post-interrupt.
-  await runSteps('post-interrupt', allSteps);
+  await complete(await runSteps('post-interrupt', allSteps));
 
   // Verify completion of each paused step.
   for (const { runState, remainingSteps } of pausedRuns) {
     const [beforeStepName] = remainingSteps[0];
-    await runSteps(`resumed-${beforeStepName}`, remainingSteps, runState);
+    await complete(
+      await runSteps(`resumed-${beforeStepName}`, remainingSteps, runState),
+    );
   }
 };
 harden(testInterruptedSteps);