@powersync/service-module-postgres 0.17.2 → 0.19.0

package/test/src/slow_tests.test.ts

@@ -7,6 +7,7 @@ import {
   connectPgPool,
   describeWithStorage,
   getClientCheckpoint,
+  StorageVersionTestContext,
   TEST_CONNECTION_OPTIONS
 } from './util.js';
 
@@ -14,20 +15,26 @@ import * as pgwire from '@powersync/service-jpgwire';
 import { SqliteRow } from '@powersync/service-sync-rules';
 
 import { PgManager } from '@module/replication/PgManager.js';
-import { createCoreReplicationMetrics, initializeCoreReplicationMetrics, storage } from '@powersync/service-core';
+import { ReplicationAbortedError } from '@powersync/lib-services-framework';
+import {
+  createCoreReplicationMetrics,
+  initializeCoreReplicationMetrics,
+  reduceBucket,
+  updateSyncRulesFromYaml
+} from '@powersync/service-core';
 import { METRICS_HELPER, test_utils } from '@powersync/service-core-tests';
 import * as mongo_storage from '@powersync/service-module-mongodb-storage';
 import * as postgres_storage from '@powersync/service-module-postgres-storage';
 import * as timers from 'node:timers/promises';
-import { CustomTypeRegistry } from '@module/types/registry.js';
+import { WalStreamTestContext } from './wal_stream_utils.js';
 
 describe.skipIf(!(env.CI || env.SLOW_TESTS))('slow tests', function () {
-  describeWithStorage({ timeout: 120_000 }, function (factory) {
-    defineSlowTests(factory);
+  describeWithStorage({ timeout: 120_000 }, function ({ factory, storageVersion }) {
+    defineSlowTests({ factory, storageVersion });
   });
 });
 
-function defineSlowTests(factory: storage.TestStorageFactory) {
+function defineSlowTests({ factory, storageVersion }: StorageVersionTestContext) {
   let walStream: WalStream | undefined;
   let connections: PgManager | undefined;
   let abortController: AbortController | undefined;
@@ -42,7 +49,7 @@ function defineSlowTests(factory: storage.TestStorageFactory) {
     // This cleans up, similar to WalStreamTestContext.dispose().
     // These tests are a little more complex than what is supported by WalStreamTestContext.
     abortController?.abort();
-    await streamPromise;
+    await streamPromise?.catch((_) => {});
     streamPromise = undefined;
     connections?.destroy();
 
@@ -70,7 +77,6 @@ function defineSlowTests(factory: storage.TestStorageFactory) {
 
   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);
     await using f = await factory();
@@ -81,7 +87,7 @@ bucket_definitions:
     data:
       - SELECT * FROM "test_data"
 `;
-    const syncRules = await f.updateSyncRules({ content: syncRuleContent });
+    const syncRules = await f.updateSyncRules(updateSyncRulesFromYaml(syncRuleContent, { storageVersion }));
     const storage = f.getInstance(syncRules);
     abortController = new AbortController();
     const options: WalStreamOptions = {
@@ -97,11 +103,11 @@ bucket_definitions:
     );
     await pool.query(`ALTER TABLE test_data REPLICA IDENTITY FULL`);
 
-    await walStream.initReplication(replicationConnection);
     let abort = false;
-    streamPromise = walStream.streamChanges(replicationConnection).finally(() => {
+    streamPromise = walStream.replicate().finally(() => {
       abort = true;
     });
+    await walStream.waitForInitialSnapshot();
     const start = Date.now();
 
     while (!abort && Date.now() - start < TEST_DURATION_MS) {
@@ -223,11 +229,12 @@ bucket_definitions:
       await compactPromise;
 
       // Wait for replication to finish
-      let checkpoint = await getClientCheckpoint(pool, storage.factory, { timeout: TIMEOUT_MARGIN_MS });
+      await getClientCheckpoint(pool, storage.factory, { timeout: TIMEOUT_MARGIN_MS });
 
       if (f instanceof mongo_storage.storage.MongoBucketStorage) {
         // Check that all inserts have been deleted again
-        const docs = await f.db.current_data.find().toArray();
+        // Note: at this point, the pending_delete cleanup may not have run yet.
+        const docs = await f.db.current_data.find({ pending_delete: { $exists: false } }).toArray();
         const transformed = docs.map((doc) => {
           return bson.deserialize(doc.data.buffer) as SqliteRow;
         });
@@ -249,13 +256,14 @@ bucket_definitions:
       } else if (f instanceof postgres_storage.storage.PostgresBucketStorageFactory) {
         const { db } = f;
         // Check that all inserts have been deleted again
+        // FIXME: handle different storage versions
         const docs = await db.sql`
           SELECT
             *
           FROM
             current_data
         `
-          .decoded(postgres_storage.models.CurrentData)
+          .decoded(postgres_storage.models.V1CurrentData)
           .rows();
         const transformed = docs.map((doc) => {
           return bson.deserialize(doc.data) as SqliteRow;
@@ -288,14 +296,20 @@ bucket_definitions:
     }
 
     abortController.abort();
-    await streamPromise;
+    await streamPromise.catch((e) => {
+      if (e instanceof ReplicationAbortedError) {
+        // Ignore
+      } else {
+        throw e;
+      }
+    });
   }
 
   // Test repeatedly performing initial replication.
   //
   // If the first LSN does not correctly match with the first replication transaction,
   // we may miss some updates.
-  test('repeated initial replication', { timeout: TEST_DURATION_MS + TIMEOUT_MARGIN_MS }, async () => {
+  test('repeated initial replication (1)', { timeout: TEST_DURATION_MS + TIMEOUT_MARGIN_MS }, async () => {
     const pool = await connectPgPool();
     await clearTestDb(pool);
     await using f = await factory();
@@ -306,7 +320,8 @@ bucket_definitions:
     data:
       - SELECT id, description FROM "test_data"
 `;
-    const syncRules = await f.updateSyncRules({ content: syncRuleContent });
+
+    const syncRules = await f.updateSyncRules(updateSyncRulesFromYaml(syncRuleContent, { storageVersion }));
     const storage = f.getInstance(syncRules);
 
     // 1. Setup some base data that will be replicated in initial replication
@@ -331,7 +346,6 @@ bucket_definitions:
       i += 1;
 
       const connections = new PgManager(TEST_CONNECTION_OPTIONS, {});
-      const replicationConnection = await connections.replicationConnection();
 
       abortController = new AbortController();
       const options: WalStreamOptions = {
@@ -344,19 +358,14 @@ bucket_definitions:
 
       await storage.clear();
 
-      // 3. Start initial replication, then streaming, but don't wait for any of this
+      // 3. Start replication, but don't wait for it
       let initialReplicationDone = false;
-      streamPromise = (async () => {
-        await walStream.initReplication(replicationConnection);
-        initialReplicationDone = true;
-        await walStream.streamChanges(replicationConnection);
-      })()
-        .catch((e) => {
+      streamPromise = walStream.replicate();
+      walStream
+        .waitForInitialSnapshot()
+        .catch((_) => {})
+        .finally(() => {
           initialReplicationDone = true;
-          throw e;
-        })
-        .then((v) => {
-          return v;
         });
 
       // 4. While initial replication is still running, write more changes
@@ -399,8 +408,104 @@ bucket_definitions:
       }
 
       abortController.abort();
-      await streamPromise;
+      await streamPromise.catch((e) => {
+        if (e instanceof ReplicationAbortedError) {
+          // Ignore
+        } else {
+          throw e;
+        }
+      });
       await connections.end();
     }
   });
+
+  // Test repeatedly performing initial replication while deleting data.
+  //
+  // This specifically checks for data in the initial snapshot being deleted while snapshotting.
+  test('repeated initial replication with deletes', { timeout: TEST_DURATION_MS + TIMEOUT_MARGIN_MS }, async () => {
+    const syncRuleContent = `
+bucket_definitions:
+  global:
+    data:
+      - SELECT id, description FROM "test_data"
+`;
+
+    const start = Date.now();
+    let i = 0;
+
+    while (Date.now() - start < TEST_DURATION_MS) {
+      i += 1;
+
+      // 1. Each iteration starts with a clean slate
+      await using context = await WalStreamTestContext.open(factory, {
+        walStreamOptions: { snapshotChunkLength: 100 }
+      });
+      const pool = context.pool;
+
+      // Introduce an artificial delay in snapshot queries, to make it more likely to reproduce an
+      // issue.
+      const originalSnapshotConnectionFn = context.connectionManager.snapshotConnection;
+      context.connectionManager.snapshotConnection = async () => {
+        const conn = await originalSnapshotConnectionFn.call(context.connectionManager);
+        // Wrap streaming query to add delays to snapshots
+        const originalStream = conn.stream;
+        conn.stream = async function* (...args: any[]) {
+          const delay = Math.random() * 20;
+          yield* originalStream.call(this, ...args);
+          await new Promise((resolve) => setTimeout(resolve, delay));
+        };
+        return conn;
+      };
+
+      await pool.query(`CREATE TABLE test_data(id uuid primary key default uuid_generate_v4(), description text)`);
+      await context.updateSyncRules(syncRuleContent);
+
+      let statements: pgwire.Statement[] = [];
+
+      const n = Math.floor(Math.random() * 200);
+      for (let i = 0; i < n; i++) {
+        statements.push({
+          statement: `INSERT INTO test_data(description) VALUES('test_init') RETURNING id`
+        });
+      }
+      const results = await pool.query(...statements);
+      const ids = new Set(
+        results.results.map((sub) => {
+          return sub.rows[0].decodeWithoutCustomTypes(0) as string;
+        })
+      );
+
+      // 3. Start replication, but don't wait for it
+      let initialReplicationDone = false;
+
+      streamPromise = context.replicateSnapshot().finally(() => {
+        initialReplicationDone = true;
+      });
+
+      // 4. While initial replication is still running, delete random rows
+      while (!initialReplicationDone && ids.size > 0) {
+        let statements: pgwire.Statement[] = [];
+
+        const m = Math.floor(Math.random() * 10) + 1;
+        const idArray = Array.from(ids);
+        for (let i = 0; i < m; i++) {
+          const id = idArray[Math.floor(Math.random() * idArray.length)];
+          statements.push({
+            statement: `DELETE FROM test_data WHERE id = $1`,
+            params: [{ type: 'uuid', value: id }]
+          });
+          ids.delete(id);
+        }
+        await pool.query(...statements);
+        await new Promise((resolve) => setTimeout(resolve, Math.random() * 10));
+      }
+
+      await streamPromise;
+
+      // 5. Once initial replication is done, wait for the streaming changes to complete syncing.
+      const data = await context.getBucketData('global[]', 0n);
+      const normalized = reduceBucket(data).filter((op) => op.op !== 'CLEAR');
+      expect(normalized.length).toEqual(ids.size);
+    }
+  });
 }

package/test/src/storage_combination.test.ts

@@ -7,9 +7,9 @@ describe.skipIf(!env.TEST_POSTGRES_STORAGE)('replication storage combination - p
   test('should allow the same Postgres cluster to be used for data and storage', async () => {
     // Use the same cluster for the storage as the data source
     await using context = await WalStreamTestContext.open(
-      postgres_storage.test_utils.postgresTestStorageFactoryGenerator({
+      postgres_storage.test_utils.postgresTestSetup({
         url: env.PG_TEST_URL
-      }),
+      }).factory,
       { doNotClear: false }
     );
 

package/test/src/util.ts

@@ -2,12 +2,20 @@ import { PostgresRouteAPIAdapter } from '@module/api/PostgresRouteAPIAdapter.js'
 import * as types from '@module/types/types.js';
 import * as lib_postgres from '@powersync/lib-service-postgres';
 import { logger } from '@powersync/lib-services-framework';
-import { BucketStorageFactory, InternalOpId, TestStorageFactory } from '@powersync/service-core';
+import {
+  BucketStorageFactory,
+  CURRENT_STORAGE_VERSION,
+  InternalOpId,
+  LEGACY_STORAGE_VERSION,
+  SUPPORTED_STORAGE_VERSIONS,
+  TestStorageConfig,
+  TestStorageFactory
+} from '@powersync/service-core';
 import * as pgwire from '@powersync/service-jpgwire';
 import * as mongo_storage from '@powersync/service-module-mongodb-storage';
 import * as postgres_storage from '@powersync/service-module-postgres-storage';
-import { env } from './env.js';
 import { describe, TestOptions } from 'vitest';
+import { env } from './env.js';
 
 export const TEST_URI = env.PG_TEST_URL;
 
@@ -16,18 +24,38 @@ export const INITIALIZED_MONGO_STORAGE_FACTORY = mongo_storage.test_utils.mongoT
   isCI: env.CI
 });
 
-export const INITIALIZED_POSTGRES_STORAGE_FACTORY = postgres_storage.test_utils.postgresTestStorageFactoryGenerator({
+export const INITIALIZED_POSTGRES_STORAGE_FACTORY = postgres_storage.test_utils.postgresTestSetup({
   url: env.PG_STORAGE_TEST_URL
 });
 
-export function describeWithStorage(options: TestOptions, fn: (factory: TestStorageFactory) => void) {
-  describe.skipIf(!env.TEST_MONGO_STORAGE)(`mongodb storage`, options, function () {
-    fn(INITIALIZED_MONGO_STORAGE_FACTORY);
-  });
+const TEST_STORAGE_VERSIONS = SUPPORTED_STORAGE_VERSIONS;
+
+export interface StorageVersionTestContext {
+  factory: TestStorageFactory;
+  storageVersion: number;
+}
 
-  describe.skipIf(!env.TEST_POSTGRES_STORAGE)(`postgres storage`, options, function () {
-    fn(INITIALIZED_POSTGRES_STORAGE_FACTORY);
-  });
+export function describeWithStorage(options: TestOptions, fn: (context: StorageVersionTestContext) => void) {
+  const describeFactory = (storageName: string, config: TestStorageConfig) => {
+    describe(`${storageName} storage`, options, function () {
+      for (const storageVersion of TEST_STORAGE_VERSIONS) {
+        describe(`storage v${storageVersion}`, function () {
+          fn({
+            factory: config.factory,
+            storageVersion
+          });
+        });
+      }
+    });
+  };
+
+  if (env.TEST_MONGO_STORAGE) {
+    describeFactory('mongodb', INITIALIZED_MONGO_STORAGE_FACTORY);
+  }
+
+  if (env.TEST_POSTGRES_STORAGE) {
+    describeFactory('postgres', INITIALIZED_POSTGRES_STORAGE_FACTORY);
+  }
 }
 
 export const TEST_CONNECTION_OPTIONS = types.normalizeConnectionConfig({

package/test/src/validation.test.ts

@@ -3,9 +3,10 @@ import { expect, test } from 'vitest';
 
 import { INITIALIZED_MONGO_STORAGE_FACTORY } from './util.js';
 import { WalStreamTestContext } from './wal_stream_utils.js';
+import { updateSyncRulesFromYaml } from '@powersync/service-core';
 
 test('validate tables', async () => {
-  await using context = await WalStreamTestContext.open(INITIALIZED_MONGO_STORAGE_FACTORY);
+  await using context = await WalStreamTestContext.open(INITIALIZED_MONGO_STORAGE_FACTORY.factory);
   const { pool } = context;
 
   await pool.query(`CREATE TABLE test_data(id uuid primary key default uuid_generate_v4(), description text)`);
@@ -19,7 +20,7 @@ bucket_definitions:
       - SELECT * FROM "other%"
 `;
 
-  const syncRules = await context.factory.updateSyncRules({ content: syncRuleContent });
+  const syncRules = await context.factory.updateSyncRules(updateSyncRulesFromYaml(syncRuleContent));
 
   const tablePatterns = syncRules.parsed({ defaultSchema: 'public' }).sync_rules.config.getSourceTables();
   const tableInfo = await getDebugTablesInfo({

package/test/src/wal_stream.test.ts

@@ -1,13 +1,12 @@
 import { MissingReplicationSlotError } from '@module/replication/WalStream.js';
-import { storage } from '@powersync/service-core';
 import { METRICS_HELPER, putOp, removeOp } from '@powersync/service-core-tests';
 import { pgwireRows } from '@powersync/service-jpgwire';
+import { JSONBig } from '@powersync/service-jsonbig';
 import { ReplicationMetric } from '@powersync/service-types';
 import * as crypto from 'crypto';
-import { afterAll, beforeAll, describe, expect, test } from 'vitest';
-import { describeWithStorage } from './util.js';
+import { describe, expect, test } from 'vitest';
+import { describeWithStorage, StorageVersionTestContext } from './util.js';
 import { WalStreamTestContext, withMaxWalSize } from './wal_stream_utils.js';
-import { JSONBig } from '@powersync/service-jsonbig';
 
 const BASIC_SYNC_RULES = `
 bucket_definitions:
@@ -20,9 +19,12 @@ describe('wal stream', () => {
   describeWithStorage({ timeout: 20_000 }, defineWalStreamTests);
 });
 
-function defineWalStreamTests(factory: storage.TestStorageFactory) {
+function defineWalStreamTests({ factory, storageVersion }: StorageVersionTestContext) {
+  const openContext = (options?: Parameters<typeof WalStreamTestContext.open>[1]) => {
+    return WalStreamTestContext.open(factory, { ...options, storageVersion });
+  };
   test('replicating basic values', async () => {
-    await using context = await WalStreamTestContext.open(factory);
+    await using context = await openContext();
     const { pool } = context;
     await context.updateSyncRules(`
 bucket_definitions:
@@ -57,7 +59,7 @@ bucket_definitions:
   });
 
   test('replicating case sensitive table', async () => {
-    await using context = await WalStreamTestContext.open(factory);
+    await using context = await openContext();
     const { pool } = context;
     await context.updateSyncRules(`
       bucket_definitions:
@@ -88,7 +90,7 @@ bucket_definitions:
   });
 
   test('replicating TOAST values', async () => {
-    await using context = await WalStreamTestContext.open(factory);
+    await using context = await openContext();
     const { pool } = context;
     await context.updateSyncRules(`
       bucket_definitions:
@@ -103,7 +105,6 @@ bucket_definitions:
     );
 
     await context.replicateSnapshot();
-    context.startStreaming();
 
     // Must be > 8kb after compression
     const largeDescription = crypto.randomBytes(20_000).toString('hex');
@@ -126,7 +127,7 @@ bucket_definitions:
   });
 
   test('replicating TRUNCATE', async () => {
-    await using context = await WalStreamTestContext.open(factory);
+    await using context = await openContext();
     const { pool } = context;
     const syncRuleContent = `
 bucket_definitions:
@@ -157,7 +158,7 @@ bucket_definitions:
   });
 
   test('replicating changing primary key', async () => {
-    await using context = await WalStreamTestContext.open(factory);
+    await using context = await openContext();
     const { pool } = context;
     await context.updateSyncRules(BASIC_SYNC_RULES);
     await pool.query(`DROP TABLE IF EXISTS test_data`);
@@ -198,7 +199,7 @@ bucket_definitions:
   });
 
   test('initial sync', async () => {
-    await using context = await WalStreamTestContext.open(factory);
+    await using context = await openContext();
     const { pool } = context;
     await context.updateSyncRules(BASIC_SYNC_RULES);
 
@@ -210,14 +211,13 @@ bucket_definitions:
     );
 
     await context.replicateSnapshot();
-    context.startStreaming();
 
     const data = await context.getBucketData('global[]');
     expect(data).toMatchObject([putOp('test_data', { id: test_id, description: 'test1' })]);
   });
 
   test('record too large', async () => {
-    await using context = await WalStreamTestContext.open(factory);
+    await using context = await openContext();
     await context.updateSyncRules(`bucket_definitions:
       global:
         data:
@@ -242,8 +242,6 @@ bucket_definitions:
       params: [{ type: 'varchar', value: largeDescription }]
     });
 
-    context.startStreaming();
-
     const data = await context.getBucketData('global[]');
     expect(data.length).toEqual(1);
     const row = JSON.parse(data[0].data as string);
@@ -254,7 +252,7 @@ bucket_definitions:
   });
 
   test('table not in sync rules', async () => {
-    await using context = await WalStreamTestContext.open(factory);
+    await using context = await openContext();
     const { pool } = context;
     await context.updateSyncRules(BASIC_SYNC_RULES);
 
@@ -280,7 +278,7 @@ bucket_definitions:
 
   test('reporting slot issues', async () => {
     {
-      await using context = await WalStreamTestContext.open(factory);
+      await using context = await openContext();
       const { pool } = context;
       await context.updateSyncRules(`
 bucket_definitions:
@@ -295,7 +293,6 @@ bucket_definitions:
         `INSERT INTO test_data(id, description) VALUES('8133cd37-903b-4937-a022-7c8294015a3a', 'test1') returning id as test_id`
       );
       await context.replicateSnapshot();
-      context.startStreaming();
 
       const data = await context.getBucketData('global[]');
 
@@ -310,7 +307,7 @@ bucket_definitions:
     }
 
     {
-      await using context = await WalStreamTestContext.open(factory, { doNotClear: true });
+      await using context = await openContext({ doNotClear: true });
       const { pool } = context;
       await pool.query('DROP PUBLICATION powersync');
       await pool.query(`UPDATE test_data SET description = 'updated'`);
@@ -320,15 +317,12 @@ bucket_definitions:
 
       await context.loadActiveSyncRules();
 
-      // Previously, the `replicateSnapshot` call picked up on this error.
-      // Now, we have removed that check, this only comes up when we start actually streaming.
-      // We don't get the streaming response directly here, but getCheckpoint() checks for that.
-      await context.replicateSnapshot();
-      context.startStreaming();
+      // Note: The actual error may be thrown either in replicateSnapshot(), or in getCheckpoint().
 
       if (serverVersion!.compareMain('18.0.0') >= 0) {
         // No error expected in Postres 18. Replication keeps on working depite the
         // publication being re-created.
+        await context.replicateSnapshot();
         await context.getCheckpoint();
       } else {
         // await context.getCheckpoint();
@@ -336,16 +330,16 @@ bucket_definitions:
         // In the service, this error is handled in WalStreamReplicationJob,
         // creating a new replication slot.
         await expect(async () => {
+          await context.replicateSnapshot();
           await context.getCheckpoint();
         }).rejects.toThrowError(MissingReplicationSlotError);
-        context.clearStreamError();
       }
     }
   });
 
   test('dropped replication slot', async () => {
     {
-      await using context = await WalStreamTestContext.open(factory);
+      await using context = await openContext();
       const { pool } = context;
       await context.updateSyncRules(`
 bucket_definitions:
@@ -360,7 +354,6 @@ bucket_definitions:
         `INSERT INTO test_data(id, description) VALUES('8133cd37-903b-4937-a022-7c8294015a3a', 'test1') returning id as test_id`
       );
       await context.replicateSnapshot();
-      context.startStreaming();
 
       const data = await context.getBucketData('global[]');
 
@@ -375,7 +368,7 @@ bucket_definitions:
     }
 
     {
-      await using context = await WalStreamTestContext.open(factory, { doNotClear: true });
+      await using context = await openContext({ doNotClear: true });
       const { pool } = context;
       const storage = await context.factory.getActiveStorage();
 
@@ -396,7 +389,7 @@ bucket_definitions:
   });
 
   test('replication slot lost', async () => {
-    await using baseContext = await WalStreamTestContext.open(factory, { doNotClear: true });
+    await using baseContext = await openContext({ doNotClear: true });
 
     const serverVersion = await baseContext.connectionManager.getServerVersion();
     if (serverVersion!.compareMain('13.0.0') < 0) {
@@ -408,7 +401,7 @@ bucket_definitions:
     await using s = await withMaxWalSize(baseContext.pool, '100MB');
 
     {
-      await using context = await WalStreamTestContext.open(factory);
+      await using context = await openContext();
       const { pool } = context;
       await context.updateSyncRules(`
 bucket_definitions:
@@ -423,7 +416,6 @@ bucket_definitions:
         `INSERT INTO test_data(id, description) VALUES('8133cd37-903b-4937-a022-7c8294015a3a', 'test1') returning id as test_id`
       );
       await context.replicateSnapshot();
-      context.startStreaming();
 
       const data = await context.getBucketData('global[]');
 
@@ -438,7 +430,7 @@ bucket_definitions:
     }
 
     {
-      await using context = await WalStreamTestContext.open(factory, { doNotClear: true });
+      await using context = await openContext({ doNotClear: true });
       const { pool } = context;
       const storage = await context.factory.getActiveStorage();
       const slotName = storage?.slot_name!;
@@ -479,7 +471,7 @@ bucket_definitions:
   });
 
   test('old date format', async () => {
-    await using context = await WalStreamTestContext.open(factory);
+    await using context = await openContext();
     await context.updateSyncRules(BASIC_SYNC_RULES);
 
     const { pool } = context;
@@ -494,7 +486,7 @@ bucket_definitions:
   });
 
   test('new date format', async () => {
-    await using context = await WalStreamTestContext.open(factory);
+    await using context = await openContext();
     await context.updateSyncRules(`
 streams:
   stream:
@@ -510,12 +502,12 @@ config:
     await context.initializeReplication();
     await pool.query(`INSERT INTO test_data(id, description) VALUES ('t1', '2025-09-10 15:17:14+02')`);
 
-    const data = await context.getBucketData('1#stream|0[]');
+    const data = await context.getBucketData('stream|0[]');
     expect(data).toMatchObject([putOp('test_data', { id: 't1', description: '2025-09-10T13:17:14.000000Z' })]);
   });
 
   test('custom types', async () => {
-    await using context = await WalStreamTestContext.open(factory);
+    await using context = await openContext();
 
     await context.updateSyncRules(`
 streams:
@@ -542,7 +534,7 @@ config:
       `INSERT INTO test_data(id, description, ts) VALUES ('t2', ROW(TRUE, 2)::composite, '2025-11-17T09:12:00Z')`
     );
 
-    const data = await context.getBucketData('1#stream|0[]');
+    const data = await context.getBucketData('stream|0[]');
     expect(data).toMatchObject([
       putOp('test_data', { id: 't1', description: '{"foo":1,"bar":1}', ts: '2025-11-17T09:11:00.000000Z' }),
       putOp('test_data', { id: 't2', description: '{"foo":1,"bar":2}', ts: '2025-11-17T09:12:00.000000Z' })
@@ -550,7 +542,7 @@ config:
   });
 
   test('custom types in primary key', async () => {
-    await using context = await WalStreamTestContext.open(factory);
+    await using context = await openContext();
 
     await context.updateSyncRules(`
 streams:
@@ -569,14 +561,14 @@ config:
     await context.initializeReplication();
     await pool.query(`INSERT INTO test_data(id) VALUES ('t1')`);
 
-    const data = await context.getBucketData('1#stream|0[]');
+    const data = await context.getBucketData('stream|0[]');
     expect(data).toMatchObject([putOp('test_data', { id: 't1' })]);
   });
 
   test('replica identity handling', async () => {
     // This specifically test a case of timestamps being used as part of the replica identity.
     // There was a regression in versions 1.15.0-1.15.5, which this tests for.
-    await using context = await WalStreamTestContext.open(factory);
+    await using context = await openContext();
     const { pool } = context;
     await context.updateSyncRules(BASIC_SYNC_RULES);
 
@@ -591,7 +583,6 @@ config:
     );
 
     await context.replicateSnapshot();
-    context.startStreaming();
 
     await pool.query(`UPDATE test_data SET description = 'test2' WHERE id = '${test_id}'`);