@powersync/service-core 0.4.1 → 0.5.0

package/test/src/compacting.test.ts

@@ -0,0 +1,207 @@
+import { SqlSyncRules } from '@powersync/service-sync-rules';
+import { describe, expect, test } from 'vitest';
+import { makeTestTable, MONGO_STORAGE_FACTORY } from './util.js';
+import { oneFromAsync } from './wal_stream_utils.js';
+import { MongoCompactOptions } from '@/storage/mongo/MongoCompactor.js';
+import { reduceBucket, validateCompactedBucket, validateBucket } from './bucket_validation.js';
+
+const TEST_TABLE = makeTestTable('test', ['id']);
+
+// Test with the default options - large batch sizes
+describe('compacting buckets - default options', () => compactTests({}));
+
+// Also test with the miniumum batch sizes, forcing usage of multiple batches internally
+describe('compacting buckets - batched', () =>
+  compactTests({ clearBatchLimit: 2, moveBatchLimit: 1, moveBatchQueryLimit: 1 }));
+
+function compactTests(compactOptions: MongoCompactOptions) {
+  const factory = MONGO_STORAGE_FACTORY;
+
+  test('compacting (1)', async () => {
+    const sync_rules = SqlSyncRules.fromYaml(`
+bucket_definitions:
+  global:
+    data: [select * from test]
+    `);
+
+    const storage = (await factory()).getInstance({ id: 1, sync_rules, slot_name: 'test' });
+
+    const result = await storage.startBatch({}, async (batch) => {
+      await batch.save({
+        sourceTable: TEST_TABLE,
+        tag: 'insert',
+        after: {
+          id: 't1'
+        }
+      });
+
+      await batch.save({
+        sourceTable: TEST_TABLE,
+        tag: 'insert',
+        after: {
+          id: 't2'
+        }
+      });
+
+      await batch.save({
+        sourceTable: TEST_TABLE,
+        tag: 'update',
+        after: {
+          id: 't2'
+        }
+      });
+    });
+
+    const checkpoint = result!.flushed_op;
+
+    const batchBefore = await oneFromAsync(storage.getBucketDataBatch(checkpoint, new Map([['global[]', '0']])));
+    const dataBefore = batchBefore.batch.data;
+
+    expect(dataBefore).toMatchObject([
+      {
+        checksum: 2634521662,
+        object_id: 't1',
+        op: 'PUT',
+        op_id: '1'
+      },
+      {
+        checksum: 4243212114,
+        object_id: 't2',
+        op: 'PUT',
+        op_id: '2'
+      },
+      {
+        checksum: 4243212114,
+        object_id: 't2',
+        op: 'PUT',
+        op_id: '3'
+      }
+    ]);
+
+    await storage.compact(compactOptions);
+
+    const batchAfter = await oneFromAsync(storage.getBucketDataBatch(checkpoint, new Map([['global[]', '0']])));
+    const dataAfter = batchAfter.batch.data;
+
+    expect(batchAfter.targetOp).toEqual(3n);
+    expect(dataAfter).toMatchObject([
+      {
+        checksum: 2634521662,
+        object_id: 't1',
+        op: 'PUT',
+        op_id: '1'
+      },
+      {
+        checksum: 4243212114,
+        op: 'MOVE',
+        op_id: '2'
+      },
+      {
+        checksum: 4243212114,
+        object_id: 't2',
+        op: 'PUT',
+        op_id: '3'
+      }
+    ]);
+
+    validateCompactedBucket(dataBefore, dataAfter);
+  });
+
+  test('compacting (2)', async () => {
+    const sync_rules = SqlSyncRules.fromYaml(`
+bucket_definitions:
+  global:
+    data: [select * from test]
+    `);
+
+    const storage = (await factory()).getInstance({ id: 1, sync_rules, slot_name: 'test' });
+
+    const result = await storage.startBatch({}, async (batch) => {
+      await batch.save({
+        sourceTable: TEST_TABLE,
+        tag: 'insert',
+        after: {
+          id: 't1'
+        }
+      });
+
+      await batch.save({
+        sourceTable: TEST_TABLE,
+        tag: 'insert',
+        after: {
+          id: 't2'
+        }
+      });
+
+      await batch.save({
+        sourceTable: TEST_TABLE,
+        tag: 'delete',
+        before: {
+          id: 't1'
+        }
+      });
+
+      await batch.save({
+        sourceTable: TEST_TABLE,
+        tag: 'update',
+        after: {
+          id: 't2'
+        }
+      });
+    });
+
+    const checkpoint = result!.flushed_op;
+
+    const batchBefore = await oneFromAsync(storage.getBucketDataBatch(checkpoint, new Map([['global[]', '0']])));
+    const dataBefore = batchBefore.batch.data;
+
+    expect(dataBefore).toMatchObject([
+      {
+        checksum: 2634521662,
+        object_id: 't1',
+        op: 'PUT',
+        op_id: '1'
+      },
+      {
+        checksum: 4243212114,
+        object_id: 't2',
+        op: 'PUT',
+        op_id: '2'
+      },
+      {
+        checksum: 4228978084,
+        object_id: 't1',
+        op: 'REMOVE',
+        op_id: '3'
+      },
+      {
+        checksum: 4243212114,
+        object_id: 't2',
+        op: 'PUT',
+        op_id: '4'
+      }
+    ]);
+
+    await storage.compact(compactOptions);
+
+    const batchAfter = await oneFromAsync(storage.getBucketDataBatch(checkpoint, new Map([['global[]', '0']])));
+    const dataAfter = batchAfter.batch.data;
+
+    expect(batchAfter.targetOp).toEqual(4n);
+    expect(dataAfter).toMatchObject([
+      {
+        checksum: -1778190028,
+        op: 'CLEAR',
+        op_id: '3'
+      },
+      {
+        checksum: 4243212114,
+        object_id: 't2',
+        op: 'PUT',
+        op_id: '4'
+      }
+    ]);
+
+    validateCompactedBucket(dataBefore, dataAfter);
+  });
+}

