@dereekb/firebase 13.0.5 → 13.0.7

package/test/index.cjs.js

@@ -819,8 +819,8 @@ function describeFirestoreAccessorDriverTests(f) {
         let mockItemFirestoreDocumentAccessor;
         let items;
         beforeEach(async () => {
-            mockItemFirestoreDocumentAccessor = f.instance.firestoreCollection.documentAccessor();
-            items = await firebase.makeDocuments(f.instance.firestoreCollection.documentAccessor(), {
+            mockItemFirestoreDocumentAccessor = f.instance.mockItemCollection.documentAccessor();
+            items = await firebase.makeDocuments(f.instance.mockItemCollection.documentAccessor(), {
                 count: testDocumentCount,
                 init: (i) => {
                     return {
@@ -845,8 +845,8 @@ function describeFirestoreAccessorDriverTests(f) {
                     dataForUpdate: () => ({ test: false }),
                     hasRemainingDataFromFirstOfTwoUpdate: (data) => (data.tags?.length || 0) > 0 && data.tags?.[0] === 'a',
                     hasDataFromUpdate: (data) => data.test === false,
-                    loadDocumentForTransaction: (transaction, ref) => f.instance.firestoreCollection.documentAccessorForTransaction(transaction).loadDocument(ref),
-                    loadDocumentForWriteBatch: (writeBatch, ref) => f.instance.firestoreCollection.documentAccessorForWriteBatch(writeBatch).loadDocument(ref)
+                    loadDocumentForTransaction: (transaction, ref) => f.instance.mockItemCollection.documentAccessorForTransaction(transaction).loadDocument(ref),
+                    loadDocumentForWriteBatch: (writeBatch, ref) => f.instance.mockItemCollection.documentAccessorForWriteBatch(writeBatch).loadDocument(ref)
                 }));
                 describe('increment()', () => {
                     it(`should increase the item's value`, async () => {
@@ -887,7 +887,7 @@ function describeFirestoreAccessorDriverTests(f) {
                         it(`should increase the item's value`, async () => {
                             const update = { number: 3 };
                             await f.parent.firestoreContext.runTransaction(async (transaction) => {
-                                const itemDocumentInTransaction = await f.instance.firestoreCollection.documentAccessorForTransaction(transaction).loadDocumentForId(itemDocument.id);
+                                const itemDocumentInTransaction = await f.instance.mockItemCollection.documentAccessorForTransaction(transaction).loadDocumentForId(itemDocument.id);
                                 const data = await itemDocumentInTransaction.snapshotData();
                                 expect(data?.number).toBe(undefined);
                                 await itemDocumentInTransaction.increment(update);
@@ -900,7 +900,7 @@ function describeFirestoreAccessorDriverTests(f) {
                         it(`should increase the item's value`, async () => {
                             const update = { number: 3 };
                             const writeBatch = f.parent.firestoreContext.batch();
-                            const itemDocumentForWriteBatch = await f.instance.firestoreCollection.documentAccessorForWriteBatch(writeBatch).loadDocumentForId(itemDocument.id);
+                            const itemDocumentForWriteBatch = await f.instance.mockItemCollection.documentAccessorForWriteBatch(writeBatch).loadDocumentForId(itemDocument.id);
                             await itemDocumentForWriteBatch.increment(update);
                             await writeBatch.commit();
                             const result = await itemDocument.snapshotData();
@@ -1577,7 +1577,7 @@ function describeFirestoreQueryDriverTests(f) {
         const EVEN_TAG = 'even';
         const ODD_TAG = 'odd';
         beforeEach(async () => {
-            items = await firebase.makeDocuments(f.instance.firestoreCollection.documentAccessor(), {
+            items = await firebase.makeDocuments(f.instance.mockItemCollection.documentAccessor(), {
                 count: testDocumentCount,
                 init: (i) => {
                     return {
@@ -2166,7 +2166,7 @@ function describeFirestoreQueryDriverTests(f) {
         describe('queryDocument', () => {
             let queryDocument;
             beforeEach(async () => {
-                queryDocument = f.instance.firestoreCollection.queryDocument;
+                queryDocument = f.instance.mockItemCollection.queryDocument;
             });
             describe('filter()', () => {
                 it('should apply the filter to the query', async () => {
@@ -2270,7 +2270,7 @@ function describeFirestoreQueryDriverTests(f) {
                         tryComplete();
                     });
                     // add one item
-                    util.waitForMs(10).then(() => firebase.makeDocuments(f.instance.firestoreCollection.documentAccessor(), {
+                    util.waitForMs(10).then(() => firebase.makeDocuments(f.instance.mockItemCollection.documentAccessor(), {
                         count: itemsToAdd,
                         init: (i) => {
                             return {
@@ -2346,7 +2346,7 @@ function describeFirestoreQueryDriverTests(f) {
                         tryComplete();
                     });
                     // add one item
-                    util.waitForMs(10).then(() => firebase.makeDocuments(f.instance.firestoreCollection.documentAccessor(), {
+                    util.waitForMs(10).then(() => firebase.makeDocuments(f.instance.mockItemCollection.documentAccessor(), {
                         count: itemsToAdd,
                         init: (i) => {
                             return {
@@ -2390,7 +2390,7 @@ function describeFirestoreQueryDriverTests(f) {
         describe('query', () => {
             let query;
             beforeEach(async () => {
-                query = f.instance.firestoreCollection.query;
+                query = f.instance.mockItemCollection.query;
             });
             describe('streamDocs()', () => {
                 let sub;
@@ -2418,7 +2418,7 @@ function describeFirestoreQueryDriverTests(f) {
                         tryComplete();
                     });
                     // add one item
-                    util.waitForMs(10).then(() => firebase.makeDocuments(f.instance.firestoreCollection.documentAccessor(), {
+                    util.waitForMs(10).then(() => firebase.makeDocuments(f.instance.mockItemCollection.documentAccessor(), {
                         count: itemsToAdd,
                         init: (i) => {
                             return {
@@ -2643,7 +2643,7 @@ function describeFirestoreQueryDriverTests(f) {
                             const oddPrefix = mockItemIdentity.collectionType + 'd' + '/'; // similar, but not quite the same
                             const expectedNumberOfEvenValues = Math.ceil(testDocumentCount / 2);
                             beforeEach(async () => {
-                                items = await firebase.makeDocuments(f.instance.firestoreCollection.documentAccessor(), {
+                                items = await firebase.makeDocuments(f.instance.mockItemCollection.documentAccessor(), {
                                     count: testDocumentCount,
                                     init: (i) => {
                                         const isEven = util.isEvenNumber(i);
@@ -2911,6 +2911,814 @@ function describeFirestoreQueryDriverTests(f) {
     });
 }
 
+/**
+ * Describes utility driver tests, using a MockItemCollectionFixture.
+ *
+ * @param f
+ */
+function describeFirestoreDocumentUtilityTests(f) {
+    describe('FirestoreDocumentUtilities', () => {
+        const testDocumentCount = 5;
+        let items;
+        const startDate = dateFns.addDays(dateFns.startOfDay(new Date()), 1);
+        const EVEN_TAG = 'even';
+        const ODD_TAG = 'odd';
+        beforeEach(async () => {
+            items = await firebase.makeDocuments(f.instance.mockItemCollection.documentAccessor(), {
+                count: testDocumentCount,
+                init: (i) => {
+                    return {
+                        value: `${i}`,
+                        number: i,
+                        date: dateFns.addHours(startDate, i),
+                        tags: [`${i}`, `${util.isEvenNumber(i) ? EVEN_TAG : ODD_TAG}`],
+                        test: true
+                    };
+                }
+            });
+        });
+        let sub;
+        beforeEach(() => {
+            sub = new rxjs.SubscriptionObject();
+        });
+        afterEach(() => {
+            sub.destroy();
+        });
+        describe('query.util.ts', () => {
+            // MARK: streamFromOnSnapshot
+            describe('streamFromOnSnapshot()', () => {
+                it('should call unsubscribe when the subscriber unsubscribes', () => {
+                    let unsubscribeCalled = false;
+                    const obs = firebase.streamFromOnSnapshot(({ next }) => {
+                        next('value');
+                        return () => {
+                            unsubscribeCalled = true;
+                        };
+                    });
+                    const subscription = obs.subscribe();
+                    expect(unsubscribeCalled).toBe(false);
+                    subscription.unsubscribe();
+                    expect(unsubscribeCalled).toBe(true);
+                });
+                it('should unsubscribe the onSnapshot listener when first() completes', () => {
+                    let unsubscribeCalled = false;
+                    const obs = firebase.streamFromOnSnapshot(({ next }) => {
+                        next('value');
+                        return () => {
+                            unsubscribeCalled = true;
+                        };
+                    });
+                    // first() completes the subscriber, then RxJS tears down the source
+                    const subscription = obs.pipe(rxjs$1.first()).subscribe();
+                    // After first() + subscribe complete synchronously, teardown should have run
+                    expect(subscription.closed).toBe(true);
+                    expect(unsubscribeCalled).toBe(true);
+                });
+                it('should unsubscribe onSnapshot listeners from document streams after subscriber unsubscribes', test.callbackTest((done) => {
+                    sub.subscription = firebase.latestSnapshotsFromDocuments(items)
+                        .pipe(rxjs$1.first())
+                        .subscribe({
+                        complete: () => {
+                            // With refCount: true on shareReplay, unsubscribing the last subscriber
+                            // tears down the source, which calls unsubscribe on each onSnapshot listener.
+                            // If this test completes without the "active listeners" error, the cleanup worked.
+                            done();
+                        }
+                    });
+                }));
+            });
+        });
+        describe('document.utility.ts', () => {
+            // MARK: newDocuments
+            describe('newDocuments()', () => {
+                it('should create the specified number of document instances', () => {
+                    const count = 3;
+                    const docs = firebase.newDocuments(f.instance.mockItemCollection.documentAccessor(), count);
+                    expect(docs.length).toBe(count);
+                });
+                it('should create documents with unique IDs', () => {
+                    const docs = firebase.newDocuments(f.instance.mockItemCollection.documentAccessor(), 3);
+                    const ids = docs.map((x) => x.id);
+                    expect(util.unique(ids).length).toBe(3);
+                });
+                it('should not persist documents to Firestore', async () => {
+                    const docs = firebase.newDocuments(f.instance.mockItemCollection.documentAccessor(), 2);
+                    for (const doc of docs) {
+                        const exists = await doc.exists();
+                        expect(exists).toBe(false);
+                    }
+                });
+            });
+            // MARK: makeDocuments
+            describe('makeDocuments()', () => {
+                it('should create and persist documents in Firestore', async () => {
+                    const count = 3;
+                    const docs = await firebase.makeDocuments(f.instance.mockItemCollection.documentAccessor(), {
+                        count,
+                        init: (i) => ({ value: `test_${i}`, test: true })
+                    });
+                    expect(docs.length).toBe(count);
+                    for (const doc of docs) {
+                        const exists = await doc.exists();
+                        expect(exists).toBe(true);
+                    }
+                });
+                it('should not persist documents when init returns null', async () => {
+                    const docs = await firebase.makeDocuments(f.instance.mockItemCollection.documentAccessor(), {
+                        count: 2,
+                        init: () => null
+                    });
+                    expect(docs.length).toBe(2);
+                    for (const doc of docs) {
+                        const exists = await doc.exists();
+                        expect(exists).toBe(false);
+                    }
+                });
+                it('should use custom newDocument factory when provided', async () => {
+                    const accessor = f.instance.mockItemCollection.documentAccessor();
+                    const customId = 'custom_doc_id';
+                    const docs = await firebase.makeDocuments(accessor, {
+                        count: 1,
+                        newDocument: (acc) => acc.loadDocumentForId(customId),
+                        init: () => ({ value: 'custom', test: true })
+                    });
+                    expect(docs.length).toBe(1);
+                    expect(docs[0].id).toBe(customId);
+                    const exists = await docs[0].exists();
+                    expect(exists).toBe(true);
+                });
+            });
+            // MARK: getDocumentSnapshots
+            describe('getDocumentSnapshots()', () => {
+                it('should return snapshots for all documents', async () => {
+                    const snapshots = await firebase.getDocumentSnapshots(items);
+                    expect(snapshots.length).toBe(testDocumentCount);
+                    snapshots.forEach((snapshot) => {
+                        expect(snapshot.data()).toBeDefined();
+                    });
+                });
+                it('should preserve ordering of the input array', async () => {
+                    const snapshots = await firebase.getDocumentSnapshots(items);
+                    for (let i = 0; i < items.length; i++) {
+                        expect(snapshots[i].id).toBe(items[i].id);
+                    }
+                });
+            });
+            // MARK: getDocumentSnapshotPair
+            describe('getDocumentSnapshotPair()', () => {
+                it('should return a pair with both document and snapshot', async () => {
+                    const pair = await firebase.getDocumentSnapshotPair(items[0]);
+                    expect(pair.document).toBe(items[0]);
+                    expect(pair.snapshot).toBeDefined();
+                    expect(pair.snapshot.data()).toBeDefined();
+                    expect(pair.snapshot.id).toBe(items[0].id);
+                });
+            });
+            // MARK: getDocumentSnapshotPairs
+            describe('getDocumentSnapshotPairs()', () => {
+                it('should return pairs for all documents', async () => {
+                    const pairs = await firebase.getDocumentSnapshotPairs(items);
+                    expect(pairs.length).toBe(testDocumentCount);
+                    pairs.forEach((pair, i) => {
+                        expect(pair.document).toBe(items[i]);
+                        expect(pair.snapshot.data()).toBeDefined();
+                    });
+                });
+            });
+            // MARK: getDocumentSnapshotDataPair
+            describe('getDocumentSnapshotDataPair()', () => {
+                it('should return a triplet with document, snapshot, and data with id/key', async () => {
+                    const pair = await firebase.getDocumentSnapshotDataPair(items[0]);
+                    expect(pair.document).toBe(items[0]);
+                    expect(pair.snapshot).toBeDefined();
+                    expect(pair.data).toBeDefined();
+                    expect(pair.data.id).toBe(items[0].id);
+                    expect(pair.data.key).toBe(items[0].key);
+                    expect(pair.data.test).toBe(true);
+                });
+                it('should return undefined data for a non-existent document', async () => {
+                    const newDoc = firebase.newDocuments(f.instance.mockItemCollection.documentAccessor(), 1)[0];
+                    const pair = await firebase.getDocumentSnapshotDataPair(newDoc);
+                    expect(pair.document).toBe(newDoc);
+                    expect(pair.data).toBeUndefined();
+                });
+            });
+            // MARK: getDocumentSnapshotDataPairs
+            describe('getDocumentSnapshotDataPairs()', () => {
+                it('should return triplets for all documents', async () => {
+                    const pairs = await firebase.getDocumentSnapshotDataPairs(items);
+                    expect(pairs.length).toBe(testDocumentCount);
+                    pairs.forEach((pair, i) => {
+                        expect(pair.document).toBe(items[i]);
+                        expect(pair.data).toBeDefined();
+                        expect(pair.data.id).toBe(items[i].id);
+                        expect(pair.data.key).toBe(items[i].key);
+                    });
+                });
+            });
+            // MARK: getDocumentSnapshotDataPairsWithData
+            describe('getDocumentSnapshotDataPairsWithData()', () => {
+                it('should return triplets for all existing documents', async () => {
+                    const pairs = await firebase.getDocumentSnapshotDataPairsWithData(items);
+                    expect(pairs.length).toBe(testDocumentCount);
+                    pairs.forEach((pair) => {
+                        expect(pair.data).toBeDefined();
+                        expect(pair.data.id).toBeDefined();
+                        expect(pair.data.key).toBeDefined();
+                    });
+                });
+                it('should filter out non-existent documents', async () => {
+                    const newDoc = firebase.newDocuments(f.instance.mockItemCollection.documentAccessor(), 1)[0];
+                    const allDocs = [...items, newDoc];
+                    const pairs = await firebase.getDocumentSnapshotDataPairsWithData(allDocs);
+                    expect(pairs.length).toBe(testDocumentCount);
+                    expect(pairs.every((p) => p.data != null)).toBe(true);
+                });
+            });
+            // MARK: getDocumentSnapshotDataTuples
+            describe('getDocumentSnapshotDataTuples()', () => {
+                it('should return [document, data] tuples for all documents', async () => {
+                    const tuples = await firebase.getDocumentSnapshotDataTuples(items);
+                    expect(tuples.length).toBe(testDocumentCount);
+                    tuples.forEach((tuple, i) => {
+                        expect(tuple[0]).toBe(items[i]);
+                        expect(tuple[1]).toBeDefined();
+                        expect(tuple[1].test).toBe(true);
+                    });
+                });
+                it('should return undefined data for non-existent documents', async () => {
+                    const newDoc = firebase.newDocuments(f.instance.mockItemCollection.documentAccessor(), 1)[0];
+                    const tuples = await firebase.getDocumentSnapshotDataTuples([newDoc]);
+                    expect(tuples.length).toBe(1);
+                    expect(tuples[0][0]).toBe(newDoc);
+                    expect(tuples[0][1]).toBeUndefined();
+                });
+            });
+            // MARK: getDocumentSnapshotData
+            describe('getDocumentSnapshotData()', () => {
+                it('should return data with id and key by default', async () => {
+                    const data = await firebase.getDocumentSnapshotData(items[0]);
+                    expect(data).toBeDefined();
+                    expect(data.id).toBe(items[0].id);
+                    expect(data.key).toBe(items[0].key);
+                    expect(data.test).toBe(true);
+                });
+                it('should return data with id and key when withId is true', async () => {
+                    const data = await firebase.getDocumentSnapshotData(items[0], true);
+                    expect(data).toBeDefined();
+                    expect(data.id).toBe(items[0].id);
+                    expect(data.key).toBe(items[0].key);
+                });
+                it('should return raw data without id/key when withId is false', async () => {
+                    const data = await firebase.getDocumentSnapshotData(items[0], false);
+                    expect(data).toBeDefined();
+                    expect(data.test).toBe(true);
+                    expect(data.id).toBeUndefined();
+                    expect(data.key).toBeUndefined();
+                });
+                it('should return undefined for a non-existent document', async () => {
+                    const newDoc = firebase.newDocuments(f.instance.mockItemCollection.documentAccessor(), 1)[0];
+                    const data = await firebase.getDocumentSnapshotData(newDoc);
+                    expect(data).toBeUndefined();
+                });
+            });
+            // MARK: getDocumentSnapshotsData
+            describe('getDocumentSnapshotsData()', () => {
+                it('should return data for all existing documents with id/key by default', async () => {
+                    const data = await firebase.getDocumentSnapshotsData(items);
+                    expect(data.length).toBe(testDocumentCount);
+                    data.forEach((d) => {
+                        expect(d.id).toBeDefined();
+                        expect(d.key).toBeDefined();
+                        expect(d.test).toBe(true);
+                    });
+                });
+                it('should return raw data without id/key when withId is false', async () => {
+                    const data = await firebase.getDocumentSnapshotsData(items, false);
+                    expect(data.length).toBe(testDocumentCount);
+                    data.forEach((d) => {
+                        expect(d.test).toBe(true);
+                    });
+                });
+            });
+            // MARK: getDataFromDocumentSnapshots
+            describe('getDataFromDocumentSnapshots()', () => {
+                it('should extract data with id/key from snapshots', async () => {
+                    const snapshots = await firebase.getDocumentSnapshots(items);
+                    const data = firebase.getDataFromDocumentSnapshots(snapshots);
+                    expect(data.length).toBe(testDocumentCount);
+                    data.forEach((d) => {
+                        expect(d.id).toBeDefined();
+                        expect(d.key).toBeDefined();
+                    });
+                });
+                it('should extract raw data when withId is false', async () => {
+                    const snapshots = await firebase.getDocumentSnapshots(items);
+                    const data = firebase.getDataFromDocumentSnapshots(snapshots, false);
+                    expect(data.length).toBe(testDocumentCount);
+                });
+                it('should filter out non-existent document snapshots', async () => {
+                    const newDoc = firebase.newDocuments(f.instance.mockItemCollection.documentAccessor(), 1)[0];
+                    const allDocs = [...items, newDoc];
+                    const snapshots = await firebase.getDocumentSnapshots(allDocs);
+                    const data = firebase.getDataFromDocumentSnapshots(snapshots);
+                    expect(data.length).toBe(testDocumentCount);
+                });
+            });
+            // MARK: loadDocumentsForSnapshots
+            describe('loadDocumentsForSnapshots()', () => {
+                it('should load documents from a query snapshot', async () => {
+                    const querySnapshot = await f.instance.mockItemCollection.query(firebase.where('test', '==', true)).getDocs();
+                    const accessor = f.instance.mockItemCollection.documentAccessor();
+                    const docs = firebase.loadDocumentsForSnapshots(accessor, querySnapshot);
+                    expect(docs.length).toBe(testDocumentCount);
+                    docs.forEach((doc) => {
+                        expect(doc).toBeDefined();
+                        expect(doc.id).toBeDefined();
+                    });
+                });
+            });
+            // MARK: loadDocumentsForDocumentReferences
+            describe('loadDocumentsForDocumentReferences()', () => {
+                it('should load documents from references', () => {
+                    const refs = items.map((x) => x.documentRef);
+                    const accessor = f.instance.mockItemCollection.documentAccessor();
+                    const docs = firebase.loadDocumentsForDocumentReferences(accessor, refs);
+                    expect(docs.length).toBe(testDocumentCount);
+                    docs.forEach((doc, i) => {
+                        expect(doc.id).toBe(items[i].id);
+                    });
+                });
+            });
+            // MARK: loadDocumentsForDocumentReferencesFromValues
+            describe('loadDocumentsForDocumentReferencesFromValues()', () => {
+                it('should extract refs from values and load documents', () => {
+                    const values = items.map((x) => ({ ref: x.documentRef }));
+                    const accessor = f.instance.mockItemCollection.documentAccessor();
+                    const docs = firebase.loadDocumentsForDocumentReferencesFromValues(accessor, values, (v) => v.ref);
+                    expect(docs.length).toBe(testDocumentCount);
+                    docs.forEach((doc, i) => {
+                        expect(doc.id).toBe(items[i].id);
+                    });
+                });
+            });
+            // MARK: loadDocumentsForKeys
+            describe('loadDocumentsForKeys()', () => {
+                it('should load documents from keys', () => {
+                    const keys = items.map((x) => x.key);
+                    const accessor = f.instance.mockItemCollection.documentAccessor();
+                    const docs = firebase.loadDocumentsForKeys(accessor, keys);
+                    expect(docs.length).toBe(testDocumentCount);
+                    docs.forEach((doc, i) => {
+                        expect(doc.key).toBe(items[i].key);
+                    });
+                });
+            });
+            // MARK: loadDocumentsForKeysFromValues
+            describe('loadDocumentsForKeysFromValues()', () => {
+                it('should extract keys from values and load documents', () => {
+                    const values = items.map((x) => ({ k: x.key }));
+                    const accessor = f.instance.mockItemCollection.documentAccessor();
+                    const docs = firebase.loadDocumentsForKeysFromValues(accessor, values, (v) => v.k);
+                    expect(docs.length).toBe(testDocumentCount);
+                    docs.forEach((doc, i) => {
+                        expect(doc.key).toBe(items[i].key);
+                    });
+                });
+            });
+            // MARK: loadDocumentsForIds
+            describe('loadDocumentsForIds()', () => {
+                it('should load documents from IDs', () => {
+                    const ids = items.map((x) => x.id);
+                    const accessor = f.instance.mockItemCollection.documentAccessor();
+                    const docs = firebase.loadDocumentsForIds(accessor, ids);
+                    expect(docs.length).toBe(testDocumentCount);
+                    docs.forEach((doc, i) => {
+                        expect(doc.id).toBe(items[i].id);
+                    });
+                });
+            });
+            // MARK: loadDocumentsForIdsFromValues
+            describe('loadDocumentsForIdsFromValues()', () => {
+                it('should extract IDs from values and load documents', () => {
+                    const values = items.map((x) => ({ docId: x.id }));
+                    const accessor = f.instance.mockItemCollection.documentAccessor();
+                    const docs = firebase.loadDocumentsForIdsFromValues(accessor, values, (v) => v.docId);
+                    expect(docs.length).toBe(testDocumentCount);
+                    docs.forEach((doc, i) => {
+                        expect(doc.id).toBe(items[i].id);
+                    });
+                });
+            });
+            // MARK: firestoreDocumentLoader
+            describe('firestoreDocumentLoader()', () => {
+                it('should create a loader that loads documents from references', () => {
+                    const loader = firebase.firestoreDocumentLoader(f.instance.mockItemCollection);
+                    const refs = items.map((x) => x.documentRef);
+                    const docs = loader(refs);
+                    expect(docs.length).toBe(testDocumentCount);
+                    docs.forEach((doc, i) => {
+                        expect(doc.id).toBe(items[i].id);
+                    });
+                });
+            });
+            // MARK: firestoreDocumentSnapshotPairsLoader
+            describe('firestoreDocumentSnapshotPairsLoader()', () => {
+                it('should create a loader that converts snapshots to data pairs', async () => {
+                    const loader = firebase.firestoreDocumentSnapshotPairsLoader(f.instance.mockItemCollection);
+                    const snapshots = await firebase.getDocumentSnapshots(items);
+                    const pairs = loader(snapshots);
+                    expect(pairs.length).toBe(testDocumentCount);
+                    pairs.forEach((pair) => {
+                        expect(pair.document).toBeDefined();
+                        expect(pair.snapshot).toBeDefined();
+                        expect(pair.data).toBeDefined();
+                        expect(pair.data.id).toBeDefined();
+                        expect(pair.data.key).toBeDefined();
+                    });
+                });
+            });
+            // MARK: documentData
+            describe('documentData()', () => {
+                it('should return data with id/key when withId is true', async () => {
+                    const snapshot = await items[0].accessor.get();
+                    const data = firebase.documentData(snapshot, true);
+                    expect(data).toBeDefined();
+                    expect(data.id).toBe(items[0].id);
+                    expect(data.key).toBe(items[0].key);
+                });
+                it('should return raw data when withId is false', async () => {
+                    const snapshot = await items[0].accessor.get();
+                    const data = firebase.documentData(snapshot, false);
+                    expect(data).toBeDefined();
+                    expect(data.test).toBe(true);
+                });
+            });
+            // MARK: documentDataFunction
+            describe('documentDataFunction()', () => {
+                it('should return a function that extracts data with id/key when withId is true', async () => {
+                    const fn = firebase.documentDataFunction(true);
+                    const snapshot = await items[0].accessor.get();
+                    const data = fn(snapshot);
+                    expect(data).toBeDefined();
+                    expect(data.id).toBe(items[0].id);
+                    expect(data.key).toBe(items[0].key);
+                });
+                it('should return a function that extracts raw data when withId is false', async () => {
+                    const fn = firebase.documentDataFunction(false);
+                    const snapshot = await items[0].accessor.get();
+                    const data = fn(snapshot);
+                    expect(data).toBeDefined();
+                    expect(data.id).toBeUndefined();
+                });
+            });
+            // MARK: documentDataWithIdAndKey
+            describe('documentDataWithIdAndKey()', () => {
+                it('should extract data with id and key from a snapshot', async () => {
+                    const snapshot = await items[0].accessor.get();
+                    const data = firebase.documentDataWithIdAndKey(snapshot);
+                    expect(data).toBeDefined();
+                    expect(data.id).toBe(items[0].id);
+                    expect(data.key).toBe(items[0].key);
+                    expect(data.test).toBe(true);
+                });
+                it('should return undefined for a non-existent document', async () => {
+                    const newDoc = firebase.newDocuments(f.instance.mockItemCollection.documentAccessor(), 1)[0];
+                    const snapshot = await newDoc.accessor.get();
+                    const data = firebase.documentDataWithIdAndKey(snapshot);
+                    expect(data).toBeUndefined();
+                });
+            });
+            // MARK: setIdAndKeyFromSnapshotOnDocumentData
+            describe('setIdAndKeyFromSnapshotOnDocumentData()', () => {
+                it('should mutate data in-place to add id and key from snapshot', async () => {
+                    const snapshot = await items[0].accessor.get();
+                    const rawData = { test: true };
+                    const result = firebase.setIdAndKeyFromSnapshotOnDocumentData(rawData, snapshot);
+                    expect(result.id).toBe(items[0].id);
+                    expect(result.key).toBe(items[0].key);
+                    expect(result).toBe(rawData); // same reference
+                });
+            });
+            // MARK: setIdAndKeyFromKeyIdRefOnDocumentData
+            describe('setIdAndKeyFromKeyIdRefOnDocumentData()', () => {
+                it('should mutate data in-place to add id and key from model ref', () => {
+                    const rawData = { test: true };
+                    const modelRef = { id: items[0].id, key: items[0].key };
+                    const result = firebase.setIdAndKeyFromKeyIdRefOnDocumentData(rawData, modelRef);
+                    expect(result.id).toBe(items[0].id);
+                    expect(result.key).toBe(items[0].key);
+                    expect(result).toBe(rawData);
+                });
+            });
+            // MARK: useDocumentSnapshot
+            describe('useDocumentSnapshot()', () => {
+                it('should fetch snapshot and pass it to the use callback', async () => {
+                    const result = await firebase.useDocumentSnapshot(items[0], (snapshot) => {
+                        expect(snapshot.data()).toBeDefined();
+                        return snapshot.id;
+                    });
+                    expect(result).toBe(items[0].id);
+                });
+                it('should return default value when document is null', async () => {
+                    const result = await firebase.useDocumentSnapshot(null, () => 'used', 'default');
+                    expect(result).toBe('default');
+                });
+            });
+            // MARK: useDocumentSnapshotData
+            describe('useDocumentSnapshotData()', () => {
+                it('should fetch snapshot data and pass it to the use callback', async () => {
+                    const result = await firebase.useDocumentSnapshotData(items[0], (data) => {
+                        expect(data.test).toBe(true);
+                        return data.value;
+                    });
+                    expect(result).toBe('0');
+                });
+                it('should return default value when document is null', async () => {
+                    const result = await firebase.useDocumentSnapshotData(null, () => 'used', 'default');
+                    expect(result).toBe('default');
+                });
+            });
+            // MARK: Key Accessors
+            describe('firestoreModelIdFromDocument()', () => {
+                it('should return the document ID', () => {
+                    const id = firebase.firestoreModelIdFromDocument(items[0]);
+                    expect(id).toBe(items[0].id);
+                });
+            });
+            describe('firestoreModelIdsFromDocuments()', () => {
+                it('should return IDs for all documents', () => {
+                    const ids = firebase.firestoreModelIdsFromDocuments(items);
+                    expect(ids.length).toBe(testDocumentCount);
+                    ids.forEach((id, i) => {
+                        expect(id).toBe(items[i].id);
+                    });
+                });
+            });
+            describe('firestoreModelKeyFromDocument()', () => {
+                it('should return the full Firestore path', () => {
+                    const key = firebase.firestoreModelKeyFromDocument(items[0]);
+                    expect(key).toBe(items[0].key);
+                });
+            });
+            describe('firestoreModelKeysFromDocuments()', () => {
+                it('should return keys for all documents', () => {
+                    const keys = firebase.firestoreModelKeysFromDocuments(items);
+                    expect(keys.length).toBe(testDocumentCount);
+                    keys.forEach((key, i) => {
+                        expect(key).toBe(items[i].key);
+                    });
+                });
+            });
+            describe('documentReferenceFromDocument()', () => {
+                it('should return the document reference', () => {
+                    const ref = firebase.documentReferenceFromDocument(items[0]);
+                    expect(ref).toBe(items[0].documentRef);
+                });
+            });
+            describe('documentReferencesFromDocuments()', () => {
+                it('should return references for all documents', () => {
+                    const refs = firebase.documentReferencesFromDocuments(items);
+                    expect(refs.length).toBe(testDocumentCount);
+                    refs.forEach((ref, i) => {
+                        expect(ref).toBe(items[i].documentRef);
+                    });
+                });
+            });
+            // MARK: limitedFirestoreDocumentAccessorSnapshotCache
+            describe('limitedFirestoreDocumentAccessorSnapshotCache()', () => {
+                it('should expose the underlying accessor', () => {
+                    const accessor = f.instance.mockItemCollection.documentAccessor();
+                    const cache = firebase.limitedFirestoreDocumentAccessorSnapshotCache(accessor);
+                    expect(cache.accessor).toBe(accessor);
+                });
+                describe('getDocumentSnapshotDataPairForKey()', () => {
+                    it('should return a snapshot data pair for an existing document', async () => {
+                        const accessor = f.instance.mockItemCollection.documentAccessor();
+                        const cache = firebase.limitedFirestoreDocumentAccessorSnapshotCache(accessor);
+                        const pair = await cache.getDocumentSnapshotDataPairForKey(items[0].key);
+                        expect(pair.document).toBeDefined();
+                        expect(pair.document.key).toBe(items[0].key);
+                        expect(pair.snapshot).toBeDefined();
+                        expect(pair.data).toBeDefined();
+                        expect(pair.data.id).toBe(items[0].id);
+                        expect(pair.data.key).toBe(items[0].key);
+                    });
+                    it('should return the same promise for the same key', async () => {
+                        const accessor = f.instance.mockItemCollection.documentAccessor();
+                        const cache = firebase.limitedFirestoreDocumentAccessorSnapshotCache(accessor);
+                        const promise1 = cache.getDocumentSnapshotDataPairForKey(items[0].key);
+                        const promise2 = cache.getDocumentSnapshotDataPairForKey(items[0].key);
+                        expect(promise1).toBe(promise2);
+                    });
+                    it('should return undefined data for a non-existent document', async () => {
+                        const accessor = f.instance.mockItemCollection.documentAccessor();
+                        const cache = firebase.limitedFirestoreDocumentAccessorSnapshotCache(accessor);
+                        const newDoc = firebase.newDocuments(accessor, 1)[0];
+                        const pair = await cache.getDocumentSnapshotDataPairForKey(newDoc.key);
+                        expect(pair.document).toBeDefined();
+                        expect(pair.data).toBeUndefined();
+                    });
+                });
+                describe('getDocumentSnapshotDataPairsForKeys()', () => {
+                    it('should return pairs for all keys in order', async () => {
+                        const accessor = f.instance.mockItemCollection.documentAccessor();
+                        const cache = firebase.limitedFirestoreDocumentAccessorSnapshotCache(accessor);
+                        const keys = items.map((x) => x.key);
+                        const pairs = await cache.getDocumentSnapshotDataPairsForKeys(keys);
+                        expect(pairs.length).toBe(testDocumentCount);
+                        pairs.forEach((pair, i) => {
+                            expect(pair.document.key).toBe(items[i].key);
+                            expect(pair.data).toBeDefined();
+                            expect(pair.data.id).toBe(items[i].id);
+                        });
+                    });
+                    it('should use the cache for duplicate keys', async () => {
+                        const accessor = f.instance.mockItemCollection.documentAccessor();
+                        const cache = firebase.limitedFirestoreDocumentAccessorSnapshotCache(accessor);
+                        const key = items[0].key;
+                        const [pair1] = await cache.getDocumentSnapshotDataPairsForKeys([key]);
+                        const [pair2] = await cache.getDocumentSnapshotDataPairsForKeys([key]);
+                        expect(pair1).toBe(pair2);
+                    });
+                });
+                describe('getDocumentSnapshotDataPairsWithDataForKeys()', () => {
+                    it('should return pairs for all existing documents', async () => {
+                        const accessor = f.instance.mockItemCollection.documentAccessor();
+                        const cache = firebase.limitedFirestoreDocumentAccessorSnapshotCache(accessor);
+                        const keys = items.map((x) => x.key);
+                        const pairs = await cache.getDocumentSnapshotDataPairsWithDataForKeys(keys);
+                        expect(pairs.length).toBe(testDocumentCount);
+                        pairs.forEach((pair) => {
+                            expect(pair.data).toBeDefined();
+                            expect(pair.data.id).toBeDefined();
+                            expect(pair.data.key).toBeDefined();
+                        });
+                    });
+                    it('should filter out non-existent documents', async () => {
+                        const accessor = f.instance.mockItemCollection.documentAccessor();
+                        const cache = firebase.limitedFirestoreDocumentAccessorSnapshotCache(accessor);
+                        const newDoc = firebase.newDocuments(accessor, 1)[0];
+                        const keys = [...items.map((x) => x.key), newDoc.key];
+                        const pairs = await cache.getDocumentSnapshotDataPairsWithDataForKeys(keys);
+                        expect(pairs.length).toBe(testDocumentCount);
+                        expect(pairs.every((p) => p.data != null)).toBe(true);
+                    });
+                });
+            });
+        });
+        describe('document.rxjs.ts', () => {
+            // MARK: latestSnapshotsFromDocuments
+            describe('latestSnapshotsFromDocuments()', () => {
+                it('should emit snapshots for all documents', test.callbackTest((done) => {
+                    sub.subscription = firebase.latestSnapshotsFromDocuments(items)
+                        .pipe(rxjs$1.first())
+                        .subscribe((snapshots) => {
+                        expect(snapshots.length).toBe(testDocumentCount);
+                        snapshots.forEach((snapshot, i) => {
+                            expect(snapshot.data()).toBeDefined();
+                            expect(snapshot.id).toBe(items[i].id);
+                        });
+                        done();
+                    });
+                }));
+                it('should emit an empty array for empty input', test.callbackTest((done) => {
+                    sub.subscription = firebase.latestSnapshotsFromDocuments([])
+                        .pipe(rxjs$1.first())
+                        .subscribe((snapshots) => {
+                        expect(snapshots.length).toBe(0);
+                        done();
+                    });
+                }));
+            });
+            // MARK: mapLatestSnapshotsFromDocuments
+            describe('mapLatestSnapshotsFromDocuments()', () => {
+                it('should apply the operator to each document stream', test.callbackTest((done) => {
+                    sub.subscription = firebase.mapLatestSnapshotsFromDocuments(items, rxjs$1.map((snapshot) => snapshot.id))
+                        .pipe(rxjs$1.first())
+                        .subscribe((ids) => {
+                        expect(ids.length).toBe(testDocumentCount);
+                        ids.forEach((id, i) => {
+                            expect(id).toBe(items[i].id);
+                        });
+                        done();
+                    });
+                }));
+                it('should emit an empty array for empty input', test.callbackTest((done) => {
+                    sub.subscription = firebase.mapLatestSnapshotsFromDocuments([], rxjs$1.map((snapshot) => snapshot.id))
+                        .pipe(rxjs$1.first())
+                        .subscribe((ids) => {
+                        expect(ids.length).toBe(0);
+                        done();
+                    });
+                }));
+            });
+            // MARK: streamDocumentSnapshotsData
+            describe('streamDocumentSnapshotsData()', () => {
+                it('should emit data with id/key for all documents', test.callbackTest((done) => {
+                    sub.subscription = firebase.streamDocumentSnapshotsData(items)
+                        .pipe(rxjs$1.first())
+                        .subscribe((data) => {
+                        expect(data.length).toBe(testDocumentCount);
+                        data.forEach((d) => {
+                            expect(d.id).toBeDefined();
+                            expect(d.key).toBeDefined();
+                            expect(d.test).toBe(true);
+                        });
+                        done();
+                    });
+                }));
+                it('should emit an empty array for empty input', test.callbackTest((done) => {
+                    sub.subscription = firebase.streamDocumentSnapshotsData([])
+                        .pipe(rxjs$1.first())
+                        .subscribe((data) => {
+                        expect(data.length).toBe(0);
+                        done();
+                    });
+                }));
+            });
+            // MARK: dataFromDocumentSnapshots operator
+            describe('dataFromDocumentSnapshots()', () => {
+                it('should transform snapshot arrays into data arrays with id/key', test.callbackTest((done) => {
+                    sub.subscription = firebase.latestSnapshotsFromDocuments(items)
+                        .pipe(firebase.dataFromDocumentSnapshots(), rxjs$1.first())
+                        .subscribe((data) => {
+                        expect(data.length).toBe(testDocumentCount);
+                        data.forEach((d) => {
+                            expect(d.id).toBeDefined();
+                            expect(d.key).toBeDefined();
+                        });
+                        done();
+                    });
+                }));
+            });
+            // MARK: streamDocumentSnapshotDataPairs
+            describe('streamDocumentSnapshotDataPairs()', () => {
+                it('should emit snapshot-data pairs for all documents', test.callbackTest((done) => {
+                    sub.subscription = firebase.streamDocumentSnapshotDataPairs(items)
+                        .pipe(rxjs$1.first())
+                        .subscribe((pairs) => {
+                        expect(pairs.length).toBe(testDocumentCount);
+                        pairs.forEach((pair, i) => {
+                            expect(pair.document).toBe(items[i]);
+                            expect(pair.snapshot).toBeDefined();
+                            expect(pair.snapshot.data()).toBeDefined();
+                            expect(pair.data).toBeDefined();
+                            expect(pair.data.id).toBe(items[i].id);
+                            expect(pair.data.key).toBe(items[i].key);
+                            expect(pair.data.test).toBe(true);
+                        });
+                        done();
+                    });
+                }));
+                it('should emit an empty array for empty input', test.callbackTest((done) => {
+                    sub.subscription = firebase.streamDocumentSnapshotDataPairs([])
+                        .pipe(rxjs$1.first())
+                        .subscribe((pairs) => {
+                        expect(pairs.length).toBe(0);
+                        done();
+                    });
+                }));
+            });
+            // MARK: streamDocumentSnapshotDataPairsWithData
+            describe('streamDocumentSnapshotDataPairsWithData()', () => {
+                it('should emit snapshot-data pairs for all existing documents', test.callbackTest((done) => {
+                    sub.subscription = firebase.streamDocumentSnapshotDataPairsWithData(items)
+                        .pipe(rxjs$1.first())
+                        .subscribe((pairs) => {
+                        expect(pairs.length).toBe(testDocumentCount);
+                        pairs.forEach((pair) => {
+                            expect(pair.data).toBeDefined();
+                            expect(pair.data.id).toBeDefined();
+                            expect(pair.data.key).toBeDefined();
+                        });
+                        done();
+                    });
+                }));
+                it('should filter out non-existent documents', test.callbackTest((done) => {
+                    const newDoc = firebase.newDocuments(f.instance.mockItemCollection.documentAccessor(), 1)[0];
+                    const allDocs = [...items, newDoc];
+                    sub.subscription = firebase.streamDocumentSnapshotDataPairsWithData(allDocs)
+                        .pipe(rxjs$1.first())
+                        .subscribe((pairs) => {
+                        expect(pairs.length).toBe(testDocumentCount);
+                        expect(pairs.every((p) => p.data != null)).toBe(true);
+                        done();
+                    });
+                }));
+                it('should emit an empty array for empty input', test.callbackTest((done) => {
+                    sub.subscription = firebase.streamDocumentSnapshotDataPairsWithData([])
+                        .pipe(rxjs$1.first())
+                        .subscribe((pairs) => {
+                        expect(pairs.length).toBe(0);
+                        done();
+                    });
+                }));
+            });
+        });
+    });
+}
+
 /**
  * Describes accessor driver tests, using a MockItemCollectionFixture.
  *
@@ -2923,8 +3731,8 @@ function describeFirestoreIterationTests(f) {
         let items;
         let sub;
         beforeEach(async () => {
-            firestoreIteration = f.instance.firestoreCollection.firestoreIteration;
-            items = await firebase.makeDocuments(f.instance.firestoreCollection.documentAccessor(), {
+            firestoreIteration = f.instance.mockItemCollection.firestoreIteration;
+            items = await firebase.makeDocuments(f.instance.mockItemCollection.documentAccessor(), {
                 count: testDocumentCount,
                 init: (i) => {
                     return {
@@ -3832,6 +4640,7 @@ exports.clearTestFirestoreContextCollections = clearTestFirestoreContextCollecti
 exports.describeFirebaseStorageAccessorDriverTests = describeFirebaseStorageAccessorDriverTests;
 exports.describeFirestoreAccessorDriverTests = describeFirestoreAccessorDriverTests;
 exports.describeFirestoreDocumentAccessorTests = describeFirestoreDocumentAccessorTests;
+exports.describeFirestoreDocumentUtilityTests = describeFirestoreDocumentUtilityTests;
 exports.describeFirestoreIterationTests = describeFirestoreIterationTests;
 exports.describeFirestoreQueryDriverTests = describeFirestoreQueryDriverTests;
 exports.firebaseRulesUnitTestBuilder = firebaseRulesUnitTestBuilder;