@powersync/service-module-mongodb-storage 0.0.0-dev-20260803144812 → 0.0.0-dev-20260929095716

package/test/src/connection_config.test.ts

@@ -0,0 +1,159 @@
+import { mongoTestStorageFactoryGenerator } from '@module/utils/test-utils.js';
+import { SqlSyncConfigParser, updateSyncRulesFromConfig } from '@powersync/service-core';
+import { test_utils } from '@powersync/service-core-tests';
+import {
+  AdditionalSyncConfigParser,
+  normalizeConnectionConfig,
+  PrecompiledSyncConfig
+} from '@powersync/service-sync-rules';
+import { describe, expect, test } from 'vitest';
+import { env } from './env.js';
+import { TEST_STORAGE_VERSIONS } from './util.js';
+
+const STREAMS = /* yaml */ `
+  config:
+    edition: 3
+  streams:
+    orders:
+      query: SELECT * FROM orders
+`;
+const CONFIGURED = /* yaml */ `
+  config:
+    edition: 3
+    connections:
+      default:
+        type: example
+        tables:
+          orders:
+            sample: 10
+  streams:
+    orders:
+      query: SELECT * FROM orders
+`;
+
+// A small module-owned option exercises persistence without introducing MongoDB filter syntax into core.
+const TABLE_OPTIONS: AdditionalSyncConfigParser = {
+  id: 'example.tables',
+  extendJsonSchema({ schema }) {
+    const map = (schema.properties as any).config.properties.connections;
+    map.additionalProperties = {
+      if: { type: 'object', required: ['type'], properties: { type: { const: 'example' } } },
+      then: {
+        type: 'object',
+        additionalProperties: false,
+        required: ['type'],
+        properties: {
+          type: { const: 'example' },
+          tables: {
+            type: 'object',
+            additionalProperties: {
+              type: 'object',
+              additionalProperties: false,
+              properties: { sample: { type: 'number' } }
+            }
+          }
+        }
+      },
+      else: map.additionalProperties
+    };
+  },
+  parse({ config, context }) {
+    const connections = normalizeConnectionConfig(
+      (config as { config?: { connections?: unknown } }).config?.connections
+    );
+    for (const [tag, connection] of Object.entries(connections)) {
+      if (connection?.type != 'example') continue;
+      context.parsedConfig.connectionConfig = { ...context.parsedConfig.connectionConfig, [tag]: connection };
+      const { plan } = context.parsedConfig as PrecompiledSyncConfig;
+      plan.moduleData = { ...plan.moduleData, ['example.tables']: null };
+    }
+  }
+};
+
+function storageFactory(withModule: boolean) {
+  const syncConfigParser = new SqlSyncConfigParser(withModule ? [TABLE_OPTIONS] : []);
+  return mongoTestStorageFactoryGenerator({
+    url: env.MONGO_TEST_URL,
+    isCI: env.CI,
+    supportsMultipleSyncConfigs: true,
+    syncConfigParser
+  });
+}
+
+describe.for(TEST_STORAGE_VERSIONS)('connection config with storage v%i', (storageVersion) => {
+  test('preserves module options across closing storage and loading its compiled plan', async () => {
+    let expected;
+    {
+      await using factory = await storageFactory(true).factory();
+      const parsed = factory.syncConfigParser.parseContent(CONFIGURED, test_utils.PARSE_OPTIONS);
+      expected = parsed.config.connectionConfig;
+      await factory.updateSyncRules(updateSyncRulesFromConfig(parsed, { storageVersion }));
+    }
+
+    // Reopen the same database without clearing it, as a service restart would.
+    await using reopened = await storageFactory(true).factory({ doNotClear: true });
+    const deploying = (await reopened.getDeployingSyncConfig())!;
+    expect(deploying.content.compiled_plan?.plan.version).toBe(3);
+    const parsed = deploying.content.parsed(test_utils.PARSE_OPTIONS);
+    expect(parsed.syncConfigs[0].config.connectionConfig).toEqual(expected);
+    expect(parsed.hydratedSyncConfig.connectionConfig).toEqual(expected);
+  });
+
+  test('rejects saved options if the module is absent after restart', async () => {
+    {
+      await using factory = await storageFactory(true).factory();
+      await factory.updateSyncRules(
+        updateSyncRulesFromConfig(factory.syncConfigParser.parseContent(CONFIGURED, test_utils.PARSE_OPTIONS), {
+          storageVersion
+        })
+      );
+    }
+    await using reopened = await storageFactory(false).factory({ doNotClear: true });
+    const deploying = (await reopened.getDeployingSyncConfig())!;
+    expect(() => deploying.content.parsed(test_utils.PARSE_OPTIONS)).toThrow(
+      'Missing required sync config parsers: example.tables'
+    );
+  });
+
+  test('continues loading unfiltered plans without an additional parser', async () => {
+    await using factory = await storageFactory(false).factory();
+    await factory.updateSyncRules(
+      updateSyncRulesFromConfig(factory.syncConfigParser.parseContent(STREAMS, test_utils.PARSE_OPTIONS), {
+        storageVersion
+      })
+    );
+    const deploying = (await factory.getDeployingSyncConfig())!;
+    expect(deploying.content.compiled_plan?.plan.version).toBe(1);
+    expect(deploying.content.parsed(test_utils.PARSE_OPTIONS).hydratedSyncConfig.connectionConfig).toEqual({});
+  });
+
+  test('starts replacement processing when connection options change', async () => {
+    await using factory = await storageFactory(true).factory();
+    const deploy = (yaml: string) =>
+      factory.updateSyncRules(
+        updateSyncRulesFromConfig(factory.syncConfigParser.parseContent(yaml, test_utils.PARSE_OPTIONS), {
+          storageVersion
+        })
+      );
+    const first = await deploy(CONFIGURED);
+    {
+      // Activate the first config so compatibility is checked against data already being served.
+      const storage = await test_utils.getTestStorage(factory, first);
+      await using writer = await storage.createWriter(test_utils.BATCH_OPTIONS);
+      await writer.markAllSnapshotDone('1/1');
+      await writer.commit('1/1');
+    }
+    if (storageVersion >= 3) {
+      // SQL-only edits can share source data when the connection options are identical.
+      const sameOptions = await deploy(CONFIGURED.replace('SELECT * FROM orders', 'SELECT id FROM orders'));
+      expect(sameOptions.replicationStreamId).toBe(first.replicationStreamId);
+      const storage = await test_utils.getTestStorage(factory, sameOptions);
+      await using writer = await storage.createWriter(test_utils.BATCH_OPTIONS);
+      await writer.markAllSnapshotDone('2/1');
+      await writer.commit('2/1');
+    }
+    const changed = await deploy(CONFIGURED.replace('sample: 10', 'sample: 20'));
+    expect(changed.replicationStreamId).not.toBe(first.replicationStreamId);
+    expect((await factory.getActiveSyncConfig())?.content.replicationStreamId).toBe(first.replicationStreamId);
+  });
+});

