@powersync/service-core 1.20.0 → 1.20.2

package/test/src/checksum_cache.test.ts

@@ -1,7 +1,9 @@
 import { ChecksumCache, FetchChecksums, FetchPartialBucketChecksum } from '@/storage/ChecksumCache.js';
 import { addChecksums, BucketChecksum, InternalOpId, PartialChecksum } from '@/util/util-index.js';
+import { BucketDataSource } from '@powersync/service-sync-rules';
 import * as crypto from 'node:crypto';
 import { describe, expect, it } from 'vitest';
+import { removeSource } from './utils.js';
 
 /**
  * Create a deterministic BucketChecksum based on the bucket name and checkpoint for testing purposes.
@@ -67,6 +69,12 @@ describe('checksum cache', function () {
     return new ChecksumCache({ fetchChecksums: fetch });
   };
 
+  const DUMMY_SOURCE: BucketDataSource = null as any;
+
+  function removeLookupSources(lookups: FetchPartialBucketChecksum[]) {
+    return lookups.map((b) => removeSource(b));
+  }
+
   it('should handle a sequential lookups (a)', async function () {
     let lookups: FetchPartialBucketChecksum[][] = [];
     const cache = factory(async (batch) => {
@@ -74,13 +82,13 @@ describe('checksum cache', function () {
       return fetchTestChecksums(batch);
     });
 
-    expect(await cache.getChecksums(123n, ['test'])).toEqual([TEST_123]);
+    expect(await cache.getChecksums(123n, [{ bucket: 'test', source: DUMMY_SOURCE }])).toEqual([TEST_123]);
 
-    expect(await cache.getChecksums(1234n, ['test'])).toEqual([TEST_1234]);
+    expect(await cache.getChecksums(1234n, [{ bucket: 'test', source: DUMMY_SOURCE }])).toEqual([TEST_1234]);
 
-    expect(await cache.getChecksums(123n, ['test2'])).toEqual([TEST2_123]);
+    expect(await cache.getChecksums(123n, [{ bucket: 'test2', source: DUMMY_SOURCE }])).toEqual([TEST2_123]);
 
-    expect(lookups).toEqual([
+    expect(lookups.map(removeLookupSources)).toMatchObject([
       [{ bucket: 'test', end: 123n }],
       // This should use the previous lookup
       [{ bucket: 'test', start: 123n, end: 1234n }],
@@ -96,13 +104,13 @@ describe('checksum cache', function () {
       return fetchTestChecksums(batch);
     });
 
-    expect(await cache.getChecksums(123n, ['test2'])).toEqual([TEST2_123]);
+    expect(await cache.getChecksums(123n, [{ bucket: 'test2', source: DUMMY_SOURCE }])).toEqual([TEST2_123]);
 
-    expect(await cache.getChecksums(1234n, ['test'])).toEqual([TEST_1234]);
+    expect(await cache.getChecksums(1234n, [{ bucket: 'test', source: DUMMY_SOURCE }])).toEqual([TEST_1234]);
 
-    expect(await cache.getChecksums(123n, ['test'])).toEqual([TEST_123]);
+    expect(await cache.getChecksums(123n, [{ bucket: 'test', source: DUMMY_SOURCE }])).toEqual([TEST_123]);
 
-    expect(lookups).toEqual([
+    expect(lookups.map(removeLookupSources)).toEqual([
       // With this order, there is no option for a partial lookup
       [{ bucket: 'test2', end: 123n }],
       [{ bucket: 'test', end: 1234n }],
@@ -117,16 +125,16 @@ describe('checksum cache', function () {
       return fetchTestChecksums(batch);
     });
 
-    const p1 = cache.getChecksums(123n, ['test']);
-    const p2 = cache.getChecksums(1234n, ['test']);
-    const p3 = cache.getChecksums(123n, ['test2']);
+    const p1 = cache.getChecksums(123n, [{ bucket: 'test', source: DUMMY_SOURCE }]);
+    const p2 = cache.getChecksums(1234n, [{ bucket: 'test', source: DUMMY_SOURCE }]);
+    const p3 = cache.getChecksums(123n, [{ bucket: 'test2', source: DUMMY_SOURCE }]);
 
     expect(await p1).toEqual([TEST_123]);
     expect(await p2).toEqual([TEST_1234]);
     expect(await p3).toEqual([TEST2_123]);
 
     // Concurrent requests, so we can't do a partial lookup for 123 -> 1234
-    expect(lookups).toEqual([
+    expect(lookups.map(removeLookupSources)).toEqual([
       [{ bucket: 'test', end: 123n }],
       [{ bucket: 'test', end: 1234n }],
       [{ bucket: 'test2', end: 123n }]
@@ -140,15 +148,15 @@ describe('checksum cache', function () {
       return fetchTestChecksums(batch);
     });
 
-    const p1 = cache.getChecksums(123n, ['test']);
-    const p2 = cache.getChecksums(123n, ['test']);
+    const p1 = cache.getChecksums(123n, [{ bucket: 'test', source: DUMMY_SOURCE }]);
+    const p2 = cache.getChecksums(123n, [{ bucket: 'test', source: DUMMY_SOURCE }]);
 
     expect(await p1).toEqual([TEST_123]);
 
     expect(await p2).toEqual([TEST_123]);
 
     // The lookup should be deduplicated, even though it's in progress
-    expect(lookups).toEqual([[{ bucket: 'test', end: 123n }]]);
+    expect(lookups.map(removeLookupSources)).toEqual([[{ bucket: 'test', end: 123n }]]);
   });
 
   it('should handle serial + concurrent lookups', async function () {
@@ -158,15 +166,15 @@ describe('checksum cache', function () {
       return fetchTestChecksums(batch);
     });
 
-    expect(await cache.getChecksums(123n, ['test'])).toEqual([TEST_123]);
+    expect(await cache.getChecksums(123n, [{ bucket: 'test', source: DUMMY_SOURCE }])).toEqual([TEST_123]);
 
-    const p2 = cache.getChecksums(1234n, ['test']);
-    const p3 = cache.getChecksums(1234n, ['test']);
+    const p2 = cache.getChecksums(1234n, [{ bucket: 'test', source: DUMMY_SOURCE }]);
+    const p3 = cache.getChecksums(1234n, [{ bucket: 'test', source: DUMMY_SOURCE }]);
 
     expect(await p2).toEqual([TEST_1234]);
     expect(await p3).toEqual([TEST_1234]);
 
-    expect(lookups).toEqual([
+    expect(lookups.map(removeLookupSources)).toEqual([
       [{ bucket: 'test', end: 123n }],
       // This lookup is deduplicated
       [{ bucket: 'test', start: 123n, end: 1234n }]
@@ -180,9 +188,14 @@ describe('checksum cache', function () {
       return fetchTestChecksums(batch);
     });
 
-    expect(await cache.getChecksums(123n, ['test', 'test2'])).toEqual([TEST_123, TEST2_123]);
+    expect(
+      await cache.getChecksums(123n, [
+        { bucket: 'test', source: DUMMY_SOURCE },
+        { bucket: 'test2', source: DUMMY_SOURCE }
+      ])
+    ).toEqual([TEST_123, TEST2_123]);
 
-    expect(lookups).toEqual([
+    expect(lookups.map(removeLookupSources)).toEqual([
       [
         // Both lookups in the same request
         { bucket: 'test', end: 123n },
@@ -198,10 +211,15 @@ describe('checksum cache', function () {
       return fetchTestChecksums(batch);
     });
 
-    expect(await cache.getChecksums(123n, ['test'])).toEqual([TEST_123]);
-    expect(await cache.getChecksums(123n, ['test', 'test2'])).toEqual([TEST_123, TEST2_123]);
+    expect(await cache.getChecksums(123n, [{ bucket: 'test', source: DUMMY_SOURCE }])).toEqual([TEST_123]);
+    expect(
+      await cache.getChecksums(123n, [
+        { bucket: 'test', source: DUMMY_SOURCE },
+        { bucket: 'test2', source: DUMMY_SOURCE }
+      ])
+    ).toEqual([TEST_123, TEST2_123]);
 
-    expect(lookups).toEqual([
+    expect(lookups.map(removeLookupSources)).toEqual([
       // Request 1
       [{ bucket: 'test', end: 123n }],
       // Request 2
@@ -216,13 +234,19 @@ describe('checksum cache', function () {
       return fetchTestChecksums(batch);
     });
 
-    const a = cache.getChecksums(123n, ['test', 'test2']);
-    const b = cache.getChecksums(123n, ['test2', 'test3']);
+    const a = cache.getChecksums(123n, [
+      { bucket: 'test', source: DUMMY_SOURCE },
+      { bucket: 'test2', source: DUMMY_SOURCE }
+    ]);
+    const b = cache.getChecksums(123n, [
+      { bucket: 'test2', source: DUMMY_SOURCE },
+      { bucket: 'test3', source: DUMMY_SOURCE }
+    ]);
 
     expect(await a).toEqual([TEST_123, TEST2_123]);
     expect(await b).toEqual([TEST2_123, TEST3_123]);
 
-    expect(lookups).toEqual([
+    expect(lookups.map(removeLookupSources)).toEqual([
       // Request A
       [
         { bucket: 'test', end: 123n },
@@ -240,9 +264,9 @@ describe('checksum cache', function () {
       return fetchTestChecksums(batch);
     });
 
-    expect(await cache.getChecksums(123n, ['test'])).toEqual([TEST_123]);
+    expect(await cache.getChecksums(123n, [{ bucket: 'test', source: DUMMY_SOURCE }])).toEqual([TEST_123]);
 
-    expect(await cache.getChecksums(125n, ['test'])).toEqual([
+    expect(await cache.getChecksums(125n, [{ bucket: 'test', source: DUMMY_SOURCE }])).toEqual([
       {
         bucket: 'test',
         checksum: -1865121912,
@@ -250,14 +274,14 @@ describe('checksum cache', function () {
       }
     ]);
 
-    expect(await cache.getChecksums(124n, ['test'])).toEqual([
+    expect(await cache.getChecksums(124n, [{ bucket: 'test', source: DUMMY_SOURCE }])).toEqual([
       {
         bucket: 'test',
         checksum: 1887460431,
         count: 124
       }
     ]);
-    expect(lookups).toEqual([
+    expect(lookups.map(removeLookupSources)).toEqual([
       [{ bucket: 'test', end: 123n }],
       [{ bucket: 'test', start: 123n, end: 125n }],
       [{ bucket: 'test', start: 123n, end: 124n }]
@@ -275,19 +299,31 @@ describe('checksum cache', function () {
       return fetchTestChecksums(batch);
     });
 
-    const a = cache.getChecksums(123n, ['test', 'test2']);
-    const b = cache.getChecksums(123n, ['test2', 'test3']);
+    const a = cache.getChecksums(123n, [
+      { bucket: 'test', source: DUMMY_SOURCE },
+      { bucket: 'test2', source: DUMMY_SOURCE }
+    ]);
+    const b = cache.getChecksums(123n, [
+      { bucket: 'test2', source: DUMMY_SOURCE },
+      { bucket: 'test3', source: DUMMY_SOURCE }
+    ]);
 
     await expect(a).rejects.toEqual(TEST_ERROR);
     await expect(b).rejects.toEqual(TEST_ERROR);
 
-    const a2 = cache.getChecksums(123n, ['test', 'test2']);
-    const b2 = cache.getChecksums(123n, ['test2', 'test3']);
+    const a2 = cache.getChecksums(123n, [
+      { bucket: 'test', source: DUMMY_SOURCE },
+      { bucket: 'test2', source: DUMMY_SOURCE }
+    ]);
+    const b2 = cache.getChecksums(123n, [
+      { bucket: 'test2', source: DUMMY_SOURCE },
+      { bucket: 'test3', source: DUMMY_SOURCE }
+    ]);
 
     expect(await a2).toEqual([TEST_123, TEST2_123]);
     expect(await b2).toEqual([TEST2_123, TEST3_123]);
 
-    expect(lookups).toEqual([
+    expect(lookups.map(removeLookupSources)).toEqual([
       // Request A (fails)
       [
         { bucket: 'test', end: 123n },
@@ -311,11 +347,15 @@ describe('checksum cache', function () {
       return fetchTestChecksums(batch.filter((b) => b.bucket != 'test'));
     });
 
-    expect(await cache.getChecksums(123n, ['test'])).toEqual([{ bucket: 'test', checksum: 0, count: 0 }]);
-    expect(await cache.getChecksums(123n, ['test', 'test2'])).toEqual([
-      { bucket: 'test', checksum: 0, count: 0 },
-      TEST2_123
+    expect(await cache.getChecksums(123n, [{ bucket: 'test', source: DUMMY_SOURCE }])).toEqual([
+      { bucket: 'test', checksum: 0, count: 0 }
     ]);
+    expect(
+      await cache.getChecksums(123n, [
+        { bucket: 'test', source: DUMMY_SOURCE },
+        { bucket: 'test2', source: DUMMY_SOURCE }
+      ])
+    ).toEqual([{ bucket: 'test', checksum: 0, count: 0 }, TEST2_123]);
   });
 
   it('should handle missing checksums (b)', async function () {
@@ -325,8 +365,10 @@ describe('checksum cache', function () {
       return fetchTestChecksums(batch.filter((b) => b.bucket != 'test' || b.end != 123n));
     });
 
-    expect(await cache.getChecksums(123n, ['test'])).toEqual([{ bucket: 'test', checksum: 0, count: 0 }]);
-    expect(await cache.getChecksums(1234n, ['test'])).toEqual([
+    expect(await cache.getChecksums(123n, [{ bucket: 'test', source: DUMMY_SOURCE }])).toEqual([
+      { bucket: 'test', checksum: 0, count: 0 }
+    ]);
+    expect(await cache.getChecksums(1234n, [{ bucket: 'test', source: DUMMY_SOURCE }])).toEqual([
       {
         bucket: 'test',
         checksum: 1597020602,
@@ -334,7 +376,10 @@ describe('checksum cache', function () {
       }
     ]);
 
-    expect(lookups).toEqual([[{ bucket: 'test', end: 123n }], [{ bucket: 'test', start: 123n, end: 1234n }]]);
+    expect(lookups.map(removeLookupSources)).toEqual([
+      [{ bucket: 'test', end: 123n }],
+      [{ bucket: 'test', start: 123n, end: 1234n }]
+    ]);
   });
 
   it('should use maxSize', async function () {
@@ -347,8 +392,8 @@ describe('checksum cache', function () {
       maxSize: 2
     });
 
-    expect(await cache.getChecksums(123n, ['test'])).toEqual([TEST_123]);
-    expect(await cache.getChecksums(124n, ['test'])).toEqual([
+    expect(await cache.getChecksums(123n, [{ bucket: 'test', source: DUMMY_SOURCE }])).toEqual([TEST_123]);
+    expect(await cache.getChecksums(124n, [{ bucket: 'test', source: DUMMY_SOURCE }])).toEqual([
       {
         bucket: 'test',
         checksum: 1887460431,
@@ -356,30 +401,30 @@ describe('checksum cache', function () {
       }
     ]);
 
-    expect(await cache.getChecksums(125n, ['test'])).toEqual([
+    expect(await cache.getChecksums(125n, [{ bucket: 'test', source: DUMMY_SOURCE }])).toEqual([
       {
         bucket: 'test',
         checksum: -1865121912,
         count: 125
       }
     ]);
-    expect(await cache.getChecksums(126n, ['test'])).toEqual([
+    expect(await cache.getChecksums(126n, [{ bucket: 'test', source: DUMMY_SOURCE }])).toEqual([
       {
         bucket: 'test',
         checksum: -1720007310,
         count: 126
       }
     ]);
-    expect(await cache.getChecksums(124n, ['test'])).toEqual([
+    expect(await cache.getChecksums(124n, [{ bucket: 'test', source: DUMMY_SOURCE }])).toEqual([
       {
         bucket: 'test',
         checksum: 1887460431,
         count: 124
       }
     ]);
-    expect(await cache.getChecksums(123n, ['test'])).toEqual([TEST_123]);
+    expect(await cache.getChecksums(123n, [{ bucket: 'test', source: DUMMY_SOURCE }])).toEqual([TEST_123]);
 
-    expect(lookups).toEqual([
+    expect(lookups.map(removeLookupSources)).toEqual([
       [{ bucket: 'test', end: 123n }],
       [{ bucket: 'test', start: 123n, end: 124n }],
       [{ bucket: 'test', start: 124n, end: 125n }],
@@ -400,10 +445,10 @@ describe('checksum cache', function () {
       maxSize: 2
     });
 
-    const p3 = cache.getChecksums(123n, ['test3']);
-    const p4 = cache.getChecksums(123n, ['test4']);
-    const p1 = cache.getChecksums(123n, ['test']);
-    const p2 = cache.getChecksums(123n, ['test2']);
+    const p3 = cache.getChecksums(123n, [{ bucket: 'test3', source: DUMMY_SOURCE }]);
+    const p4 = cache.getChecksums(123n, [{ bucket: 'test4', source: DUMMY_SOURCE }]);
+    const p1 = cache.getChecksums(123n, [{ bucket: 'test', source: DUMMY_SOURCE }]);
+    const p2 = cache.getChecksums(123n, [{ bucket: 'test2', source: DUMMY_SOURCE }]);
 
     expect(await p1).toEqual([TEST_123]);
     expect(await p2).toEqual([TEST2_123]);
@@ -417,7 +462,7 @@ describe('checksum cache', function () {
     ]);
 
     // The lookup should be deduplicated, even though it's in progress
-    expect(lookups).toEqual([
+    expect(lookups.map(removeLookupSources)).toEqual([
       [{ bucket: 'test3', end: 123n }],
       [{ bucket: 'test4', end: 123n }],
       [{ bucket: 'test', end: 123n }],
@@ -434,7 +479,7 @@ describe('checksum cache', function () {
       return fetchTestChecksums(batch);
     });
 
-    expect(await cache.getChecksums(123n, ['test'])).toEqual([TEST_123]);
-    expect(await cache.getChecksums(1234n, ['test'])).toEqual([TEST_1234]);
+    expect(await cache.getChecksums(123n, [{ bucket: 'test', source: DUMMY_SOURCE }])).toEqual([TEST_123]);
+    expect(await cache.getChecksums(1234n, [{ bucket: 'test', source: DUMMY_SOURCE }])).toEqual([TEST_1234]);
   });
 });

package/test/src/config.test.ts

@@ -155,6 +155,7 @@ describe('Config', () => {
         type: mongodb
     `;
     const yamlSyncConfig = /* yaml */ `
+      # Sync config
       config:
         edition: 2
       streams:

package/test/src/sync/BucketChecksumState.test.ts

@@ -14,15 +14,43 @@ import {
 } from '@/index.js';
 import { JSONBig } from '@powersync/service-jsonbig';
 import {
+  ParameterIndexLookupCreator,
   RequestJwtPayload,
   ScopedParameterLookup,
   SqliteJsonRow,
+  SqliteRow,
   SqlSyncRules,
+  TablePattern,
+  SourceTableInterface,
   versionedHydrationState
 } from '@powersync/service-sync-rules';
+import { ParameterLookupScope } from '@powersync/service-sync-rules/src/HydrationState.js';
 import { beforeEach, describe, expect, test } from 'vitest';
 
 describe('BucketChecksumState', () => {
+  const LOOKUP_SOURCE: ParameterIndexLookupCreator = {
+    get defaultLookupScope(): ParameterLookupScope {
+      return {
+        lookupName: 'lookup',
+        queryId: '0',
+        source: LOOKUP_SOURCE
+      };
+    },
+    getSourceTables(): Set<TablePattern> {
+      return new Set();
+    },
+    evaluateParameterRow(_sourceTable: SourceTableInterface, _row: SqliteRow) {
+      return [];
+    },
+    tableSyncsParameters(_table: SourceTableInterface): boolean {
+      return false;
+    }
+  };
+
+  function lookupScope(lookupName: string, queryId: string): ParameterLookupScope {
+    return { lookupName, queryId, source: LOOKUP_SOURCE };
+  }
+
   // Single global[] bucket.
   // We don't care about data in these tests
   const SYNC_RULES_GLOBAL = SqlSyncRules.fromYaml(
@@ -67,6 +95,10 @@ bucket_definitions:
   const syncRequest: StreamingSyncRequest = {};
   const tokenPayload = new JwtPayload({ sub: '' });
 
+  function bucketStarts(requests: { bucket: string; start: InternalOpId }[]) {
+    return new Map(requests.map((request) => [request.bucket, request.start]));
+  }
+
   test('global bucket with update', async () => {
     const storage = new MockBucketChecksumStateStorage();
     // Set intial state
@@ -94,14 +126,14 @@ bucket_definitions:
         streams: [{ name: 'global', is_default: true, errors: [] }]
       }
     });
-    expect(line.bucketsToFetch).toEqual([
+    expect(line.bucketsToFetch).toMatchObject([
       {
         bucket: '1#global[]',
         priority: 3
       }
     ]);
     // This is the bucket data to be fetched
-    expect(line.getFilteredBucketPositions()).toEqual(new Map([['1#global[]', 0n]]));
+    expect(bucketStarts(line.getFilteredBucketPositions())).toEqual(new Map([['1#global[]', 0n]]));
 
     // This similuates the bucket data being sent
     line.advance();
@@ -132,7 +164,7 @@ bucket_definitions:
         write_checkpoint: undefined
       }
     });
-    expect(line2.getFilteredBucketPositions()).toEqual(new Map([['1#global[]', 1n]]));
+    expect(bucketStarts(line2.getFilteredBucketPositions())).toEqual(new Map([['1#global[]', 1n]]));
   });
 
   test('global bucket with initial state', async () => {
@@ -166,14 +198,14 @@ bucket_definitions:
         streams: [{ name: 'global', is_default: true, errors: [] }]
       }
     });
-    expect(line.bucketsToFetch).toEqual([
+    expect(line.bucketsToFetch).toMatchObject([
       {
         bucket: '1#global[]',
         priority: 3
       }
     ]);
     // This is the main difference between this and the previous test
-    expect(line.getFilteredBucketPositions()).toEqual(new Map([['1#global[]', 1n]]));
+    expect(bucketStarts(line.getFilteredBucketPositions())).toEqual(new Map([['1#global[]', 1n]]));
   });
 
   test('multiple static buckets', async () => {
@@ -206,7 +238,7 @@ bucket_definitions:
         streams: [{ name: 'global', is_default: true, errors: [] }]
       }
     });
-    expect(line.bucketsToFetch).toEqual([
+    expect(line.bucketsToFetch).toMatchObject([
       {
         bucket: '2#global[1]',
         priority: 3
@@ -274,13 +306,13 @@ bucket_definitions:
         streams: [{ name: 'global', is_default: true, errors: [] }]
       }
     });
-    expect(line.bucketsToFetch).toEqual([
+    expect(line.bucketsToFetch).toMatchObject([
       {
         bucket: '1#global[]',
         priority: 3
       }
     ]);
-    expect(line.getFilteredBucketPositions()).toEqual(new Map([['1#global[]', 0n]]));
+    expect(bucketStarts(line.getFilteredBucketPositions())).toEqual(new Map([['1#global[]', 0n]]));
   });
 
   test('invalidating individual bucket', async () => {
@@ -337,7 +369,7 @@ bucket_definitions:
         write_checkpoint: undefined
       }
     });
-    expect(line2.bucketsToFetch).toEqual([{ bucket: '2#global[1]', priority: 3 }]);
+    expect(line2.bucketsToFetch).toMatchObject([{ bucket: '2#global[1]', priority: 3 }]);
   });
 
   test('invalidating all buckets', async () => {
@@ -387,7 +419,7 @@ bucket_definitions:
         write_checkpoint: undefined
       }
     });
-    expect(line2.bucketsToFetch).toEqual([
+    expect(line2.bucketsToFetch).toMatchObject([
       { bucket: '2#global[1]', priority: 3 },
       { bucket: '2#global[2]', priority: 3 }
     ]);
@@ -424,7 +456,7 @@ bucket_definitions:
         streams: [{ name: 'global', is_default: true, errors: [] }]
       }
     });
-    expect(line.bucketsToFetch).toEqual([
+    expect(line.bucketsToFetch).toMatchObject([
       {
         bucket: '2#global[1]',
         priority: 3
@@ -436,7 +468,7 @@ bucket_definitions:
     ]);
 
     // This is the bucket data to be fetched
-    expect(line.getFilteredBucketPositions()).toEqual(
+    expect(bucketStarts(line.getFilteredBucketPositions())).toEqual(
       new Map([
         ['2#global[1]', 0n],
         ['2#global[2]', 0n]
@@ -477,7 +509,7 @@ bucket_definitions:
       }
     });
     // This should contain both buckets, even though only one changed.
-    expect(line2.bucketsToFetch).toEqual([
+    expect(line2.bucketsToFetch).toMatchObject([
       {
         bucket: '2#global[1]',
         priority: 3
@@ -488,7 +520,7 @@ bucket_definitions:
       }
     ]);
 
-    expect(line2.getFilteredBucketPositions()).toEqual(
+    expect(bucketStarts(line2.getFilteredBucketPositions())).toEqual(
       new Map([
         ['2#global[1]', 3n],
         ['2#global[2]', 1n]
@@ -513,7 +545,7 @@ bucket_definitions:
 
     const line = (await state.buildNextCheckpointLine({
       base: storage.makeCheckpoint(1n, (lookups) => {
-        expect(lookups).toEqual([ScopedParameterLookup.direct({ lookupName: 'by_project', queryId: '1' }, ['u1'])]);
+        expect(lookups).toEqual([ScopedParameterLookup.direct(lookupScope('by_project', '1'), ['u1'])]);
         return [{ id: 1 }, { id: 2 }];
       }),
       writeCheckpoint: null,
@@ -548,7 +580,7 @@ bucket_definitions:
         write_checkpoint: undefined
       }
     });
-    expect(line.bucketsToFetch).toEqual([
+    expect(line.bucketsToFetch).toMatchObject([
       {
         bucket: '3#by_project[1]',
         priority: 3
@@ -560,7 +592,7 @@ bucket_definitions:
     ]);
     line.advance();
     // This is the bucket data to be fetched
-    expect(line.getFilteredBucketPositions()).toEqual(
+    expect(bucketStarts(line.getFilteredBucketPositions())).toEqual(
       new Map([
         ['3#by_project[1]', 0n],
         ['3#by_project[2]', 0n]
@@ -574,7 +606,7 @@ bucket_definitions:
     // Now we get a new line
     const line2 = (await state.buildNextCheckpointLine({
       base: storage.makeCheckpoint(2n, (lookups) => {
-        expect(lookups).toEqual([ScopedParameterLookup.direct({ lookupName: 'by_project', queryId: '1' }, ['u1'])]);
+        expect(lookups).toEqual([ScopedParameterLookup.direct(lookupScope('by_project', '1'), ['u1'])]);
         return [{ id: 1 }, { id: 2 }, { id: 3 }];
       }),
       writeCheckpoint: null,
@@ -602,7 +634,7 @@ bucket_definitions:
         write_checkpoint: undefined
       }
     });
-    expect(line2.getFilteredBucketPositions()).toEqual(new Map([['3#by_project[3]', 0n]]));
+    expect(bucketStarts(line2.getFilteredBucketPositions())).toEqual(new Map([['3#by_project[3]', 0n]]));
   });
 
   describe('streams', () => {
@@ -1044,9 +1076,9 @@ class MockBucketChecksumStateStorage implements BucketChecksumStateStorage {
     this.filter?.({ invalidate: true });
   }
 
-  async getChecksums(checkpoint: InternalOpId, buckets: string[]): Promise<ChecksumMap> {
+  async getChecksums(_checkpoint: InternalOpId, buckets: { bucket: string }[]): Promise<ChecksumMap> {
     return new Map<string, BucketChecksum>(
-      buckets.map((bucket) => {
+      buckets.map(({ bucket }) => {
         const checksum = this.state.get(bucket);
         return [
           bucket,

package/test/src/utils.ts

@@ -0,0 +1,9 @@
+/**
+ * Removes the source property from an object.
+ *
+ * This is for tests where we don't care about this value, and it adds a lot of noise in the output.
+ */
+export function removeSource<T extends { source?: any }>(obj: T): Omit<T, 'source'> {
+  const { source, ...rest } = obj;
+  return rest;
+}