@agoric/swing-store 0.9.2-dev-bf1e645.0 → 0.9.2-dev-07f6885.0

package/test/deletion.test.js

@@ -1,11 +1,16 @@
 // @ts-check
 import test from 'ava';
-import path from 'path';
 
 import { Buffer } from 'node:buffer';
+import path from 'node:path';
+import fs from 'node:fs';
+import zlib from 'node:zlib';
 import sqlite3 from 'better-sqlite3';
+import tmp from 'tmp';
+import { arrayIsLike } from '@agoric/internal/tools/ava-assertions.js';
 import { tmpDir } from './util.js';
 import { initSwingStore } from '../src/swingStore.js';
+import { makeArchiveSnapshot, makeArchiveTranscript } from '../src/archiver.js';
 import { makeSwingStoreExporter } from '../src/exporter.js';
 import { importSwingStore } from '../src/importer.js';
 
@@ -50,32 +55,31 @@ test('delete snapshots with export callback', async t => {
 
   await commit();
 
-  t.is(exportLog.length, 4);
-  t.is(exportLog[0][0], 'snapshot.v1.10');
-  t.is(exportLog[1][0], 'snapshot.v1.11');
-  t.is(exportLog[2][0], 'snapshot.v1.12');
-  t.is(exportLog[3][0], 'snapshot.v1.current');
   const hash = JSON.parse(exportLog[0][1]).hash;
+  arrayIsLike(t, exportLog.splice(0), [
+    ['snapshot.v1.10'],
+    ['snapshot.v1.11'],
+    ['snapshot.v1.12'],
+    ['snapshot.v1.current'],
+  ]);
   t.deepEqual(exportData, {
     'snapshot.v1.10': JSON.stringify({ vatID, snapPos: 10, hash, inUse: 0 }),
     'snapshot.v1.11': JSON.stringify({ vatID, snapPos: 11, hash, inUse: 0 }),
     'snapshot.v1.12': JSON.stringify({ vatID, snapPos: 12, hash, inUse: 1 }),
     'snapshot.v1.current': 'snapshot.v1.12',
   });
-  exportLog.length = 0;
 
   // in a previous version, deleteVatSnapshots caused overlapping SQL
   // queries, and failed
   snapStore.deleteVatSnapshots(vatID);
   await commit();
 
-  t.deepEqual(exportLog, [
+  t.deepEqual(exportLog.splice(0), [
     ['snapshot.v1.10', null],
     ['snapshot.v1.11', null],
     ['snapshot.v1.12', null],
     ['snapshot.v1.current', null],
   ]);
-  exportLog.length = 0;
   t.deepEqual(exportData, {});
 });
 
@@ -95,7 +99,7 @@ test('delete transcripts with export callback', async t => {
   transcriptStore.addItem('v1', 'aaa');
   transcriptStore.addItem('v1', 'bbb');
   transcriptStore.addItem('v1', 'ccc');
-  transcriptStore.rolloverSpan('v1');
+  await transcriptStore.rolloverSpan('v1');
   transcriptStore.addItem('v1', 'ddd');
   transcriptStore.addItem('v1', 'eee');
   transcriptStore.addItem('v1', 'fff');
@@ -104,22 +108,20 @@ test('delete transcripts with export callback', async t => {
 
   await commit();
 
-  t.is(exportLog.length, 2);
-  t.is(exportLog[0][0], 'transcript.v1.0');
-  t.is(exportLog[1][0], 'transcript.v1.current');
-  exportLog.length = 0;
+  arrayIsLike(t, exportLog.splice(0), [
+    ['transcript.v1.0'],
+    ['transcript.v1.current'],
+  ]);
 
   // in a previous version, deleteVatTranscripts caused overlapping SQL
   // queries, and failed
   transcriptStore.deleteVatTranscripts('v1');
   await commit();
 
-  t.deepEqual(exportLog, [
+  t.deepEqual(exportLog.splice(0), [
     ['transcript.v1.0', null],
     ['transcript.v1.current', null],
   ]);
-
-  exportLog.length = 0;
 });
 
 const getExport = async (dbDir, artifactMode) => {
@@ -145,16 +147,20 @@ const reImport = async (t, dbDir, artifactMode) => {
   return sqlite3(path.join(dbDir2, 'swingstore.sqlite'));
 };
 
-const compareNoHash = (t, obj1, obj2) => {
-  const o1 = {};
-  for (const [key, value] of Object.entries(obj1)) {
+const stripHashes = exportData => {
+  const stripped = {};
+  const entries =
+    exportData instanceof Map
+      ? exportData.entries()
+      : Object.entries(exportData);
+  for (const [key, value] of entries) {
     const { hash: _, ...data } = JSON.parse(value);
-    o1[key] = data;
+    stripped[key] = data;
   }
-  return t.deepEqual(o1, obj2);
+  return stripped;
 };
 
-const setupTranscript = async t => {
+const setupTranscript = async (t, keepTranscripts) => {
   const vatID = 'v1';
   const exportLog = [];
   const currentExportData = {};
@@ -166,7 +172,17 @@ const setupTranscript = async t => {
   };
   const [dbDir, cleanup] = await tmpDir('testdb');
   t.teardown(cleanup);
-  const store = initSwingStore(dbDir, { exportCallback });
+  const [archiveDir, cleanupArchives] = await tmpDir('archives');
+  t.teardown(cleanupArchives);
+  const fsPowers = { fs, path, tmp };
+  const archiveSnapshot = makeArchiveSnapshot(archiveDir, fsPowers);
+  const archiveTranscript = makeArchiveTranscript(archiveDir, fsPowers);
+  const store = initSwingStore(dbDir, {
+    exportCallback,
+    keepTranscripts,
+    archiveSnapshot,
+    archiveTranscript,
+  });
   const { kernelStorage, hostStorage } = store;
   const { transcriptStore } = kernelStorage;
   const { commit } = hostStorage;
@@ -177,13 +193,13 @@ const setupTranscript = async t => {
   transcriptStore.initTranscript(vatID);
   transcriptStore.addItem(vatID, 'aaa');
   transcriptStore.addItem(vatID, 'bbb');
-  transcriptStore.rolloverSpan(vatID);
+  await transcriptStore.rolloverSpan(vatID);
   transcriptStore.addItem(vatID, 'ccc');
   transcriptStore.addItem(vatID, 'ddd');
-  transcriptStore.rolloverIncarnation(vatID);
+  await transcriptStore.rolloverIncarnation(vatID);
   transcriptStore.addItem(vatID, 'eee');
   transcriptStore.addItem(vatID, 'fff');
-  transcriptStore.rolloverSpan(vatID);
+  await transcriptStore.rolloverSpan(vatID);
   transcriptStore.addItem(vatID, 'ggg');
   transcriptStore.addItem(vatID, 'hhh');
   await commit();
@@ -191,6 +207,7 @@ const setupTranscript = async t => {
   return {
     db,
     dbDir,
+    archiveDir,
     commit,
     transcriptStore,
     exportLog,
@@ -199,74 +216,93 @@ const setupTranscript = async t => {
   };
 };
 
-test('slow deletion of transcripts', async t => {
+/**
+ * @param {import('ava').ExecutionContext} t
+ * @param {{ keepTranscripts: boolean }} config
+ */
+const execSlowTranscriptDeletion = async (t, { keepTranscripts }) => {
   // slow transcript deletion should remove export-data as it removes
   // transcript spans and their items
 
   const {
     db,
     dbDir,
+    archiveDir,
     commit,
     transcriptStore,
     exportLog,
     currentExportData,
     vatID,
-  } = await setupTranscript(t);
-
-  t.is(exportLog.length, 4);
-  t.is(exportLog[0][0], 'transcript.v1.0');
-  t.is(exportLog[1][0], 'transcript.v1.2');
-  t.is(exportLog[2][0], 'transcript.v1.4');
-  t.is(exportLog[3][0], 'transcript.v1.current');
-  exportLog.length = 0;
+  } = await setupTranscript(t, keepTranscripts);
+
+  arrayIsLike(t, exportLog.splice(0), [
+    ['transcript.v1.0'],
+    ['transcript.v1.2'],
+    ['transcript.v1.4'],
+    ['transcript.v1.current'],
+  ]);
   const t0 = { vatID, startPos: 0, endPos: 2, isCurrent: 0, incarnation: 0 };
   const t2 = { vatID, startPos: 2, endPos: 4, isCurrent: 0, incarnation: 0 };
   const t4 = { vatID, startPos: 4, endPos: 6, isCurrent: 0, incarnation: 1 };
-  const tc = { vatID, startPos: 6, endPos: 8, isCurrent: 1, incarnation: 1 };
   const t6 = { vatID, startPos: 6, endPos: 8, isCurrent: 0, incarnation: 1 };
-  compareNoHash(t, currentExportData, {
+  const expectedLiveExportData = {
     'transcript.v1.0': t0,
     'transcript.v1.2': t2,
     'transcript.v1.4': t4,
-    'transcript.v1.current': tc,
-  });
+    'transcript.v1.current': { ...t6, isCurrent: 1 },
+  };
+  const expectedStoppedExportData = {
+    'transcript.v1.0': t0,
+    'transcript.v1.2': t2,
+    'transcript.v1.4': t4,
+    'transcript.v1.6': t6,
+  };
+  const expectedArtifactContents = {
+    'transcript.v1.0.2': 'aaa\nbbb\n',
+    'transcript.v1.2.4': 'ccc\nddd\n',
+    'transcript.v1.4.6': 'eee\nfff\n',
+    'transcript.v1.6.8': 'ggg\nhhh\n',
+  };
+  const expectedArtifactNames = Object.keys(expectedArtifactContents);
 
-  t.is(db.prepare('SELECT COUNT(*) FROM transcriptItems').pluck().get(), 8);
+  t.deepEqual(stripHashes(currentExportData), expectedLiveExportData);
+  t.is(
+    db.prepare('SELECT COUNT(*) FROM transcriptItems').pluck().get(),
+    keepTranscripts ? 8 : 2,
+  );
   t.is(db.prepare('SELECT COUNT(*) FROM transcriptSpans').pluck().get(), 4);
 
+  // verify archived transcripts
+  t.deepEqual(
+    fs.readdirSync(archiveDir),
+    expectedArtifactNames.slice(0, -1).map(name => `${name}.gz`),
+  );
+  for (const name of expectedArtifactNames.slice(0, -1)) {
+    const filePath = path.join(archiveDir, `${name}.gz`);
+    const contents = zlib.gunzipSync(fs.readFileSync(filePath)).toString();
+    t.is(contents, expectedArtifactContents[name], `${filePath} contents`);
+  }
+
   // an "operational"-mode export should list all spans, but only have
   // artifacts for the current one
   {
     const { exportData, artifactNames } = await getExport(dbDir, 'operational');
     t.deepEqual(currentExportData, mapToObj(exportData));
-    compareNoHash(t, mapToObj(exportData), {
-      'transcript.v1.0': t0,
-      'transcript.v1.2': t2,
-      'transcript.v1.4': t4,
-      'transcript.v1.current': tc,
-    });
-    t.deepEqual(artifactNames, ['transcript.v1.6.8']);
+    t.deepEqual(stripHashes(exportData), expectedLiveExportData);
+    t.deepEqual(artifactNames, expectedArtifactNames.slice(-1));
     const db2 = await reImport(t, dbDir, 'operational');
     t.is(db2.prepare('SELECT COUNT(*) FROM transcriptItems').pluck().get(), 2);
     t.is(db2.prepare('SELECT COUNT(*) FROM transcriptSpans').pluck().get(), 4);
   }
 
-  // an "archival"-mode export should list all four spans, with
-  // artifacts for each
-  {
+  // an "archival"-mode export should list all four spans with
+  // artifacts for each, but is only available with keepTranscripts=true
+  if (!keepTranscripts) {
+    await t.throwsAsync(getExport(dbDir, 'archival'));
+  } else {
     const { exportData, artifactNames } = await getExport(dbDir, 'archival');
-    compareNoHash(t, mapToObj(exportData), {
-      'transcript.v1.0': t0,
-      'transcript.v1.2': t2,
-      'transcript.v1.4': t4,
-      'transcript.v1.current': tc,
-    });
-    t.deepEqual(artifactNames, [
-      'transcript.v1.0.2',
-      'transcript.v1.2.4',
-      'transcript.v1.4.6',
-      'transcript.v1.6.8',
-    ]);
+    t.deepEqual(stripHashes(exportData), expectedLiveExportData);
+    t.deepEqual(artifactNames, expectedArtifactNames);
     const db2 = await reImport(t, dbDir, 'archival');
     t.is(db2.prepare('SELECT COUNT(*) FROM transcriptItems').pluck().get(), 8);
     t.is(db2.prepare('SELECT COUNT(*) FROM transcriptSpans').pluck().get(), 4);
@@ -276,60 +312,60 @@ test('slow deletion of transcripts', async t => {
   // deletes the .current record (i.e. it transforms .current into a
   // closed record)
   {
-    transcriptStore.stopUsingTranscript(vatID);
+    await transcriptStore.stopUsingTranscript(vatID);
     await commit();
-    compareNoHash(t, currentExportData, {
-      'transcript.v1.0': t0,
-      'transcript.v1.2': t2,
-      'transcript.v1.4': t4,
-      'transcript.v1.6': t6,
-    });
+    t.deepEqual(stripHashes(currentExportData), expectedStoppedExportData);
     exportLog.length = 0;
     // stopUsingTranscript is idempotent
-    transcriptStore.stopUsingTranscript(vatID);
+    await transcriptStore.stopUsingTranscript(vatID);
     await commit();
-    t.is(exportLog.length, 0);
+    t.deepEqual(exportLog, []);
+  }
+  t.deepEqual(
+    fs.readdirSync(archiveDir),
+    expectedArtifactNames.map(name => `${name}.gz`),
+  );
+  for (const name of expectedArtifactNames) {
+    const filePath = path.join(archiveDir, `${name}.gz`);
+    const contents = zlib.gunzipSync(fs.readFileSync(filePath)).toString();
+    t.is(contents, expectedArtifactContents[name], `${filePath} contents`);
   }
 
   // All exports (debug and non-debug) in this "terminated but not
   // deleted" state will still have the export-data keys. Only
-  // debug-mode will have artifacts.
+  // debug-mode will have artifacts (and only with keepTranscripts=true).
   for (const mode of ['operational', 'replay', 'archival', 'debug']) {
     const { exportData, artifactNames } = await getExport(dbDir, mode);
-    compareNoHash(t, mapToObj(exportData), {
-      'transcript.v1.0': t0,
-      'transcript.v1.2': t2,
-      'transcript.v1.4': t4,
-      'transcript.v1.6': t6,
-    });
-    if (mode === 'debug') {
-      t.deepEqual(artifactNames, [
-        'transcript.v1.0.2',
-        'transcript.v1.2.4',
-        'transcript.v1.4.6',
-        'transcript.v1.6.8',
-      ]);
-    } else {
-      t.deepEqual(artifactNames, []);
-    }
+    t.deepEqual(
+      stripHashes(exportData),
+      expectedStoppedExportData,
+      `${mode} stopped-vat export data`,
+    );
+    t.deepEqual(
+      artifactNames,
+      mode === 'debug' && keepTranscripts ? expectedArtifactNames : [],
+      `${mode} stopped-vat export artifacts`,
+    );
     const db2 = await reImport(t, dbDir, 'operational');
     t.is(db2.prepare('SELECT COUNT(*) FROM transcriptItems').pluck().get(), 0);
     t.is(db2.prepare('SELECT COUNT(*) FROM transcriptSpans').pluck().get(), 4);
   }
 
   // first deletion
+  const expectedTruncatedExportData1 = Object.fromEntries(
+    Object.entries(expectedStoppedExportData).slice(0, -1),
+  );
   {
     // budget=1 will let it delete one span, the last one
     const dc = transcriptStore.deleteVatTranscripts(vatID, 1);
     t.false(dc.done);
     t.is(dc.cleanups, 1);
     await commit();
-    compareNoHash(t, currentExportData, {
-      'transcript.v1.0': t0,
-      'transcript.v1.2': t2,
-      'transcript.v1.4': t4,
-    });
-    t.is(db.prepare('SELECT COUNT(*) FROM transcriptItems').pluck().get(), 6);
+    t.deepEqual(stripHashes(currentExportData), expectedTruncatedExportData1);
+    t.is(
+      db.prepare('SELECT COUNT(*) FROM transcriptItems').pluck().get(),
+      keepTranscripts ? 6 : 0,
+    );
     t.is(db.prepare('SELECT COUNT(*) FROM transcriptSpans').pluck().get(), 3);
   }
 
@@ -341,50 +377,53 @@ test('slow deletion of transcripts', async t => {
 
   for (const mode of ['operational', 'replay', 'archival', 'debug']) {
     const { exportData, artifactNames } = await getExport(dbDir, mode);
-    compareNoHash(t, mapToObj(exportData), {
-      'transcript.v1.0': t0,
-      'transcript.v1.2': t2,
-      'transcript.v1.4': t4,
-    });
-    if (mode === 'debug') {
-      t.deepEqual(artifactNames, [
-        'transcript.v1.0.2',
-        'transcript.v1.2.4',
-        'transcript.v1.4.6',
-      ]);
-    } else {
-      t.deepEqual(artifactNames, []);
-    }
+    t.deepEqual(
+      stripHashes(exportData),
+      expectedTruncatedExportData1,
+      `${mode} first-deletion export data`,
+    );
+    t.deepEqual(
+      artifactNames,
+      mode === 'debug' && keepTranscripts
+        ? expectedArtifactNames.slice(0, -1)
+        : [],
+      `${mode} first-deletion export artifacts`,
+    );
     const db2 = await reImport(t, dbDir, 'operational');
     t.is(db2.prepare('SELECT COUNT(*) FROM transcriptItems').pluck().get(), 0);
     t.is(db2.prepare('SELECT COUNT(*) FROM transcriptSpans').pluck().get(), 3);
   }
 
   // second deletion
+  const expectedTruncatedExportData2 = Object.fromEntries(
+    Object.entries(expectedStoppedExportData).slice(0, -2),
+  );
   {
     const dc = transcriptStore.deleteVatTranscripts(vatID, 1);
     t.false(dc.done);
     t.is(dc.cleanups, 1);
     await commit();
-    compareNoHash(t, currentExportData, {
-      'transcript.v1.0': t0,
-      'transcript.v1.2': t2,
-    });
-    t.is(db.prepare('SELECT COUNT(*) FROM transcriptItems').pluck().get(), 4);
+    t.deepEqual(stripHashes(currentExportData), expectedTruncatedExportData2);
+    t.is(
+      db.prepare('SELECT COUNT(*) FROM transcriptItems').pluck().get(),
+      keepTranscripts ? 4 : 0,
+    );
     t.is(db.prepare('SELECT COUNT(*) FROM transcriptSpans').pluck().get(), 2);
   }
-
   for (const mode of ['operational', 'replay', 'archival', 'debug']) {
     const { exportData, artifactNames } = await getExport(dbDir, mode);
-    compareNoHash(t, mapToObj(exportData), {
-      'transcript.v1.0': t0,
-      'transcript.v1.2': t2,
-    });
-    if (mode === 'debug') {
-      t.deepEqual(artifactNames, ['transcript.v1.0.2', 'transcript.v1.2.4']);
-    } else {
-      t.deepEqual(artifactNames, []);
-    }
+    t.deepEqual(
+      stripHashes(exportData),
+      expectedTruncatedExportData2,
+      `${mode} second-deletion export data`,
+    );
+    t.deepEqual(
+      artifactNames,
+      mode === 'debug' && keepTranscripts
+        ? expectedArtifactNames.slice(0, -2)
+        : [],
+      `${mode} second-deletion export artifacts`,
+    );
     const db2 = await reImport(t, dbDir, 'operational');
     t.is(db2.prepare('SELECT COUNT(*) FROM transcriptItems').pluck().get(), 0);
     t.is(db2.prepare('SELECT COUNT(*) FROM transcriptSpans').pluck().get(), 2);
@@ -396,15 +435,18 @@ test('slow deletion of transcripts', async t => {
     t.true(dc.done);
     t.is(dc.cleanups, 2);
     await commit();
-    compareNoHash(t, currentExportData, {});
+    t.deepEqual(stripHashes(currentExportData), {});
     t.is(db.prepare('SELECT COUNT(*) FROM transcriptItems').pluck().get(), 0);
     t.is(db.prepare('SELECT COUNT(*) FROM transcriptSpans').pluck().get(), 0);
   }
-
   for (const mode of ['operational', 'replay', 'archival', 'debug']) {
     const { exportData, artifactNames } = await getExport(dbDir, mode);
-    compareNoHash(t, mapToObj(exportData), {});
-    t.deepEqual(artifactNames, []);
+    t.deepEqual(
+      stripHashes(exportData),
+      {},
+      `${mode} final-deletion export data`,
+    );
+    t.deepEqual(artifactNames, [], `${mode} final-deletion export artifacts`);
     const db2 = await reImport(t, dbDir, 'operational');
     t.is(db2.prepare('SELECT COUNT(*) FROM transcriptItems').pluck().get(), 0);
     t.is(db2.prepare('SELECT COUNT(*) FROM transcriptSpans').pluck().get(), 0);
@@ -417,9 +459,18 @@ test('slow deletion of transcripts', async t => {
     t.true(dc.done);
     t.is(dc.cleanups, 0);
     await commit();
-    t.is(exportLog.length, 0);
+    t.deepEqual(exportLog, []);
   }
+};
+const testSlowTranscriptDeletion = test.macro({
+  title(extra = '', { keepTranscripts }) {
+    const detail = keepTranscripts ? 'with retention' : 'without retention';
+    return `slow deletion of transcripts ${detail}${extra.replace(/.$/, ' $&')}`;
+  },
+  exec: execSlowTranscriptDeletion,
 });
+test(testSlowTranscriptDeletion, { keepTranscripts: true });
+test(testSlowTranscriptDeletion, { keepTranscripts: false });
 
 test('slow deletion without stopUsingTranscript', async t => {
   // slow deletion should work even without stopUsingTranscript
@@ -438,7 +489,7 @@ test('slow deletion without stopUsingTranscript', async t => {
     const t0 = { vatID, startPos: 0, endPos: 2, isCurrent: 0, incarnation: 0 };
     const t2 = { vatID, startPos: 2, endPos: 4, isCurrent: 0, incarnation: 0 };
     const t4 = { vatID, startPos: 4, endPos: 6, isCurrent: 0, incarnation: 1 };
-    compareNoHash(t, currentExportData, {
+    t.deepEqual(stripHashes(currentExportData), {
       'transcript.v1.0': t0,
       'transcript.v1.2': t2,
       'transcript.v1.4': t4,
@@ -556,7 +607,7 @@ test('slow deletion of snapshots', async t => {
     // stopUsingLastSnapshot is idempotent
     snapStore.stopUsingLastSnapshot(vatID);
     await commit();
-    t.is(exportLog.length, 0);
+    t.deepEqual(exportLog, []);
   }
 
   // first deletion

package/test/export.test.js

@@ -47,7 +47,7 @@ const exportTest = test.macro(async (t, mode) => {
   // incarnation 0
   ks.transcriptStore.addItem('v1', 'start-worker'); // 0
   ks.transcriptStore.addItem('v1', 'shutdown-worker'); // 1
-  ks.transcriptStore.rolloverIncarnation('v1');
+  await ks.transcriptStore.rolloverIncarnation('v1');
   const spanHash0 =
     '5bee0f44eca02f23eab03703e84ed2647d5d117fed99e1c30a3b424b7f082ab9';
 
@@ -56,7 +56,7 @@ const exportTest = test.macro(async (t, mode) => {
   ks.transcriptStore.addItem('v1', 'delivery1'); // 3
   await ks.snapStore.saveSnapshot('v1', 4, getSnapshotStream(snapshotData));
   ks.transcriptStore.addItem('v1', 'save-snapshot'); // 4
-  ks.transcriptStore.rolloverSpan('v1'); // range= 2..5
+  await ks.transcriptStore.rolloverSpan('v1'); // range= 2..5
   const spanHash1 =
     '57152efdd7fdf75c03371d2b4f1088d5bf3eae7fe643babce527ff81df38998c';
 
@@ -64,7 +64,7 @@ const exportTest = test.macro(async (t, mode) => {
   ks.transcriptStore.addItem('v1', 'delivery2'); // 6
   await ks.snapStore.saveSnapshot('v1', 7, getSnapshotStream(snapshotData));
   ks.transcriptStore.addItem('v1', 'save-snapshot'); // 7
-  ks.transcriptStore.rolloverSpan('v1'); // range= 5..8
+  await ks.transcriptStore.rolloverSpan('v1'); // range= 5..8
   const spanHash2 =
     '1947001e78e01bd1e773feb22b4ffc530447373b9de9274d5d5fbda3f23dbf2b';
 
@@ -251,7 +251,7 @@ test('export omits pruned span artifacts', async t => {
   ks.transcriptStore.addItem('v1', 'delivery1'); // 1
   await ks.snapStore.saveSnapshot('v1', 2, getSnapshotStream(snapshotData));
   ks.transcriptStore.addItem('v1', 'save-snapshot'); // 2
-  ks.transcriptStore.rolloverSpan('v1'); // range= 0..3
+  await ks.transcriptStore.rolloverSpan('v1'); // range= 0..3
   const spanHash1 =
     '57152efdd7fdf75c03371d2b4f1088d5bf3eae7fe643babce527ff81df38998c';
   // rolloverSpan prunes the contents of the old span

package/test/exportImport.test.js

@@ -87,7 +87,7 @@ async function fakeAVatSnapshot(vat, ks) {
   await ks.snapStore.saveSnapshot(vat.vatID, vat.endPos, getSnapshotStream());
   ks.transcriptStore.addItem(vat.vatID, 'save-snapshot');
   vat.endPos += 1;
-  ks.transcriptStore.rolloverSpan(vat.vatID);
+  await ks.transcriptStore.rolloverSpan(vat.vatID);
   ks.transcriptStore.addItem(vat.vatID, 'load-snapshot');
   vat.endPos += 1;
 }