@powersync/service-module-postgres 0.0.0-dev-20250507154604 → 0.0.0-dev-20250611110033

package/test/src/slow_tests.test.ts

@@ -5,9 +5,8 @@ import { env } from './env.js';
 import {
   clearTestDb,
   connectPgPool,
+  describeWithStorage,
   getClientCheckpoint,
-  INITIALIZED_MONGO_STORAGE_FACTORY,
-  INITIALIZED_POSTGRES_STORAGE_FACTORY,
   TEST_CONNECTION_OPTIONS
 } from './util.js';
 
@@ -21,26 +20,10 @@ 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';
 
-describe.skipIf(!env.TEST_MONGO_STORAGE)('slow tests - mongodb', function () {
-  // These are slow, inconsistent tests.
-  // Not run on every test run, but we do run on CI, or when manually debugging issues.
-  if (env.CI || env.SLOW_TESTS) {
-    defineSlowTests(INITIALIZED_MONGO_STORAGE_FACTORY);
-  } else {
-    // Need something in this file.
-    test('no-op', () => {});
-  }
-});
-
-describe.skipIf(!env.TEST_POSTGRES_STORAGE)('slow tests - postgres', function () {
-  // These are slow, inconsistent tests.
-  // Not run on every test run, but we do run on CI, or when manually debugging issues.
-  if (env.CI || env.SLOW_TESTS) {
-    defineSlowTests(INITIALIZED_POSTGRES_STORAGE_FACTORY);
-  } else {
-    // Need something in this file.
-    test('no-op', () => {});
-  }
+describe.skipIf(!(env.CI || env.SLOW_TESTS))('slow tests', function () {
+  describeWithStorage({ timeout: 120_000 }, function (factory) {
+    defineSlowTests(factory);
+  });
 });
 
 function defineSlowTests(factory: storage.TestStorageFactory) {
@@ -350,14 +333,14 @@ bucket_definitions:
       const connections = new PgManager(TEST_CONNECTION_OPTIONS, {});
       const replicationConnection = await connections.replicationConnection();
 
-        abortController = new AbortController();
-        const options: WalStreamOptions = {
-          abort_signal: abortController.signal,
-          connections,
-          storage: storage,
-          metrics: METRICS_HELPER.metricsEngine
-        };
-        walStream = new WalStream(options);
+      abortController = new AbortController();
+      const options: WalStreamOptions = {
+        abort_signal: abortController.signal,
+        connections,
+        storage: storage,
+        metrics: METRICS_HELPER.metricsEngine
+      };
+      walStream = new WalStream(options);
 
       await storage.clear();
 

package/test/src/util.ts

@@ -2,11 +2,12 @@ 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, TestStorageOptions } from '@powersync/service-core';
+import { BucketStorageFactory, InternalOpId, TestStorageFactory, TestStorageOptions } 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';
 
 export const TEST_URI = env.PG_TEST_URL;
 
@@ -19,6 +20,16 @@ export const INITIALIZED_POSTGRES_STORAGE_FACTORY = postgres_storage.PostgresTes
   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);
+  });
+
+  describe.skipIf(!env.TEST_POSTGRES_STORAGE)(`postgres storage`, options, function () {
+    fn(INITIALIZED_POSTGRES_STORAGE_FACTORY);
+  });
+}
+
 export const TEST_CONNECTION_OPTIONS = types.normalizeConnectionConfig({
   type: 'postgresql',
   uri: TEST_URI,

package/test/src/validation.test.ts

@@ -1,7 +1,6 @@
 import { getDebugTablesInfo } from '@module/replication/replication-utils.js';
 import { expect, test } from 'vitest';
 
-// Not quite a walStreamTest, but it helps to manage the connection
 import { INITIALIZED_MONGO_STORAGE_FACTORY } from './util.js';
 import { WalStreamTestContext } from './wal_stream_utils.js';
 

package/test/src/wal_stream.test.ts

@@ -2,12 +2,11 @@ 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 { ReplicationMetric } from '@powersync/service-types';
 import * as crypto from 'crypto';
 import { describe, expect, test } from 'vitest';
-import { env } from './env.js';
-import { INITIALIZED_MONGO_STORAGE_FACTORY, INITIALIZED_POSTGRES_STORAGE_FACTORY } from './util.js';
+import { describeWithStorage } from './util.js';
 import { WalStreamTestContext } from './wal_stream_utils.js';
-import { ReplicationMetric } from '@powersync/service-types';
 
 const BASIC_SYNC_RULES = `
 bucket_definitions:
@@ -16,12 +15,8 @@ bucket_definitions:
       - SELECT id, description FROM "test_data"
 `;
 
-describe.skipIf(!env.TEST_MONGO_STORAGE)('wal stream - mongodb', { timeout: 20_000 }, function () {
-  defineWalStreamTests(INITIALIZED_MONGO_STORAGE_FACTORY);
-});
-
-describe.skipIf(!env.TEST_POSTGRES_STORAGE)('wal stream - postgres', { timeout: 20_000 }, function () {
-  defineWalStreamTests(INITIALIZED_POSTGRES_STORAGE_FACTORY);
+describe('wal stream', () => {
+  describeWithStorage({ timeout: 20_000 }, defineWalStreamTests);
 });
 
 function defineWalStreamTests(factory: storage.TestStorageFactory) {

package/test/src/wal_stream_utils.ts

@@ -19,6 +19,7 @@ export class WalStreamTestContext implements AsyncDisposable {
   private streamPromise?: Promise<void>;
   public storage?: SyncRulesBucketStorage;
   private replicationConnection?: pgwire.PgConnection;
+  private snapshotPromise?: Promise<void>;
 
   /**
    * Tests operating on the wal stream need to configure the stream and manage asynchronous
@@ -28,7 +29,7 @@ export class WalStreamTestContext implements AsyncDisposable {
    */
   static async open(
     factory: (options: storage.TestStorageOptions) => Promise<BucketStorageFactory>,
-    options?: { doNotClear?: boolean }
+    options?: { doNotClear?: boolean; walStreamOptions?: Partial<WalStreamOptions> }
   ) {
     const f = await factory({ doNotClear: options?.doNotClear });
     const connectionManager = new PgManager(TEST_CONNECTION_OPTIONS, {});
@@ -37,12 +38,13 @@ export class WalStreamTestContext implements AsyncDisposable {
       await clearTestDb(connectionManager.pool);
     }
 
-    return new WalStreamTestContext(f, connectionManager);
+    return new WalStreamTestContext(f, connectionManager, options?.walStreamOptions);
   }
 
   constructor(
     public factory: BucketStorageFactory,
-    public connectionManager: PgManager
+    public connectionManager: PgManager,
+    private walStreamOptions?: Partial<WalStreamOptions>
   ) {
     createCoreReplicationMetrics(METRICS_HELPER.metricsEngine);
     initializeCoreReplicationMetrics(METRICS_HELPER.metricsEngine);
@@ -54,6 +56,7 @@ export class WalStreamTestContext implements AsyncDisposable {
 
   async dispose() {
     this.abortController.abort();
+    await this.snapshotPromise;
     await this.streamPromise;
     await this.connectionManager.destroy();
     await this.factory?.[Symbol.asyncDispose]();
@@ -108,16 +111,21 @@ export class WalStreamTestContext implements AsyncDisposable {
       storage: this.storage,
       metrics: METRICS_HELPER.metricsEngine,
       connections: this.connectionManager,
-      abort_signal: this.abortController.signal
+      abort_signal: this.abortController.signal,
+      ...this.walStreamOptions
     };
     this._walStream = new WalStream(options);
     return this._walStream!;
   }
 
   async replicateSnapshot() {
-    this.replicationConnection = await this.connectionManager.replicationConnection();
-    await this.walStream.initReplication(this.replicationConnection);
-    await this.storage!.autoActivate();
+    const promise = (async () => {
+      this.replicationConnection = await this.connectionManager.replicationConnection();
+      await this.walStream.initReplication(this.replicationConnection);
+      await this.storage!.autoActivate();
+    })();
+    this.snapshotPromise = promise.catch((e) => e);
+    await promise;
   }
 
   startStreaming() {