package/test/src/helpers/MemoryObjectStorage.ts

@@ -1,5 +1,6 @@
 import {
   ObjectStorage,
+  ObjectStorageOperationOptions,
   ObjectStoragePutMetadata
 } from '@module/storage/implementation/v3/object-storage/ObjectStorage.js';
 
@@ -9,13 +10,19 @@ export class MemoryObjectStorage implements ObjectStorage {
    */
   public readonly store = new Map<string, { data: Uint8Array; metadata: ObjectStoragePutMetadata }>();
 
-  async put(path: string, data: Uint8Array, metadata: ObjectStoragePutMetadata): Promise<void> {
+  async put(
+    path: string,
+    data: Uint8Array,
+    metadata: ObjectStoragePutMetadata,
+    options?: ObjectStorageOperationOptions
+  ): Promise<void> {
+    options?.signal?.throwIfAborted();
     this.store.set(path, { data, metadata: metadata });
   }
 
   async get(
     path: string,
-    options?: { signal?: AbortSignal }
+    options?: ObjectStorageOperationOptions
   ): Promise<{ data: Uint8Array; metadata: ObjectStoragePutMetadata }> {
     const signal = options?.signal;
     signal?.throwIfAborted();
@@ -26,7 +33,7 @@ export class MemoryObjectStorage implements ObjectStorage {
     return data;
   }
 
-  async *list(prefix: string, options?: { signal?: AbortSignal }): AsyncIterable<string> {
+  async *list(prefix: string, options?: ObjectStorageOperationOptions): AsyncIterable<string> {
     const signal = options?.signal;
     for (const path of this.store.keys()) {
       signal?.throwIfAborted();
@@ -36,18 +43,19 @@ export class MemoryObjectStorage implements ObjectStorage {
     }
   }
 
-  async delete(paths: string[]): Promise<void> {
+  async delete(paths: string[], options?: ObjectStorageOperationOptions): Promise<void> {
+    options?.signal?.throwIfAborted();
     for (const p of paths) {
       this.store.delete(p);
     }
   }
 
-  async deletePrefix(prefix: string, options?: { signal?: AbortSignal }): Promise<{ objectCount: number }> {
+  async deletePrefix(prefix: string, options?: ObjectStorageOperationOptions): Promise<{ objectCount: number }> {
     const paths: string[] = [];
     for await (const path of this.list(prefix, options)) {
       paths.push(path);
     }
-    await this.delete(paths);
+    await this.delete(paths, options);
     return { objectCount: paths.length };
   }
 }

package/test/src/helpers/concurrentWriter.mjs

@@ -0,0 +1,29 @@
+import { storage } from '@powersync/service-core';
+import { test_utils } from '@powersync/service-core-tests';
+import { mongoTestStorageFactoryGenerator } from '../../../dist/utils/test-utils.js';
+
+// A separate process exercises the database protocol without sharing any mutex,
+// allocator, MongoClient, or lease object with the test runner.
+async function main() {
+  const factoryGen = mongoTestStorageFactoryGenerator({ url: process.argv[2], isCI: true });
+  await using factory = await factoryGen.factory({ doNotClear: true });
+  const streamId = Number(process.argv[3]);
+  const stream = (await factory.getReplicatingReplicationStreams()).find((s) => s.replicationStreamId === streamId);
+  const lock = await stream.lock();
+  await using lockLifetime = { [Symbol.asyncDispose]: () => lock.release() };
+  const bucketStorage = factory.getInstance(stream, { replicationLock: lock });
+  await using writer = await bucketStorage.createWriter(test_utils.BATCH_OPTIONS);
+  const table = await test_utils.resolveTestTable(writer, 'items', ['id'], factoryGen, streamId);
+  await writer.save({
+    sourceTable: table,
+    tag: storage.SaveOperationTag.INSERT,
+    after: { id: 'child', description: 'child' },
+    afterReplicaId: test_utils.rid('child')
+  });
+  await writer.commit('1/2');
+  console.log(`checkpoint=${(await bucketStorage.getCheckpoint()).checkpoint}`);
+}
+
+await main();
+// Workspace test utilities start background timers. Exit after all resources are disposed.
+process.exit(0);

package/test/src/helpers/s3TestFactory.ts

@@ -4,7 +4,7 @@ import { mongoTestStorageFactoryGenerator } from '@module/utils/test-utils.js';
 import { randomUUID } from 'node:crypto';
 import { MemoryObjectStorage } from './MemoryObjectStorage.js';
 
-const minioStorages: S3ObjectStorage[] = [];
+const rustfsStorages: S3ObjectStorage[] = [];
 
 export interface S3TestFactoryOptions {
   url: string;
@@ -26,24 +26,24 @@ function createTestStorageSuite(options: S3TestFactoryOptions, objectStorage: Ob
 
 /**
  * Creates an ObjectStorage instance for S3 tests.
- * Set MINIO_ENDPOINT to switch all S3 tests from MemoryObjectStorage
- * to a real MinIO/S3 endpoint.
- *   MINIO_ENDPOINT=http://localhost:9000
+ * Set RUSTFS_ENDPOINT to switch all S3 tests from MemoryObjectStorage
+ * to a real RustFS/S3 endpoint.
+ *   RUSTFS_ENDPOINT=http://localhost:9000
  */
 export function createS3TestStorageSuite(options: S3TestFactoryOptions) {
-  const minioEndpoint = process.env.MINIO_ENDPOINT;
+  const rustfsEndpoint = process.env.RUSTFS_ENDPOINT;
   let objectStorage: ObjectStorage;
-  if (minioEndpoint) {
+  if (rustfsEndpoint) {
     const s3 = new S3ObjectStorage({
       bucket: 'powersync-s3-test',
       region: 'us-east-1',
       prefix: `test-${process.pid}-${randomUUID()}`,
-      endpoint: minioEndpoint,
+      endpoint: rustfsEndpoint,
       forcePathStyle: true,
-      accessKeyId: process.env.MINIO_ACCESS_KEY ?? 'minioadmin',
-      secretAccessKey: process.env.MINIO_SECRET_KEY ?? 'minioadmin'
+      accessKeyId: process.env.RUSTFS_ACCESS_KEY ?? 'rustfsadmin',
+      secretAccessKey: process.env.RUSTFS_SECRET_KEY ?? 'rustfsadmin'
     });
-    minioStorages.push(s3);
+    rustfsStorages.push(s3);
     objectStorage = s3;
   } else {
     objectStorage = new MemoryObjectStorage();
@@ -52,9 +52,9 @@ export function createS3TestStorageSuite(options: S3TestFactoryOptions) {
   return createTestStorageSuite(options, objectStorage);
 }
 
-/** Remove all objects created by MinIO-backed suites in the current test. */
+/** Remove all objects created by RustFS-backed suites in the current test. */
 export async function cleanupS3TestStorage(): Promise<void> {
-  for (const storage of minioStorages.splice(0)) {
+  for (const storage of rustfsStorages.splice(0)) {
     await storage.deletePrefix('bucket-data/');
   }
 }

package/test/src/object_storage_usage.test.ts

@@ -0,0 +1,268 @@
+import { MongoSyncBucketStorage } from '@module/storage/implementation/createMongoSyncBucketStorage.js';
+import { BucketDataDocumentV3, ObjectStorageUsageDocument } from '@module/storage/implementation/v3/models.js';
+import {
+  OBJECT_STORAGE_USAGE_BASE_WRITER_ID,
+  ObjectStorageUsage
+} from '@module/storage/implementation/v3/object-storage/ObjectStorageUsage.js';
+import { VersionedPowerSyncMongoV3 } from '@module/storage/implementation/v3/VersionedPowerSyncMongoV3.js';
+import * as lib_mongo from '@powersync/lib-service-mongodb';
+import { mongo } from '@powersync/lib-service-mongodb';
+import { updateSyncRulesFromYaml } from '@powersync/service-core';
+import { getTestStorage } from '@powersync/service-core-tests';
+import { BucketDefinitionId } from '@powersync/service-sync-rules';
+import { describe, expect, test } from 'vitest';
+import { INITIALIZED_MONGO_STORAGE_FACTORY } from './util.js';
+
+const SYNC_RULES_YAML = `
+bucket_definitions:
+  global:
+    data:
+      - SELECT id FROM items
+`;
+
+type UsageContext = {
+  db: VersionedPowerSyncMongoV3;
+  bucketStorage: MongoSyncBucketStorage;
+  definitionId: BucketDefinitionId;
+};
+
+type UsageEntry = {
+  definition_id: BucketDefinitionId;
+  active_bytes: bigint;
+};
+
+async function withUsageContext<T>(callback: (context: UsageContext) => Promise<T>): Promise<T> {
+  await using factory = await INITIALIZED_MONGO_STORAGE_FACTORY.factory();
+  const syncRules = await factory.updateSyncRules(updateSyncRulesFromYaml(SYNC_RULES_YAML, { storageVersion: 3 }));
+  const bucketStorage = (await getTestStorage(factory, syncRules)) as MongoSyncBucketStorage;
+  const db = bucketStorage.db as VersionedPowerSyncMongoV3;
+  const definitionId = syncRules.syncConfigContent[0].mapping.allBucketDefinitionIds()[0];
+  return callback({ db, bucketStorage, definitionId });
+}
+
+async function withTransaction<T>(
+  db: VersionedPowerSyncMongoV3,
+  callback: (session: mongo.ClientSession) => Promise<T>
+): Promise<T> {
+  const session = db.client.startSession();
+  try {
+    return await session.withTransaction(() => callback(session));
+  } finally {
+    await session.endSession();
+  }
+}
+
+async function readUsageEntries(
+  db: VersionedPowerSyncMongoV3,
+  replicationStreamId: number,
+  session?: mongo.ClientSession
+): Promise<UsageEntry[]> {
+  const entries = await db.objectStorageUsage
+    .aggregate<{ _id: BucketDefinitionId; active_bytes: bigint }>(
+      [
+        { $match: { '_id.g': replicationStreamId } },
+        { $project: { definitions: { $objectToArray: '$definitions' } } },
+        { $unwind: '$definitions' },
+        { $group: { _id: '$definitions.k', active_bytes: { $sum: '$definitions.v' } } }
+      ],
+      { session, readConcern: 'snapshot' }
+    )
+    .toArray()
+    .catch((error) => {
+      if (lib_mongo.isMongoNamespaceNotFoundError(error)) {
+        return [];
+      }
+      throw error;
+    });
+
+  return entries.map((entry) => ({
+    definition_id: entry._id,
+    active_bytes: BigInt(entry.active_bytes ?? 0)
+  }));
+}
+
+function usageDocument(
+  replicationStreamId: number,
+  writerId: string,
+  definitions: Record<string, bigint>,
+  updatedAt = new Date(0)
+): ObjectStorageUsageDocument {
+  return {
+    _id: { g: replicationStreamId, w: writerId },
+    updated_at: updatedAt,
+    definitions
+  };
+}
+
+function bucketDataDocument(
+  replicationStreamId: number,
+  definitionId: BucketDefinitionId,
+  fileSize: number
+): BucketDataDocumentV3 {
+  return {
+    _id: { b: `${replicationStreamId}-${definitionId}`, o: 1n },
+    min_op: 1n,
+    checksum: 1n,
+    count: 1,
+    size: fileSize,
+    storage_ref: {
+      path: `bucket-data/${replicationStreamId}/${definitionId}/1.bson`,
+      file_size: fileSize
+    }
+  };
+}
+
+describe('ObjectStorageUsage', () => {
+  test('counts a committed reference exactly once after an aborted transaction is retried', async () => {
+    await withUsageContext(async ({ db, bucketStorage, definitionId }) => {
+      const replicationStreamId = bucketStorage.replicationStreamId;
+      const writerId = 'replication-writer';
+      const usage = new ObjectStorageUsage(db, replicationStreamId, writerId);
+      const bucketData = db.bucketData(replicationStreamId, definitionId);
+      const document = bucketDataDocument(replicationStreamId, definitionId, 123);
+
+      await expect(
+        withTransaction(db, async (session) => {
+          await bucketData.insertOne(document, { session });
+          const writes = db.createWriteBatch(session, { ordered: false });
+          usage.applyDelta(definitionId, 123n, writes);
+          await writes.execute();
+          throw new Error('abort this attempt');
+        })
+      ).rejects.toThrow('abort this attempt');
+
+      await withTransaction(db, async (session) => {
+        await bucketData.insertOne(document, { session });
+        const writes = db.createWriteBatch(session, { ordered: false });
+        usage.applyDelta(definitionId, 123n, writes);
+        await writes.execute();
+      });
+
+      expect(await bucketData.countDocuments({ storage_ref: { $exists: true } })).toBe(1);
+      await expect(readUsageEntries(db, replicationStreamId)).resolves.toEqual([
+        { definition_id: definitionId, active_bytes: 123n }
+      ]);
+    });
+  });
+
+  test('snapshot usage reads observe a complete pre-fold view', async () => {
+    await withUsageContext(async ({ db, bucketStorage, definitionId }) => {
+      const replicationStreamId = bucketStorage.replicationStreamId;
+      const usage = new ObjectStorageUsage(db, replicationStreamId);
+      await db.objectStorageUsage.insertMany([
+        usageDocument(replicationStreamId, OBJECT_STORAGE_USAGE_BASE_WRITER_ID, { [definitionId]: 100n }),
+        usageDocument(replicationStreamId, 'replication', { [definitionId]: 20n }),
+        usageDocument(replicationStreamId, 'compactor', { [definitionId]: -5n })
+      ]);
+
+      const readSession = db.client.startSession();
+      try {
+        readSession.startTransaction({ readConcern: { level: 'snapshot' } });
+        await db.objectStorageUsage.findOne(
+          { _id: { g: replicationStreamId, w: OBJECT_STORAGE_USAGE_BASE_WRITER_ID } },
+          { session: readSession }
+        );
+
+        await usage.foldStaleWriterDeltas({ staleWriterMs: 0 });
+        const entries = await readUsageEntries(db, replicationStreamId, readSession);
+
+        await readSession.commitTransaction();
+        expect(entries).toEqual([{ definition_id: definitionId, active_bytes: 115n }]);
+      } catch (error) {
+        await readSession.abortTransaction().catch(() => undefined);
+        throw error;
+      } finally {
+        await readSession.endSession();
+      }
+
+      await expect(readUsageEntries(db, replicationStreamId)).resolves.toEqual([
+        { definition_id: definitionId, active_bytes: 115n }
+      ]);
+    });
+  });
+
+  test('folding preserves totals across both writer/folder commit orders', async () => {
+    await withUsageContext(async ({ db, bucketStorage, definitionId }) => {
+      const replicationStreamId = bucketStorage.replicationStreamId;
+      const writerId = 'reused-writer';
+      const usage = new ObjectStorageUsage(db, replicationStreamId, writerId);
+
+      await withTransaction(db, async (session) => {
+        const writes = db.createWriteBatch(session, { ordered: false });
+        usage.applyDelta(definitionId, 10n, writes);
+        await writes.execute();
+      });
+      await db.objectStorageUsage.updateOne(
+        { _id: { g: replicationStreamId, w: writerId } },
+        { $set: { updated_at: new Date(0) } }
+      );
+      await usage.foldStaleWriterDeltas({ staleWriterMs: 0 });
+
+      // The folder committed first and deleted the writer shard. The writer's
+      // next transaction must recreate it through the upsert.
+      await withTransaction(db, async (session) => {
+        const writes = db.createWriteBatch(session, { ordered: false });
+        usage.applyDelta(definitionId, 4n, writes);
+        await writes.execute();
+      });
+      expect((await readUsageEntries(db, replicationStreamId))[0].active_bytes).toBe(14n);
+
+      await db.objectStorageUsage.updateOne(
+        { _id: { g: replicationStreamId, w: writerId } },
+        { $set: { updated_at: new Date(0) } }
+      );
+      await usage.foldStaleWriterDeltas({ staleWriterMs: 0 });
+
+      // The writer committed before the folder. Folding the recreated shard
+      // must preserve the same visible total.
+      expect((await readUsageEntries(db, replicationStreamId))[0].active_bytes).toBe(14n);
+    });
+  });
+
+  test('definition cleanup racing a fold removes only that definition, and stream clear is isolated', async () => {
+    await withUsageContext(async ({ db, bucketStorage, definitionId }) => {
+      const replicationStreamId = bucketStorage.replicationStreamId;
+      const otherStreamId = replicationStreamId + 1;
+      const otherDefinitionId = 'other_definition';
+      const usage = new ObjectStorageUsage(db, replicationStreamId);
+
+      await db.objectStorageUsage.insertMany([
+        usageDocument(replicationStreamId, OBJECT_STORAGE_USAGE_BASE_WRITER_ID, {
+          [definitionId]: 3n,
+          [otherDefinitionId]: 7n
+        }),
+        usageDocument(replicationStreamId, 'writer', { [definitionId]: 20n, [otherDefinitionId]: 11n }),
+        usageDocument(otherStreamId, 'other-writer', { [definitionId]: 50n })
+      ]);
+
+      await Promise.all([
+        usage.foldStaleWriterDeltas({ staleWriterMs: 0 }),
+        withTransaction(db, (session) => usage.removeDefinition(definitionId, session))
+      ]);
+
+      await expect(readUsageEntries(db, replicationStreamId)).resolves.toEqual([
+        { definition_id: otherDefinitionId, active_bytes: 18n }
+      ]);
+
+      await withTransaction(db, async (session) => {
+        await new ObjectStorageUsage(db, otherStreamId).removeStream(session);
+      });
+      await db.objectStorageUsage.insertOne(usageDocument(otherStreamId, 'other-writer', { [definitionId]: 50n }));
+
+      await withTransaction(db, async (session) => {
+        await usage.removeStream(session);
+      });
+
+      await expect(ObjectStorageUsage.readAllDefinitionUsage(db)).resolves.toEqual([
+        { replication_stream_id: otherStreamId, definition_id: definitionId, active_bytes: 50n }
+      ]);
+    });
+  });
+
+  test('returns no entries for an absent usage collection', async () => {
+    await withUsageContext(async ({ db, bucketStorage }) => {
+      await db.objectStorageUsage.drop().catch(() => undefined);
+      await expect(readUsageEntries(db, bucketStorage.replicationStreamId)).resolves.toEqual([]);
+    });
+  });
+});