package/test/src/data_storage.test.ts

@@ -1,26 +1,8 @@
 import { RequestParameters, SqlSyncRules } from '@powersync/service-sync-rules';
-import * as bson from 'bson';
 import { describe, expect, test } from 'vitest';
-import { SourceTable } from '../../src/storage/SourceTable.js';
-import { hashData } from '../../src/util/utils.js';
-import { MONGO_STORAGE_FACTORY, StorageFactory } from './util.js';
-import { SyncBucketData } from '../../src/util/protocol-types.js';
 import { BucketDataBatchOptions } from '../../src/storage/BucketStorage.js';
-import { fromAsync } from './wal_stream_utils.js';
-
-function makeTestTable(name: string, columns?: string[] | undefined) {
-  const relId = hashData('table', name, (columns ?? ['id']).join(','));
-  const id = new bson.ObjectId('6544e3899293153fa7b38331');
-  return new SourceTable(
-    id,
-    SourceTable.DEFAULT_TAG,
-    relId,
-    SourceTable.DEFAULT_SCHEMA,
-    name,
-    (columns ?? ['id']).map((column) => ({ name: column, typeOid: 25 })),
-    true
-  );
-}
+import { getBatchData, getBatchMeta, makeTestTable, MONGO_STORAGE_FACTORY, StorageFactory } from './util.js';
+import { fromAsync, oneFromAsync } from './wal_stream_utils.js';
 
 const TEST_TABLE = makeTestTable('test', ['id']);
 
@@ -236,7 +218,7 @@ bucket_definitions:
     const checkpoint = result!.flushed_op;
 
     const batch = await fromAsync(storage.getBucketDataBatch(checkpoint, new Map([['global[]', '0']])));
