@powersync/service-core 0.2.0 → 0.2.1

package/src/sync/sync.ts

@@ -78,8 +78,8 @@ async function* streamResponseInner(
   // This starts with the state from the client. May contain buckets that the user do not have access to (anymore).
   let dataBuckets = new Map<string, string>();
 
-  let last_checksums: util.BucketChecksum[] | null = null;
-  let last_write_checkpoint: bigint | null = null;
+  let lastChecksums: util.ChecksumMap | null = null;
+  let lastWriteCheckpoint: bigint | null = null;
 
   const { raw_data, binary_data } = params;
 
@@ -113,39 +113,42 @@ async function* streamResponseInner(
       throw new Error(`Too many buckets: ${allBuckets.length}`);
     }
 
-    let checksums: util.BucketChecksum[] | undefined = undefined;
-
     let dataBucketsNew = new Map<string, string>();
     for (let bucket of allBuckets) {
       dataBucketsNew.set(bucket, dataBuckets.get(bucket) ?? '0');
     }
     dataBuckets = dataBucketsNew;
 
-    checksums = await storage.getChecksums(checkpoint, [...dataBuckets.keys()]);
+    const bucketList = [...dataBuckets.keys()];
+    const checksumMap = await storage.getChecksums(checkpoint, bucketList);
+    // Subset of buckets for which there may be new data in this batch.
+    let bucketsToFetch: string[];
 
-    if (last_checksums) {
-      const diff = util.checksumsDiff(last_checksums, checksums);
+    if (lastChecksums) {
+      const diff = util.checksumsDiff(lastChecksums, checksumMap);
 
       if (
-        last_write_checkpoint == writeCheckpoint &&
-        diff.removed_buckets.length == 0 &&
-        diff.updated_buckets.length == 0
+        lastWriteCheckpoint == writeCheckpoint &&
+        diff.removedBuckets.length == 0 &&
+        diff.updatedBuckets.length == 0
       ) {
         // No changes - don't send anything to the client
         continue;
       }
+      bucketsToFetch = diff.updatedBuckets.map((c) => c.bucket);
 
       let message = `Updated checkpoint: ${checkpoint} | write: ${writeCheckpoint} | `;
       message += `buckets: ${allBuckets.length} | `;
-      message += `updated: ${limitedBuckets(diff.updated_buckets, 20)} | `;
-      message += `removed: ${limitedBuckets(diff.removed_buckets, 20)} | `;
+      message += `updated: ${limitedBuckets(diff.updatedBuckets, 20)} | `;
+      message += `removed: ${limitedBuckets(diff.removedBuckets, 20)} | `;
       micro.logger.info(message);
 
       const checksum_line: util.StreamingSyncCheckpointDiff = {
         checkpoint_diff: {
           last_op_id: checkpoint,
           write_checkpoint: writeCheckpoint ? String(writeCheckpoint) : undefined,
-          ...diff
+          removed_buckets: diff.removedBuckets,
+          updated_buckets: diff.updatedBuckets
         }
       };
 
@@ -154,35 +157,41 @@ async function* streamResponseInner(
       let message = `New checkpoint: ${checkpoint} | write: ${writeCheckpoint} | `;
       message += `buckets: ${allBuckets.length} ${limitedBuckets(allBuckets, 20)}`;
       micro.logger.info(message);
+      bucketsToFetch = allBuckets;
       const checksum_line: util.StreamingSyncCheckpoint = {
         checkpoint: {
           last_op_id: checkpoint,
           write_checkpoint: writeCheckpoint ? String(writeCheckpoint) : undefined,
-          buckets: checksums
+          buckets: [...checksumMap.values()]
         }
       };
       yield checksum_line;
     }
+    lastChecksums = checksumMap;
+    lastWriteCheckpoint = writeCheckpoint;
 
-    last_checksums = checksums;
-    last_write_checkpoint = writeCheckpoint;
-
-    yield* bucketDataInBatches(storage, checkpoint, dataBuckets, raw_data, binary_data, signal);
+    // This incrementally updates dataBuckets with each individual bucket position.
+    // At the end of this, we can be sure that all buckets have data up to the checkpoint.
+    yield* bucketDataInBatches({ storage, checkpoint, bucketsToFetch, dataBuckets, raw_data, binary_data, signal });
 
     await new Promise((resolve) => setTimeout(resolve, 10));
   }
 }
 
-async function* bucketDataInBatches(
-  storage: storage.SyncRulesBucketStorage,
-  checkpoint: string,
-  dataBuckets: Map<string, string>,
-  raw_data: boolean | undefined,
-  binary_data: boolean | undefined,
-  signal: AbortSignal
-) {
+interface BucketDataRequest {
+  storage: storage.SyncRulesBucketStorage;
+  checkpoint: string;
+  bucketsToFetch: string[];
+  /** Bucket data position, modified by the request.  */
+  dataBuckets: Map<string, string>;
+  raw_data: boolean | undefined;
+  binary_data: boolean | undefined;
+  signal: AbortSignal;
+}
+
+async function* bucketDataInBatches(request: BucketDataRequest) {
   let isDone = false;
-  while (!signal.aborted && !isDone) {
+  while (!request.signal.aborted && !isDone) {
     // The code below is functionally the same as this for-await loop below.
     // However, the for-await loop appears to have a memory leak, so we avoid it.
     // for await (const { done, data } of bucketDataBatch(storage, checkpoint, dataBuckets, raw_data, signal)) {
@@ -192,7 +201,7 @@ async function* bucketDataInBatches(
     //   }
     //   break;
     // }
-    const iter = bucketDataBatch(storage, checkpoint, dataBuckets, raw_data, binary_data, signal);
+    const iter = bucketDataBatch(request);
     try {
       while (true) {
         const { value, done: iterDone } = await iter.next();
@@ -215,17 +224,15 @@ async function* bucketDataInBatches(
 /**
  * Extracted as a separate internal function just to avoid memory leaks.
  */
-async function* bucketDataBatch(
-  storage: storage.SyncRulesBucketStorage,
-  checkpoint: string,
-  dataBuckets: Map<string, string>,
-  raw_data: boolean | undefined,
-  binary_data: boolean | undefined,
-  signal: AbortSignal
-) {
+async function* bucketDataBatch(request: BucketDataRequest) {
+  const { storage, checkpoint, bucketsToFetch, dataBuckets, raw_data, binary_data, signal } = request;
+
   const [_, release] = await syncSemaphore.acquire();
   try {
-    const data = storage.getBucketDataBatch(checkpoint, dataBuckets);
+    // Optimization: Only fetch buckets for which the checksums have changed since the last checkpoint
+    // For the first batch, this will be all buckets.
+    const filteredBuckets = new Map(bucketsToFetch.map((bucket) => [bucket, dataBuckets.get(bucket)!]));
+    const data = storage.getBucketDataBatch(checkpoint, filteredBuckets);
 
     let has_more = false;
 

package/src/util/utils.ts

@@ -7,6 +7,8 @@ import * as storage from '@/storage/storage-index.js';
 import { BucketChecksum, OpId } from './protocol-types.js';
 import { retriedQuery } from './pgwire_utils.js';
 
+export type ChecksumMap = Map<string, BucketChecksum>;
+
 export function hashData(type: string, id: string, data: string): number {
   const hash = crypto.createHash('sha256');
   hash.update(`put.${type}.${id}.${data}`);
@@ -30,32 +32,50 @@ export function timestampToOpId(ts: bigint): OpId {
   return ts.toString(10);
 }
 
-export function checksumsDiff(previous: BucketChecksum[], current: BucketChecksum[]) {
-  const updated_buckets: BucketChecksum[] = [];
+export function checksumsDiff(previous: ChecksumMap, current: ChecksumMap) {
+  // All changed ones
+  const updatedBuckets = new Map<string, BucketChecksum>();
 
-  const previousBuckets = new Map<string, BucketChecksum>();
-  for (let checksum of previous) {
-    previousBuckets.set(checksum.bucket, checksum);
-  }
-  for (let checksum of current) {
-    if (!previousBuckets.has(checksum.bucket)) {
-      updated_buckets.push(checksum);
+  const toRemove = new Set<string>(previous.keys());
+
+  for (let checksum of current.values()) {
+    const p = previous.get(checksum.bucket);
+    if (p == null) {
+      // Added
+      updatedBuckets.set(checksum.bucket, checksum);
     } else {
-      const p = previousBuckets.get(checksum.bucket);
-      if (p?.checksum != checksum.checksum || p?.count != checksum.count) {
-        updated_buckets.push(checksum);
+      toRemove.delete(checksum.bucket);
+      if (checksum.checksum != p.checksum || checksum.count != p.count) {
+        // Updated
+        updatedBuckets.set(checksum.bucket, checksum);
+      } else {
+        // No change
       }
-      previousBuckets.delete(checksum.bucket);
     }
   }
 
-  const removed_buckets: string[] = [...previousBuckets.keys()];
   return {
-    updated_buckets,
-    removed_buckets
+    updatedBuckets: [...updatedBuckets.values()],
+    removedBuckets: [...toRemove]
   };
 }
 
+export function addChecksums(a: number, b: number) {
+  return (a + b) & 0xffffffff;
+}
+
+export function addBucketChecksums(a: BucketChecksum, b: BucketChecksum | null): BucketChecksum {
+  if (b == null) {
+    return a;
+  } else {
+    return {
+      bucket: a.bucket,
+      count: a.count + b.count,
+      checksum: addChecksums(a.checksum, b.checksum)
+    };
+  }
+}
+
 export async function getClientCheckpoint(
   db: pgwire.PgClient,
   bucketStorage: storage.BucketStorageFactory,

package/test/src/__snapshots__/sync.test.ts.snap

@@ -12,7 +12,13 @@ exports[`sync - mongodb > expiring token 1`] = `
 [
   {
     "checkpoint": {
-      "buckets": [],
+      "buckets": [
+        {
+          "bucket": "mybucket[]",
+          "checksum": 0,
+          "count": 0,
+        },
+      ],
       "last_op_id": "0",
       "write_checkpoint": undefined,
     },
@@ -135,7 +141,13 @@ exports[`sync - mongodb > sync updates to global data 1`] = `
 [
   {
     "checkpoint": {
-      "buckets": [],
+      "buckets": [
+        {
+          "bucket": "mybucket[]",
+          "checksum": 0,
+          "count": 0,
+        },
+      ],
       "last_op_id": "0",
       "write_checkpoint": undefined,
     },

package/test/src/checksum_cache.test.ts

@@ -0,0 +1,436 @@
+import { describe, expect, it } from 'vitest';
+import { BucketChecksum, OpId } from '@/util/protocol-types.js';
+import * as crypto from 'node:crypto';
+import { addBucketChecksums } from '@/util/util-index.js';
+import { ChecksumCache, FetchChecksums, FetchPartialBucketChecksum } from '@/storage/ChecksumCache.js';
+
+/**
+ * Create a deterministic BucketChecksum based on the bucket name and checkpoint for testing purposes.
+ */
+function testHash(bucket: string, checkpoint: OpId) {
+  const key = `${checkpoint}/${bucket}`;
+  const hash = crypto.createHash('sha256').update(key).digest().readInt32LE(0);
+  return hash;
+}
+
+function testPartialHash(request: FetchPartialBucketChecksum): BucketChecksum {
+  if (request.start) {
+    const a = testHash(request.bucket, request.start);
+    const b = testHash(request.bucket, request.end);
+    return addBucketChecksums(
+      {
+        bucket: request.bucket,
+        checksum: b,
+        count: Number(request.end)
+      },
+      {
+        // Subtract a
+        bucket: request.bucket,
+        checksum: -a,
+        count: -Number(request.start)
+      }
+    );
+  } else {
+    return {
+      bucket: request.bucket,
+      checksum: testHash(request.bucket, request.end),
+      count: Number(request.end)
+    };
+  }
+}
+
+const TEST_123 = {
+  bucket: 'test',
+  count: 123,
+  checksum: 1104081737
+};
+
+const TEST_1234 = {
+  bucket: 'test',
+  count: 1234,
+  checksum: -1593864957
+};
+
+const TEST2_123 = {
+  bucket: 'test2',
+  count: 123,
+  checksum: 1741377449
+};
+
+const TEST3_123 = {
+  bucket: 'test3',
+  count: 123,
+  checksum: -2085080402
+};
+
+function fetchTestChecksums(batch: FetchPartialBucketChecksum[]) {
+  return new Map(
+    batch.map((v) => {
+      return [v.bucket, testPartialHash(v)];
+    })
+  );
+}
+
+describe('checksum cache', function () {
+  const factory = (fetch: FetchChecksums) => {
+    return new ChecksumCache({ fetchChecksums: fetch });
+  };
+
+  it('should handle a sequential lookups (a)', async function () {
+    let lookups: FetchPartialBucketChecksum[][] = [];
+    const cache = factory(async (batch) => {
+      lookups.push(batch);
+      return fetchTestChecksums(batch);
+    });
+
+    expect(await cache.getChecksums('123', ['test'])).toEqual([TEST_123]);
+
+    expect(await cache.getChecksums('1234', ['test'])).toEqual([TEST_1234]);
+
+    expect(await cache.getChecksums('123', ['test2'])).toEqual([TEST2_123]);
+
+    expect(lookups).toEqual([
+      [{ bucket: 'test', end: '123' }],
+      // This should use the previous lookup
+      [{ bucket: 'test', start: '123', end: '1234' }],
+      [{ bucket: 'test2', end: '123' }]
+    ]);
+  });
+
+  it('should handle a sequential lookups (b)', async function () {
+    // Reverse order of the above
+    let lookups: FetchPartialBucketChecksum[][] = [];
+    const cache = factory(async (batch) => {
+      lookups.push(batch);
+      return fetchTestChecksums(batch);
+    });
+
+    expect(await cache.getChecksums('123', ['test2'])).toEqual([TEST2_123]);
+
+    expect(await cache.getChecksums('1234', ['test'])).toEqual([TEST_1234]);
+
+    expect(await cache.getChecksums('123', ['test'])).toEqual([TEST_123]);
+
+    expect(lookups).toEqual([
+      // With this order, there is no option for a partial lookup
+      [{ bucket: 'test2', end: '123' }],
+      [{ bucket: 'test', end: '1234' }],
+      [{ bucket: 'test', end: '123' }]
+    ]);
+  });
+
+  it('should handle a concurrent lookups (a)', async function () {
+    let lookups: FetchPartialBucketChecksum[][] = [];
+    const cache = factory(async (batch) => {
+      lookups.push(batch);
+      return fetchTestChecksums(batch);
+    });
+
+    const p1 = cache.getChecksums('123', ['test']);
+    const p2 = cache.getChecksums('1234', ['test']);
+    const p3 = cache.getChecksums('123', ['test2']);
+
+    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([
+      [{ bucket: 'test', end: '123' }],
+      [{ bucket: 'test', end: '1234' }],
+      [{ bucket: 'test2', end: '123' }]
+    ]);
+  });
+
+  it('should handle a concurrent lookups (b)', async function () {
+    let lookups: FetchPartialBucketChecksum[][] = [];
+    const cache = factory(async (batch) => {
+      lookups.push(batch);
+      return fetchTestChecksums(batch);
+    });
+
+    const p1 = cache.getChecksums('123', ['test']);
+    const p2 = cache.getChecksums('123', ['test']);
+
+    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: '123' }]]);
+  });
+
+  it('should handle serial + concurrent lookups', async function () {
+    let lookups: FetchPartialBucketChecksum[][] = [];
+    const cache = factory(async (batch) => {
+      lookups.push(batch);
+      return fetchTestChecksums(batch);
+    });
+
+    expect(await cache.getChecksums('123', ['test'])).toEqual([TEST_123]);
+
+    const p2 = cache.getChecksums('1234', ['test']);
+    const p3 = cache.getChecksums('1234', ['test']);
+
+    expect(await p2).toEqual([TEST_1234]);
+    expect(await p3).toEqual([TEST_1234]);
+
+    expect(lookups).toEqual([
+      [{ bucket: 'test', end: '123' }],
+      // This lookup is deduplicated
+      [{ bucket: 'test', start: '123', end: '1234' }]
+    ]);
+  });
+
+  it('should handle multiple buckets', async function () {
+    let lookups: FetchPartialBucketChecksum[][] = [];
+    const cache = factory(async (batch) => {
+      lookups.push(batch);
+      return fetchTestChecksums(batch);
+    });
+
+    expect(await cache.getChecksums('123', ['test', 'test2'])).toEqual([TEST_123, TEST2_123]);
+
+    expect(lookups).toEqual([
+      [
+        // Both lookups in the same request
+        { bucket: 'test', end: '123' },
+        { bucket: 'test2', end: '123' }
+      ]
+    ]);
+  });
+
+  it('should handle multiple buckets with partial caching (a)', async function () {
+    let lookups: FetchPartialBucketChecksum[][] = [];
+    const cache = factory(async (batch) => {
+      lookups.push(batch);
+      return fetchTestChecksums(batch);
+    });
+
+    expect(await cache.getChecksums('123', ['test'])).toEqual([TEST_123]);
+    expect(await cache.getChecksums('123', ['test', 'test2'])).toEqual([TEST_123, TEST2_123]);
+
+    expect(lookups).toEqual([
+      // Request 1
+      [{ bucket: 'test', end: '123' }],
+      // Request 2
+      [{ bucket: 'test2', end: '123' }]
+    ]);
+  });
+
+  it('should handle multiple buckets with partial caching (b)', async function () {
+    let lookups: FetchPartialBucketChecksum[][] = [];
+    const cache = factory(async (batch) => {
+      lookups.push(batch);
+      return fetchTestChecksums(batch);
+    });
+
+    const a = cache.getChecksums('123', ['test', 'test2']);
+    const b = cache.getChecksums('123', ['test2', 'test3']);
+
+    expect(await a).toEqual([TEST_123, TEST2_123]);
+    expect(await b).toEqual([TEST2_123, TEST3_123]);
+
+    expect(lookups).toEqual([
+      // Request A
+      [
+        { bucket: 'test', end: '123' },
+        { bucket: 'test2', end: '123' }
+      ],
+      // Request B (re-uses the checksum for test2 from request a)
+      [{ bucket: 'test3', end: '123' }]
+    ]);
+  });
+
+  it('should handle out-of-order requests', async function () {
+    let lookups: FetchPartialBucketChecksum[][] = [];
+    const cache = factory(async (batch) => {
+      lookups.push(batch);
+      return fetchTestChecksums(batch);
+    });
+
+    expect(await cache.getChecksums('123', ['test'])).toEqual([TEST_123]);
+
+    expect(await cache.getChecksums('125', ['test'])).toEqual([
+      {
+        bucket: 'test',
+        checksum: -1865121912,
+        count: 125
+      }
+    ]);
+
+    expect(await cache.getChecksums('124', ['test'])).toEqual([
+      {
+        bucket: 'test',
+        checksum: 1887460431,
+        count: 124
+      }
+    ]);
+    expect(lookups).toEqual([
+      [{ bucket: 'test', end: '123' }],
+      [{ bucket: 'test', start: '123', end: '125' }],
+      [{ bucket: 'test', start: '123', end: '124' }]
+    ]);
+  });
+
+  it('should handle errors', async function () {
+    let lookups: FetchPartialBucketChecksum[][] = [];
+    const TEST_ERROR = new Error('Simulated error');
+    const cache = factory(async (batch) => {
+      lookups.push(batch);
+      if (lookups.length == 1) {
+        throw new Error('Simulated error');
+      }
+      return fetchTestChecksums(batch);
+    });
+
+    const a = cache.getChecksums('123', ['test', 'test2']);
+    const b = cache.getChecksums('123', ['test2', 'test3']);
+
+    await expect(a).rejects.toEqual(TEST_ERROR);
+    await expect(b).rejects.toEqual(TEST_ERROR);
+
+    const a2 = cache.getChecksums('123', ['test', 'test2']);
+    const b2 = cache.getChecksums('123', ['test2', 'test3']);
+
+    expect(await a2).toEqual([TEST_123, TEST2_123]);
+    expect(await b2).toEqual([TEST2_123, TEST3_123]);
+
+    expect(lookups).toEqual([
+      // Request A (fails)
+      [
+        { bucket: 'test', end: '123' },
+        { bucket: 'test2', end: '123' }
+      ],
+      // Request B (re-uses the checksum for test2 from request a)
+      // Even thought the full request fails, this batch succeeds
+      [{ bucket: 'test3', end: '123' }],
+      // Retry request A
+      [
+        { bucket: 'test', end: '123' },
+        { bucket: 'test2', end: '123' }
+      ]
+    ]);
+  });
+
+  it('should handle missing checksums (a)', async function () {
+    let lookups: FetchPartialBucketChecksum[][] = [];
+    const cache = factory(async (batch) => {
+      lookups.push(batch);
+      return fetchTestChecksums(batch.filter((b) => b.bucket != 'test'));
+    });
+
+    expect(await cache.getChecksums('123', ['test'])).toEqual([{ bucket: 'test', checksum: 0, count: 0 }]);
+    expect(await cache.getChecksums('123', ['test', 'test2'])).toEqual([
+      { bucket: 'test', checksum: 0, count: 0 },
+      TEST2_123
+    ]);
+  });
+
+  it('should handle missing checksums (b)', async function () {
+    let lookups: FetchPartialBucketChecksum[][] = [];
+    const cache = factory(async (batch) => {
+      lookups.push(batch);
+      return fetchTestChecksums(batch.filter((b) => b.bucket != 'test' || b.end != '123'));
+    });
+
+    expect(await cache.getChecksums('123', ['test'])).toEqual([{ bucket: 'test', checksum: 0, count: 0 }]);
+    expect(await cache.getChecksums('1234', ['test'])).toEqual([
+      {
+        bucket: 'test',
+        checksum: 1597020602,
+        count: 1111
+      }
+    ]);
+
+    expect(lookups).toEqual([[{ bucket: 'test', end: '123' }], [{ bucket: 'test', start: '123', end: '1234' }]]);
+  });
+
+  it('should use maxSize', async function () {
+    let lookups: FetchPartialBucketChecksum[][] = [];
+    const cache = new ChecksumCache({
+      fetchChecksums: async (batch) => {
+        lookups.push(batch);
+        return fetchTestChecksums(batch);
+      },
+      maxSize: 2
+    });
+
+    expect(await cache.getChecksums('123', ['test'])).toEqual([TEST_123]);
+    expect(await cache.getChecksums('124', ['test'])).toEqual([
+      {
+        bucket: 'test',
+        checksum: 1887460431,
+        count: 124
+      }
+    ]);
+
+    expect(await cache.getChecksums('125', ['test'])).toEqual([
+      {
+        bucket: 'test',
+        checksum: -1865121912,
+        count: 125
+      }
+    ]);
+    expect(await cache.getChecksums('126', ['test'])).toEqual([
+      {
+        bucket: 'test',
+        checksum: -1720007310,
+        count: 126
+      }
+    ]);
+    expect(await cache.getChecksums('124', ['test'])).toEqual([
+      {
+        bucket: 'test',
+        checksum: 1887460431,
+        count: 124
+      }
+    ]);
+    expect(await cache.getChecksums('123', ['test'])).toEqual([TEST_123]);
+
+    expect(lookups).toEqual([
+      [{ bucket: 'test', end: '123' }],
+      [{ bucket: 'test', start: '123', end: '124' }],
+      [{ bucket: 'test', start: '124', end: '125' }],
+      [{ bucket: 'test', start: '125', end: '126' }],
+      [{ bucket: 'test', end: '124' }],
+      [{ bucket: 'test', end: '123' }]
+    ]);
+  });
+
+  it('should handle concurrent requests greater than cache size', async function () {
+    // This will not be cached efficiently, but we test that we don't get errors at least.
+    let lookups: FetchPartialBucketChecksum[][] = [];
+    const cache = new ChecksumCache({
+      fetchChecksums: async (batch) => {
+        lookups.push(batch);
+        return fetchTestChecksums(batch);
+      },
+      maxSize: 2
+    });
+
+    const p3 = cache.getChecksums('123', ['test3']);
+    const p4 = cache.getChecksums('123', ['test4']);
+    const p1 = cache.getChecksums('123', ['test']);
+    const p2 = cache.getChecksums('123', ['test2']);
+
+    expect(await p1).toEqual([TEST_123]);
+    expect(await p2).toEqual([TEST2_123]);
+    expect(await p3).toEqual([TEST3_123]);
+    expect(await p4).toEqual([
+      {
+        bucket: 'test4',
+        checksum: 1004797863,
+        count: 123
+      }
+    ]);
+
+    // The lookup should be deduplicated, even though it's in progress
+    expect(lookups).toEqual([
+      [{ bucket: 'test3', end: '123' }],
+      [{ bucket: 'test4', end: '123' }],
+      [{ bucket: 'test', end: '123' }],
+      [{ bucket: 'test2', end: '123' }]
+    ]);
+  });
+});