-    const data = batch[0].data.map((d) => {
+    const data = batch[0].batch.data.map((d) => {
       return {
         op: d.op,
         object_id: d.object_id,
@@ -504,7 +486,7 @@ bucket_definitions:
     });
     const checkpoint = result!.flushed_op;
     const batch = await fromAsync(storage.getBucketDataBatch(checkpoint, new Map([['global[]', '0']])));
-    const data = batch[0].data.map((d) => {
+    const data = batch[0].batch.data.map((d) => {
       return {
         op: d.op,
         object_id: d.object_id
@@ -568,7 +550,7 @@ bucket_definitions:
     const checkpoint = result!.flushed_op;
 
     const batch = await fromAsync(storage.getBucketDataBatch(checkpoint, new Map([['global[]', '0']])));
-    const data = batch[0].data.map((d) => {
+    const data = batch[0].batch.data.map((d) => {
       return {
         op: d.op,
         object_id: d.object_id,
@@ -680,7 +662,7 @@ bucket_definitions:
 
     const batch = await fromAsync(storage.getBucketDataBatch(checkpoint, new Map([['global[]', '0']])));
 
-    const data = batch[0].data.map((d) => {
+    const data = batch[0].batch.data.map((d) => {
       return {
         op: d.op,
         object_id: d.object_id,
@@ -855,7 +837,7 @@ bucket_definitions:
     const checkpoint2 = result2!.flushed_op;
 
     const batch = await fromAsync(storage.getBucketDataBatch(checkpoint2, new Map([['global[]', checkpoint1]])));
-    const data = batch[0].data.map((d) => {
+    const data = batch[0].batch.data.map((d) => {
       return {
         op: d.op,
         object_id: d.object_id,
@@ -939,7 +921,7 @@ bucket_definitions:
     const checkpoint3 = result3!.flushed_op;
 
     const batch = await fromAsync(storage.getBucketDataBatch(checkpoint3, new Map([['global[]', checkpoint1]])));
-    const data = batch[0].data.map((d) => {
+    const data = batch[0].batch.data.map((d) => {
       return {
         op: d.op,
         object_id: d.object_id,
@@ -1031,7 +1013,7 @@ bucket_definitions:
     const checkpoint3 = result3!.flushed_op;
 
     const batch = await fromAsync(storage.getBucketDataBatch(checkpoint3, new Map([['global[]', checkpoint1]])));
-    const data = batch[0].data.map((d) => {
+    const data = batch[0].batch.data.map((d) => {
       return {
         op: d.op,
         object_id: d.object_id,
@@ -1133,7 +1115,7 @@ bucket_definitions:
     });
 
     const batch2 = await fromAsync(
-      storage.getBucketDataBatch(checkpoint, new Map([['global[]', batch1[0].next_after]]), options)
+      storage.getBucketDataBatch(checkpoint, new Map([['global[]', batch1[0].batch.next_after]]), options)
     );
     expect(getBatchData(batch2)).toEqual([
       { op_id: '3', op: 'PUT', object_id: 'large2', checksum: 1795508474 },
@@ -1146,7 +1128,7 @@ bucket_definitions:
     });
 
     const batch3 = await fromAsync(
-      storage.getBucketDataBatch(checkpoint, new Map([['global[]', batch2[0].next_after]]), options)
+      storage.getBucketDataBatch(checkpoint, new Map([['global[]', batch2[0].batch.next_after]]), options)
     );
     expect(getBatchData(batch3)).toEqual([]);
     expect(getBatchMeta(batch3)).toEqual(null);
@@ -1223,7 +1205,7 @@ bucket_definitions:
     });
 
     const batch2 = await fromAsync(
-      storage.getBucketDataBatch(checkpoint, new Map([['global[]', batch1[0].next_after]]), options)
+      storage.getBucketDataBatch(checkpoint, new Map([['global[]', batch1[0].batch.next_after]]), options)
     );
     expect(getBatchData(batch2)).toEqual([{ op_id: '3', op: 'PUT', object_id: 'large2', checksum: 1607205872 }]);
     expect(getBatchMeta(batch2)).toEqual({
@@ -1233,7 +1215,7 @@ bucket_definitions:
     });
 
     const batch3 = await fromAsync(
-      storage.getBucketDataBatch(checkpoint, new Map([['global[]', batch2[0].next_after]]), options)
+      storage.getBucketDataBatch(checkpoint, new Map([['global[]', batch2[0].batch.next_after]]), options)
     );
     expect(getBatchData(batch3)).toEqual([{ op_id: '4', op: 'PUT', object_id: 'test3', checksum: 1359888332 }]);
     expect(getBatchMeta(batch3)).toEqual({
@@ -1270,7 +1252,9 @@ bucket_definitions:
 
     const checkpoint = result!.flushed_op;
 
-    const batch1 = await fromAsync(storage.getBucketDataBatch(checkpoint, new Map([['global[]', '0']]), { limit: 4 }));
+    const batch1 = await oneFromAsync(
+      storage.getBucketDataBatch(checkpoint, new Map([['global[]', '0']]), { limit: 4 })
+    );
 
     expect(getBatchData(batch1)).toEqual([
       { op_id: '1', op: 'PUT', object_id: 'test1', checksum: 2871785649 },
@@ -1285,8 +1269,8 @@ bucket_definitions:
       next_after: '4'
     });
 
-    const batch2 = await fromAsync(
-      storage.getBucketDataBatch(checkpoint, new Map([['global[]', batch1[0].next_after]]), {
+    const batch2 = await oneFromAsync(
+      storage.getBucketDataBatch(checkpoint, new Map([['global[]', batch1.batch.next_after]]), {
         limit: 4
       })
     );
@@ -1302,7 +1286,7 @@ bucket_definitions:
     });
 
     const batch3 = await fromAsync(
-      storage.getBucketDataBatch(checkpoint, new Map([['global[]', batch2[0].next_after]]), {
+      storage.getBucketDataBatch(checkpoint, new Map([['global[]', batch2.batch.next_after]]), {
         limit: 4
       })
     );
@@ -1311,28 +1295,3 @@ bucket_definitions:
     expect(getBatchMeta(batch3)).toEqual(null);
   });
 }
-
-function getBatchData(batch: SyncBucketData[]) {
-  if (batch.length == 0) {
-    return [];
-  }
-  return batch[0].data.map((d) => {
-    return {
-      op_id: d.op_id,
-      op: d.op,
-      object_id: d.object_id,
-      checksum: d.checksum
-    };
-  });
-}
-
-function getBatchMeta(batch: SyncBucketData[]) {
-  if (batch.length == 0) {
-    return null;
-  }
-  return {
-    has_more: batch[0].has_more,
-    after: batch[0].after,
-    next_after: batch[0].next_after
-  };
-}

package/test/src/slow_tests.test.ts

@@ -4,12 +4,15 @@ import { afterEach, describe, expect, test } from 'vitest';
 import { WalStream, WalStreamOptions } from '../../src/replication/WalStream.js';
 import { getClientCheckpoint } from '../../src/util/utils.js';
 import { env } from './env.js';
-import { MONGO_STORAGE_FACTORY, StorageFactory, TEST_CONNECTION_OPTIONS, connectPgPool } from './util.js';
+import { MONGO_STORAGE_FACTORY, StorageFactory, TEST_CONNECTION_OPTIONS, clearTestDb, connectPgPool } from './util.js';
 
 import * as pgwire from '@powersync/service-jpgwire';
 import { SqliteRow } from '@powersync/service-sync-rules';
 import { MongoBucketStorage } from '../../src/storage/MongoBucketStorage.js';
 import { PgManager } from '../../src/util/PgManager.js';
+import { mapOpEntry } from '@/storage/storage-index.js';
+import { reduceBucket, validateCompactedBucket, validateBucket } from './bucket_validation.js';
+import * as timers from 'node:timers/promises';
 
 describe('slow tests - mongodb', function () {
   // These are slow, inconsistent tests.
@@ -51,130 +54,169 @@ function defineSlowTests(factory: StorageFactory) {
   // * Skipping LSNs after a keepalive message
   // * Skipping LSNs when source transactions overlap
   test(
-    'repeated replication',
+    'repeated replication - basic',
     async () => {
-      const connections = new PgManager(TEST_CONNECTION_OPTIONS, {});
-      const replicationConnection = await connections.replicationConnection();
-      const pool = connections.pool;
-      const f = (await factory()) as MongoBucketStorage;
+      await testRepeatedReplication({ compact: false, maxBatchSize: 50, numBatches: 5 });
+    },
+    { timeout: TEST_DURATION_MS + TIMEOUT_MARGIN_MS }
+  );
 
-      const syncRuleContent = `
+  test(
+    'repeated replication - compacted',
+    async () => {
+      await testRepeatedReplication({ compact: true, maxBatchSize: 100, numBatches: 2 });
+    },
+    { timeout: TEST_DURATION_MS + TIMEOUT_MARGIN_MS }
+  );
+
+  async function testRepeatedReplication(testOptions: { compact: boolean; maxBatchSize: number; numBatches: number }) {
+    const connections = new PgManager(TEST_CONNECTION_OPTIONS, {});
+    const replicationConnection = await connections.replicationConnection();
+    const pool = connections.pool;
+    await clearTestDb(pool);
+    const f = (await factory()) as MongoBucketStorage;
+
+    const syncRuleContent = `
 bucket_definitions:
   global:
     data:
       - SELECT * FROM "test_data"
 `;
-      const syncRules = await f.updateSyncRules({ content: syncRuleContent });
-      const storage = f.getInstance(syncRules.parsed());
-      abortController = new AbortController();
-      const options: WalStreamOptions = {
-        abort_signal: abortController.signal,
-        connections,
-        storage: storage,
-        factory: f
-      };
-      walStream = new WalStream(options);
-
-      await pool.query(`DROP TABLE IF EXISTS test_data`);
-      await pool.query(
-        `CREATE TABLE test_data(id uuid primary key default uuid_generate_v4(), description text, num decimal)`
-      );
-      await pool.query(`ALTER TABLE test_data REPLICA IDENTITY FULL`);
-
-      await walStream.initReplication(replicationConnection);
-      await storage.autoActivate();
-      let abort = false;
-      streamPromise = walStream.streamChanges(replicationConnection).finally(() => {
-        abort = true;
-      });
-      const start = Date.now();
+    const syncRules = await f.updateSyncRules({ content: syncRuleContent });
+    const storage = f.getInstance(syncRules.parsed());
+    abortController = new AbortController();
+    const options: WalStreamOptions = {
+      abort_signal: abortController.signal,
+      connections,
+      storage: storage,
+      factory: f
+    };
+    walStream = new WalStream(options);
+
+    await pool.query(
+      `CREATE TABLE test_data(id uuid primary key default uuid_generate_v4(), description text, num decimal)`
+    );
+    await pool.query(`ALTER TABLE test_data REPLICA IDENTITY FULL`);
+
+    await walStream.initReplication(replicationConnection);
+    await storage.autoActivate();
+    let abort = false;
+    streamPromise = walStream.streamChanges(replicationConnection).finally(() => {
+      abort = true;
+    });
+    const start = Date.now();
+
+    while (!abort && Date.now() - start < TEST_DURATION_MS) {
+      const bg = async () => {
+        for (let j = 0; j < testOptions.numBatches && !abort; j++) {
+          const n = Math.max(1, Math.floor(Math.random() * testOptions.maxBatchSize));
+          let statements: pgwire.Statement[] = [];
+          for (let i = 0; i < n; i++) {
+            const description = `test${i}`;
+            statements.push({
+              statement: `INSERT INTO test_data(description, num) VALUES($1, $2) returning id as test_id`,
+              params: [
+                { type: 'varchar', value: description },
+                { type: 'float8', value: Math.random() }
+              ]
+            });
+          }
+          const results = await pool.query(...statements);
+          const ids = results.results.map((sub) => {
+            return sub.rows[0][0] as string;
+          });
+          await new Promise((resolve) => setTimeout(resolve, Math.random() * 30));
 
-      while (!abort && Date.now() - start < TEST_DURATION_MS) {
-        const bg = async () => {
-          for (let j = 0; j < 1 && !abort; j++) {
-            const n = 1;
-            let statements: pgwire.Statement[] = [];
-            for (let i = 0; i < n; i++) {
-              const description = `test${i}`;
-              statements.push({
-                statement: `INSERT INTO test_data(description, num) VALUES($1, $2) returning id as test_id`,
+          if (Math.random() > 0.5) {
+            const updateStatements: pgwire.Statement[] = ids.map((id) => {
+              return {
+                statement: `UPDATE test_data SET num = $2 WHERE id = $1`,
                 params: [
-                  { type: 'varchar', value: description },
+                  { type: 'uuid', value: id },
                   { type: 'float8', value: Math.random() }
                 ]
-              });
-            }
-            const results = await pool.query(...statements);
-            const ids = results.results.map((sub) => {
-              return sub.rows[0][0] as string;
+              };
             });
-            await new Promise((resolve) => setTimeout(resolve, Math.random() * 30));
 
+            await pool.query(...updateStatements);
             if (Math.random() > 0.5) {
-              const updateStatements: pgwire.Statement[] = ids.map((id) => {
-                return {
-                  statement: `UPDATE test_data SET num = $2 WHERE id = $1`,
-                  params: [
-                    { type: 'uuid', value: id },
-                    { type: 'float8', value: Math.random() }
-                  ]
-                };
-              });
-
+              // Special case - an update that doesn't change data
               await pool.query(...updateStatements);
-              if (Math.random() > 0.5) {
-                // Special case - an update that doesn't change data
-                await pool.query(...updateStatements);
-              }
             }
-
-            const deleteStatements: pgwire.Statement[] = ids.map((id) => {
-              return {
-                statement: `DELETE FROM test_data WHERE id = $1`,
-                params: [{ type: 'uuid', value: id }]
-              };
-            });
-            await pool.query(...deleteStatements);
-
-            await new Promise((resolve) => setTimeout(resolve, Math.random() * 10));
           }
-        };
 
-        // Call the above loop multiple times concurrently
-        let promises = [1, 2, 3].map((i) => bg());
-        await Promise.all(promises);
+          const deleteStatements: pgwire.Statement[] = ids.map((id) => {
+            return {
+              statement: `DELETE FROM test_data WHERE id = $1`,
+              params: [{ type: 'uuid', value: id }]
+            };
+          });
+          await pool.query(...deleteStatements);
 
-        // Wait for replication to finish
-        let checkpoint = await getClientCheckpoint(pool, storage.factory, { timeout: TIMEOUT_MARGIN_MS });
+          await new Promise((resolve) => setTimeout(resolve, Math.random() * 10));
+        }
+      };
 
-        // Check that all inserts have been deleted again
-        const docs = await f.db.current_data.find().toArray();
-        const transformed = docs.map((doc) => {
-          return bson.deserialize((doc.data as mongo.Binary).buffer) as SqliteRow;
-        });
-        expect(transformed).toEqual([]);
-
-        // Check that each PUT has a REMOVE
-        const ops = await f.db.bucket_data.find().sort({ _id: 1 }).toArray();
-        let active = new Set<string>();
-        for (let op of ops) {
-          const key = op.source_key.toHexString();
-          if (op.op == 'PUT') {
-            active.add(key);
-          } else if (op.op == 'REMOVE') {
-            active.delete(key);
+      let compactController = new AbortController();
+
+      const bgCompact = async () => {
+        // Repeatedly compact, and check that the compact conditions hold
+        while (!compactController.signal.aborted) {
+          const delay = Math.random() * 50;
+          try {
+            await timers.setTimeout(delay, undefined, { signal: compactController.signal });
+          } catch (e) {
+            break;
           }
+
+          const checkpoint = BigInt((await storage.getCheckpoint()).checkpoint);
+          const opsBefore = (await f.db.bucket_data.find().sort({ _id: 1 }).toArray())
+            .filter((row) => row._id.o <= checkpoint)
+            .map(mapOpEntry);
+          await storage.compact({ maxOpId: checkpoint });
+          const opsAfter = (await f.db.bucket_data.find().sort({ _id: 1 }).toArray())
+            .filter((row) => row._id.o <= checkpoint)
+            .map(mapOpEntry);
+
+          validateCompactedBucket(opsBefore, opsAfter);
         }
-        if (active.size > 0) {
-          throw new Error(`${active.size} rows not removed`);
+      };
+
+      // Call the above loop multiple times concurrently
+      const promises = [1, 2, 3].map((i) => bg());
+      const compactPromise = testOptions.compact ? bgCompact() : null;
+      await Promise.all(promises);
+      compactController.abort();
+      await compactPromise;
+
+      // Wait for replication to finish
+      let checkpoint = await getClientCheckpoint(pool, storage.factory, { timeout: TIMEOUT_MARGIN_MS });
+
+      // Check that all inserts have been deleted again
+      const docs = await f.db.current_data.find().toArray();
+      const transformed = docs.map((doc) => {
+        return bson.deserialize((doc.data as mongo.Binary).buffer) as SqliteRow;
+      });
+      expect(transformed).toEqual([]);
+
+      // Check that each PUT has a REMOVE
+      const ops = await f.db.bucket_data.find().sort({ _id: 1 }).toArray();
+
+      // All a single bucket in this test
+      const bucket = ops.map((op) => mapOpEntry(op));
+      const reduced = reduceBucket(bucket);
+      expect(reduced).toMatchObject([
+        {
+          op_id: '0',
+          op: 'CLEAR'
         }
-      }
+        // Should contain no additional data
+      ]);
+    }
 
-      abortController.abort();
-      await streamPromise;
-    },
-    { timeout: TEST_DURATION_MS + TIMEOUT_MARGIN_MS }
-  );
+    abortController.abort();
+    await streamPromise;
+  }
 
   // Test repeatedly performing initial replication.
   //
@@ -184,6 +226,7 @@ bucket_definitions:
     'repeated initial replication',
     async () => {
       const pool = await connectPgPool();
+      await clearTestDb(pool);
       const f = await factory();
 
       const syncRuleContent = `
@@ -196,7 +239,6 @@ bucket_definitions:
       const storage = f.getInstance(syncRules.parsed());
 
       // 1. Setup some base data that will be replicated in initial replication
-      await pool.query(`DROP TABLE IF EXISTS test_data`);
       await pool.query(`CREATE TABLE test_data(id uuid primary key default uuid_generate_v4(), description text)`);
 
       let statements: pgwire.Statement[] = [];