@dereekb/firebase 12.7.0 → 13.0.1

package/test/index.esm.js

@@ -0,0 +1,3803 @@
+import { performAsyncTasks, cachedGetter, bitwiseObjectDencoder, modelFieldConversions, isEvenNumber, arrayFactory, mapGetter, randomNumberFactory, randomFromArrayFactory, idBatchFactory, unique, waitForMs, arrayContainsDuplicateValue, useCallback, readableStreamToBuffer, SLASH_PATH_SEPARATOR } from '@dereekb/util';
+import { AbstractTestContextFixture, testContextBuilder, instanceWrapTestContextFactory, AbstractWrappedFixtureWithInstance, itShouldFail, expectFail, callbackTest } from '@dereekb/util/test';
+import { initializeTestEnvironment } from '@firebase/rules-unit-testing';
+import { firebaseStorageClientDrivers, firebaseFirestoreClientDrivers, firestoreContextFactory, firebaseStorageContextFactory, firestoreModelIdentity, snapshotConverterFunctions, firestoreBoolean, optionalFirestoreNumber, optionalFirestoreDate, optionalFirestoreArray, optionalFirestoreString, firestoreDate, firestoreBitwiseObjectMap, firestoreUniqueStringArray, firestoreNumber, firestoreString, firestoreUID, copyUserRelatedDataAccessorFactoryFunction, firestoreSubObject, AbstractFirestoreDocumentWithParent, AbstractFirestoreDocument, firebaseModelServiceFactory, grantFullAccessIfAdmin, firebaseModelsService, systemStateFirestoreCollection, allChildDocumentsUnderParent, where, makeDocuments, getDocumentSnapshotPairs, useDocumentSnapshot, useDocumentSnapshotData, firestoreIdBatchVerifierFactory, whereDocumentId, loadAllFirestoreDocumentSnapshotPairs, loadAllFirestoreDocumentSnapshot, iterateFirestoreDocumentSnapshotPairs, iterateFirestoreDocumentSnapshots, iterateFirestoreDocumentSnapshotPairBatches, iterateFirestoreDocumentSnapshotBatches, limit, orderBy, limitToLast, whereStringHasRootIdentityModelKey, whereStringValueHasPrefix, whereDateIsAfterWithSort, whereDateIsBeforeWithSort, whereDateIsOnOrAfterWithSort, whereDateIsOnOrBeforeWithSort, whereDateIsInRange, whereDateIsBetween, startAt, orderByDocumentId, startAtValue, startAfter, endAt, endAtValue, endBefore, firebaseQuerySnapshotAccumulator, firebaseQueryItemAccumulator, uploadFileWithStream, iterateStorageListFilesByEachFile } from '@dereekb/firebase';
+import { setLogLevel } from 'firebase/firestore';
+import { firstValueFrom, filter, skip, from, first, switchMap } from 'rxjs';
+import { SubscriptionObject, iteratorNextPageUntilPage, flattenAccumulatorResultItemArray, accumulatorCurrentPageListLoadingState, isLoadingStateFinishedLoading, accumulatorFlattenPageListLoadingState } from '@dereekb/rxjs';
+import { addDays, startOfDay, addHours } from 'date-fns';
+import { DateRangeType } from '@dereekb/date';
+import { Readable } from 'stream';
+import { createReadStream } from 'fs';
+
+function makeTestingFirestoreAccesorDriver(driver) {
+    let fuzzerKey = 0;
+    const time = new Date().getTime();
+    const fuzzedMap = new Map();
+    const { collection, subcollection, collectionGroup } = driver;
+    const fuzzedPathForPath = (path) => {
+        let fuzzedPath = fuzzedMap.get(path);
+        if (!fuzzedPath) {
+            const random = Math.ceil(Math.random() * 9999) % 9999;
+            fuzzedPath = `${time}_${random}_${path}_${(fuzzerKey += 1)}`;
+            fuzzedMap.set(path, fuzzedPath);
+        }
+        return fuzzedPath;
+    };
+    const fuzzedCollection = (f, path) => {
+        const fuzzedPath = fuzzedPathForPath(path);
+        return collection(f, fuzzedPath);
+    };
+    const fuzzedSubcollection = (document, path, ...pathSegments) => {
+        const fuzzedPath = fuzzedPathForPath(path);
+        const fuzzedPathSegments = pathSegments.map((x) => fuzzedPathForPath(x));
+        return subcollection(document, fuzzedPath, ...fuzzedPathSegments);
+    };
+    const fuzzedCollectionGroup = (f, collectionId) => {
+        const fuzzedPath = fuzzedPathForPath(collectionId);
+        return collectionGroup(f, fuzzedPath);
+    };
+    const initWithCollectionNames = (collectionNames) => {
+        collectionNames.forEach((x) => fuzzedPathForPath(x));
+        return fuzzedMap;
+    };
+    const injectedDriver = {
+        ...driver,
+        collection: fuzzedCollection,
+        collectionGroup: fuzzedCollectionGroup,
+        subcollection: fuzzedSubcollection,
+        getFuzzedCollectionsNameMap: () => fuzzedMap,
+        initWithCollectionNames,
+        fuzzedPathForPath
+    };
+    return injectedDriver;
+}
+/**
+ * Extends the input drivers to generate new drivers for a testing environment.
+ *
+ * @param drivers
+ * @returns
+ */
+function makeTestingFirestoreDrivers(drivers) {
+    return {
+        ...drivers,
+        firestoreDriverType: 'testing',
+        firestoreAccessorDriver: makeTestingFirestoreAccesorDriver(drivers.firestoreAccessorDriver)
+    };
+}
+async function clearTestFirestoreContextCollections(context, clearCollection) {
+    const names = context.drivers.firestoreAccessorDriver.getFuzzedCollectionsNameMap();
+    const tuples = Array.from(names.entries());
+    await performAsyncTasks(tuples, ([name, fuzzyPath]) => clearCollection(name, fuzzyPath));
+}
+
+let bucketTestNameKey = 0;
+function makeTestingFirebaseStorageAccesorDriver(driver, config) {
+    const { useTestDefaultBucket } = config ?? {};
+    // The default bucket is only used if another bucket is not input.
+    const defaultBucket = (!driver.getDefaultBucket && useTestDefaultBucket !== false) || useTestDefaultBucket === true
+        ? cachedGetter(() => {
+            const time = new Date().getTime();
+            const random = Math.ceil(Math.random() * 999999) % 999999;
+            const testBucketName = `test-bucket-${time}-${random}-${(bucketTestNameKey += 1)}`;
+            return testBucketName;
+        })
+        : driver.getDefaultBucket;
+    const injectedDriver = {
+        ...driver,
+        getDefaultBucket: defaultBucket
+    };
+    return injectedDriver;
+}
+/**
+ * Extends the input drivers to generate new drivers for a testing environment.
+ *
+ * @param drivers
+ * @returns
+ */
+function makeTestingFirebaseStorageDrivers(drivers, config) {
+    return {
+        ...drivers,
+        storageDriverType: 'testing',
+        storageAccessorDriver: makeTestingFirebaseStorageAccesorDriver(drivers.storageAccessorDriver, config)
+    };
+}
+
+class TestFirebaseInstance {
+    firestoreContext;
+    storageContext;
+    constructor(firestoreContext, storageContext) {
+        this.firestoreContext = firestoreContext;
+        this.storageContext = storageContext;
+    }
+    get firestore() {
+        return this.firestoreContext.firestore;
+    }
+    get storage() {
+        return this.storageContext.storage;
+    }
+}
+class TestFirebaseContextFixture extends AbstractTestContextFixture {
+    get firestore() {
+        return this.instance.firestore;
+    }
+    get firestoreContext() {
+        return this.instance.firestoreContext;
+    }
+    get storage() {
+        return this.instance.storage;
+    }
+    get storageContext() {
+        return this.instance.storageContext;
+    }
+}
+
+function makeRulesTestFirestoreContext(drivers, rulesTestEnvironment, rulesTestContext) {
+    const context = {
+        ...firestoreContextFactory(drivers)(rulesTestContext.firestore()),
+        drivers,
+        rulesTestContext,
+        rulesTestEnvironment
+    };
+    return context;
+}
+function makeRulesTestFirebaseStorageContext(drivers, rulesTestEnvironment, rulesTestContext) {
+    const context = {
+        ...firebaseStorageContextFactory(drivers)(rulesTestContext.storage()),
+        drivers,
+        rulesTestContext,
+        rulesTestEnvironment
+    };
+    return context;
+}
+class RulesUnitTestTestFirebaseInstance {
+    drivers;
+    rulesTestEnvironment;
+    rulesTestContext;
+    _firestoreContext = cachedGetter(() => makeRulesTestFirestoreContext(this.drivers, this.rulesTestEnvironment, this.rulesTestContext));
+    _storageContext = cachedGetter(() => makeRulesTestFirebaseStorageContext(this.drivers, this.rulesTestEnvironment, this.rulesTestContext));
+    constructor(drivers, rulesTestEnvironment, rulesTestContext) {
+        this.drivers = drivers;
+        this.rulesTestEnvironment = rulesTestEnvironment;
+        this.rulesTestContext = rulesTestContext;
+    }
+    get firestoreContext() {
+        return this._firestoreContext();
+    }
+    get storageContext() {
+        return this._storageContext();
+    }
+    get firestore() {
+        return this.firestoreContext.firestore;
+    }
+    get storage() {
+        return this.storageContext.storage;
+    }
+}
+class RulesUnitTestFirebaseTestingContextFixture extends TestFirebaseContextFixture {
+}
+/**
+ * A TestContextBuilderFunction for building firebase test context factories using @firebase/firebase and @firebase/rules-unit-testing. This means CLIENT TESTING ONLY. For server testing, look at @dereekb/firestore-server.
+ *
+ * This can be used to easily build a testing context that sets up RulesTestEnvironment for tests that sets itself up and tears itself down.
+ */
+const firebaseRulesUnitTestBuilder = testContextBuilder({
+    buildConfig: (input) => {
+        const config = {
+            testEnvironment: input?.testEnvironment ?? {},
+            rulesContext: input?.rulesContext
+        };
+        return config;
+    },
+    buildFixture: () => new RulesUnitTestFirebaseTestingContextFixture(),
+    setupInstance: async (config) => {
+        const drivers = {
+            ...makeTestingFirestoreDrivers(firebaseFirestoreClientDrivers()),
+            ...makeTestingFirebaseStorageDrivers(firebaseStorageClientDrivers(), { useTestDefaultBucket: true })
+        };
+        let testEnvironment = config.testEnvironment;
+        if (config.testEnvironment.collectionNames) {
+            drivers.firestoreAccessorDriver.initWithCollectionNames(config.testEnvironment.collectionNames);
+            testEnvironment = {
+                ...testEnvironment,
+                firestore: rewriteEmulatorConfigRulesForFuzzedCollectionNames(testEnvironment.firestore)
+            };
+        }
+        const rulesTestEnv = await initializeTestEnvironment(config.testEnvironment);
+        const rulesTestContext = rulesTestContextForConfig(rulesTestEnv, config.rulesContext);
+        return new RulesUnitTestTestFirebaseInstance(drivers, rulesTestEnv, rulesTestContext);
+    },
+    teardownInstance: async (instance, config) => {
+        await instance.rulesTestEnvironment.cleanup().catch((e) => {
+            console.warn('firebaseRulesUnitTestBuilder(): Failed to cleanup rules test environment', e);
+            throw e;
+        });
+    }
+});
+// MARK: Internal
+function rulesTestContextForConfig(rulesTestEnv, testingRulesConfig) {
+    let rulesTestContext;
+    if (testingRulesConfig != null) {
+        rulesTestContext = rulesTestEnv.authenticatedContext(testingRulesConfig.userId, testingRulesConfig.tokenOptions ?? undefined);
+    }
+    else {
+        rulesTestContext = rulesTestEnv.unauthenticatedContext();
+    }
+    return rulesTestContext;
+}
+function rewriteEmulatorConfigRulesForFuzzedCollectionNames(config, fuzzedCollectionNamesMap) {
+    if (config && config.rules) {
+        config = {
+            ...config,
+            rules: rewriteRulesForFuzzedCollectionNames(config.rules)
+        };
+    }
+    return config;
+}
+function rewriteRulesForFuzzedCollectionNames(rules, fuzzedCollectionNamesMap) {
+    // TODO: rewrite the rules using regex matching/replacement.
+    return rules;
+}
+// MARK: Utility
+function changeFirestoreLogLevelBeforeAndAfterTests() {
+    beforeAll(() => setLogLevel('error'));
+    afterAll(() => setLogLevel('warn'));
+}
+
+const TESTING_AUTHORIZED_FIREBASE_USER_ID = '0';
+const authorizedFirebaseFactory = firebaseRulesUnitTestBuilder({
+    testEnvironment: {
+        firestore: {
+            rules: `
+      rules_version = '2';
+      service cloud.firestore {
+        match /databases/{database}/documents {
+          match /{document=**} {
+            allow read, write: if true;
+          }
+        }
+      }
+      `
+        },
+        storage: {
+            rules: `
+      rules_version = '2';
+      service firebase.storage {
+        match /b/{bucket}/o {
+          match /{allPaths=**} {
+            allow read, write: if true;
+          }
+        }
+      }
+      `
+        }
+    },
+    rulesContext: { userId: TESTING_AUTHORIZED_FIREBASE_USER_ID }
+});
+
+// MARK: Mock Item
+const mockItemIdentity = firestoreModelIdentity('mockItem', 'mi');
+class MockItemDocument extends AbstractFirestoreDocument {
+    get modelIdentity() {
+        return mockItemIdentity;
+    }
+}
+/**
+ * Used to build a FirestoreDataConverter. Fields are configured via configuration. See the SnapshotConverterFunctions for more info.
+ */
+const mockItemConverter = snapshotConverterFunctions({
+    fields: {
+        value: optionalFirestoreString(),
+        tags: optionalFirestoreArray(),
+        date: optionalFirestoreDate(),
+        number: optionalFirestoreNumber(),
+        test: firestoreBoolean({ default: true })
+    }
+});
+/**
+ * Used to build a mockItemCollection from a firestore instance with a converter setup.
+ *
+ * @param firestore
+ * @returns
+ */
+function mockItemCollectionReference(context) {
+    return context.collection(mockItemIdentity.collectionName);
+}
+function mockItemFirestoreCollection(firestoreContext) {
+    return firestoreContext.firestoreCollection({
+        converter: mockItemConverter,
+        modelIdentity: mockItemIdentity,
+        collection: mockItemCollectionReference(firestoreContext),
+        makeDocument: (a, d) => new MockItemDocument(a, d),
+        firestoreContext
+    });
+}
+// MARK: MockItemPrivate
+const mockItemPrivateIdentity = firestoreModelIdentity(mockItemIdentity, 'mockItemPrivate', 'mip');
+var MockItemSettingsItemEnum;
+(function (MockItemSettingsItemEnum) {
+    MockItemSettingsItemEnum[MockItemSettingsItemEnum["NORTH"] = 0] = "NORTH";
+    MockItemSettingsItemEnum[MockItemSettingsItemEnum["SOUTH"] = 1] = "SOUTH";
+    MockItemSettingsItemEnum[MockItemSettingsItemEnum["EAST"] = 2] = "EAST";
+    MockItemSettingsItemEnum[MockItemSettingsItemEnum["WEST"] = 3] = "WEST";
+})(MockItemSettingsItemEnum || (MockItemSettingsItemEnum = {}));
+const mockItemSettingsItemDencoder = bitwiseObjectDencoder({
+    maxIndex: 4,
+    toSetFunction: (x) => {
+        const set = new Set();
+        if (x.north) {
+            set.add(MockItemSettingsItemEnum.NORTH);
+        }
+        if (x.south) {
+            set.add(MockItemSettingsItemEnum.SOUTH);
+        }
+        if (x.east) {
+            set.add(MockItemSettingsItemEnum.EAST);
+        }
+        if (x.west) {
+            set.add(MockItemSettingsItemEnum.WEST);
+        }
+        return set;
+    },
+    fromSetFunction: (x) => {
+        const object = {};
+        if (x.has(MockItemSettingsItemEnum.NORTH)) {
+            object.north = true;
+        }
+        if (x.has(MockItemSettingsItemEnum.SOUTH)) {
+            object.south = true;
+        }
+        if (x.has(MockItemSettingsItemEnum.EAST)) {
+            object.east = true;
+        }
+        if (x.has(MockItemSettingsItemEnum.WEST)) {
+            object.west = true;
+        }
+        return object;
+    }
+});
+/**
+ * FirestoreDocument for MockItem
+ */
+class MockItemPrivateDocument extends AbstractFirestoreDocument {
+    get modelIdentity() {
+        return mockItemPrivateIdentity;
+    }
+}
+/**
+ * Used to build a FirestoreDataConverter. Fields are configured via configuration. See the SnapshotConverterFunctions for more info.
+ */
+const mockItemPrivateConverter = snapshotConverterFunctions({
+    fieldConversions: modelFieldConversions({
+        num: firestoreNumber({ default: 0, defaultBeforeSave: 0 }),
+        comments: optionalFirestoreString(),
+        values: firestoreUniqueStringArray(),
+        settings: firestoreBitwiseObjectMap({
+            dencoder: mockItemSettingsItemDencoder
+        }),
+        createdAt: firestoreDate({ saveDefaultAsNow: true })
+    })
+});
+/**
+ * Used to build a mockItemCollection from a firestore instance with a converter setup.
+ *
+ * @param firestore
+ * @returns
+ */
+function mockItemPrivateCollectionReferenceFactory(context) {
+    return (parent) => {
+        return context.subcollection(parent.documentRef, mockItemPrivateIdentity.collectionName);
+    };
+}
+function mockItemPrivateFirestoreCollection(firestoreContext) {
+    const factory = mockItemPrivateCollectionReferenceFactory(firestoreContext);
+    return (parent) => {
+        return firestoreContext.singleItemFirestoreCollection({
+            modelIdentity: mockItemPrivateIdentity,
+            converter: mockItemPrivateConverter,
+            collection: factory(parent),
+            makeDocument: (a, d) => new MockItemPrivateDocument(a, d),
+            firestoreContext,
+            parent
+        });
+    };
+}
+function mockItemPrivateCollectionReference(context) {
+    return context.collectionGroup(mockItemPrivateIdentity.collectionName);
+}
+function mockItemPrivateFirestoreCollectionGroup(firestoreContext) {
+    return firestoreContext.firestoreCollectionGroup({
+        modelIdentity: mockItemPrivateIdentity,
+        converter: mockItemPrivateConverter,
+        queryLike: mockItemPrivateCollectionReference(firestoreContext),
+        makeDocument: (accessor, documentAccessor) => new MockItemPrivateDocument(accessor, documentAccessor),
+        firestoreContext
+    });
+}
+// MARK: MockItemUser
+const mockItemUserIdentity = firestoreModelIdentity(mockItemIdentity, 'mockItemUser', 'miu');
+/**
+ * FirestoreDocument for MockItem
+ */
+class MockItemUserDocument extends AbstractFirestoreDocument {
+    get modelIdentity() {
+        return mockItemUserIdentity;
+    }
+}
+/**
+ * Firestore collection path name.
+ */
+const mockItemUserCollectionName = 'mockItemUser';
+const mockItemUserIdentifier = '0';
+/**
+ * Used to build a FirestoreDataConverter. Fields are configured via configuration. See the SnapshotConverterFunctions for more info.
+ */
+const mockItemUserConverter = snapshotConverterFunctions({
+    fieldConversions: modelFieldConversions({
+        uid: firestoreUID(),
+        name: firestoreString()
+    })
+});
+/**
+ * Used to build a mockItemCollection from a firestore instance with a converter setup.
+ *
+ * @param firestore
+ * @returns
+ */
+function mockItemUserCollectionReferenceFactory(context) {
+    return (parent) => {
+        return context.subcollection(parent.documentRef, mockItemUserCollectionName);
+    };
+}
+const mockItemUserAccessorFactory = copyUserRelatedDataAccessorFactoryFunction();
+function mockItemUserFirestoreCollection(firestoreContext) {
+    const factory = mockItemUserCollectionReferenceFactory(firestoreContext);
+    return (parent) => {
+        return firestoreContext.firestoreCollectionWithParent({
+            modelIdentity: mockItemUserIdentity,
+            converter: mockItemUserConverter,
+            collection: factory(parent),
+            accessorFactory: mockItemUserAccessorFactory,
+            makeDocument: (a, d) => new MockItemUserDocument(a, d),
+            firestoreContext,
+            parent
+        });
+    };
+}
+function mockItemUserCollectionReference(context) {
+    return context.collectionGroup(mockItemUserCollectionName);
+}
+function mockItemUserFirestoreCollectionGroup(firestoreContext) {
+    return firestoreContext.firestoreCollectionGroup({
+        modelIdentity: mockItemUserIdentity,
+        converter: mockItemUserConverter,
+        queryLike: mockItemUserCollectionReference(firestoreContext),
+        accessorFactory: mockItemUserAccessorFactory,
+        makeDocument: (accessor, documentAccessor) => new MockItemUserDocument(accessor, documentAccessor),
+        firestoreContext
+    });
+}
+// MARK: MockItemSubItem
+const mockItemSubItemIdentity = firestoreModelIdentity(mockItemIdentity, 'mockItemSub', 'misi');
+/**
+ * FirestoreDocument for MockItem
+ */
+class MockItemSubItemDocument extends AbstractFirestoreDocumentWithParent {
+    get modelIdentity() {
+        return mockItemSubItemIdentity;
+    }
+}
+/**
+ * Used to build a FirestoreDataConverter. Fields are configured via configuration. See the SnapshotConverterFunctions for more info.
+ */
+const mockItemSubItemConverter = snapshotConverterFunctions({
+    fields: {
+        value: optionalFirestoreNumber()
+    }
+});
+function mockItemSubItemCollectionReferenceFactory(context) {
+    return (parent) => {
+        return context.subcollection(parent.documentRef, mockItemSubItemIdentity.collectionName);
+    };
+}
+function mockItemSubItemFirestoreCollection(firestoreContext) {
+    const factory = mockItemSubItemCollectionReferenceFactory(firestoreContext);
+    return (parent) => {
+        return firestoreContext.firestoreCollectionWithParent({
+            modelIdentity: mockItemSubItemIdentity,
+            converter: mockItemSubItemConverter,
+            collection: factory(parent),
+            makeDocument: (a, d) => new MockItemSubItemDocument(a, d),
+            firestoreContext,
+            parent
+        });
+    };
+}
+function mockItemSubItemCollectionReference(context) {
+    return context.collectionGroup(mockItemSubItemIdentity.collectionName);
+}
+function mockItemSubItemFirestoreCollectionGroup(firestoreContext) {
+    return firestoreContext.firestoreCollectionGroup({
+        modelIdentity: mockItemSubItemIdentity,
+        converter: mockItemSubItemConverter,
+        queryLike: mockItemSubItemCollectionReference(firestoreContext),
+        makeDocument: (accessor, documentAccessor) => new MockItemSubItemDocument(accessor, documentAccessor),
+        firestoreContext
+    });
+}
+// MARK: Sub-Sub Item
+const mockItemSubItemDeepIdentity = firestoreModelIdentity(mockItemSubItemIdentity, 'mockItemSubItemDeep', 'misid');
+/**
+ * FirestoreDocument for MockSubItem
+ */
+class MockItemSubItemDeepDocument extends AbstractFirestoreDocumentWithParent {
+    get modelIdentity() {
+        return mockItemSubItemDeepIdentity;
+    }
+}
+/**
+ * Used to build a FirestoreDataConverter. Fields are configured via configuration. See the SnapshotConverterFunctions for more info.
+ */
+const mockItemSubItemDeepConverter = snapshotConverterFunctions({
+    fields: {
+        value: optionalFirestoreNumber()
+    }
+});
+function mockItemSubItemDeepCollectionReferenceFactory(context) {
+    return (parent) => {
+        return context.subcollection(parent.documentRef, mockItemSubItemDeepIdentity.collectionName);
+    };
+}
+function mockItemSubItemDeepFirestoreCollection(firestoreContext) {
+    const factory = mockItemSubItemDeepCollectionReferenceFactory(firestoreContext);
+    return (parent) => {
+        return firestoreContext.firestoreCollectionWithParent({
+            modelIdentity: mockItemSubItemDeepIdentity,
+            converter: mockItemSubItemDeepConverter,
+            collection: factory(parent),
+            makeDocument: (a, d) => new MockItemSubItemDeepDocument(a, d),
+            firestoreContext,
+            parent
+        });
+    };
+}
+function mockItemSubItemDeepCollectionReference(context) {
+    return context.collectionGroup(mockItemSubItemDeepIdentity.collectionName);
+}
+function mockItemSubItemDeepFirestoreCollectionGroup(firestoreContext) {
+    return firestoreContext.firestoreCollectionGroup({
+        modelIdentity: mockItemSubItemDeepIdentity,
+        converter: mockItemSubItemDeepConverter,
+        queryLike: mockItemSubItemDeepCollectionReference(firestoreContext),
+        makeDocument: (accessor, documentAccessor) => new MockItemSubItemDeepDocument(accessor, documentAccessor),
+        firestoreContext
+    });
+}
+// MARK: Mock System Item
+const MOCK_SYSTEM_STATE_TYPE = 'mockitemsystemstate';
+const mockItemSystemDataConverter = firestoreSubObject({
+    objectField: {
+        fields: {
+            lat: firestoreDate({ saveDefaultAsNow: true })
+        }
+    }
+});
+const mockItemSystemStateStoredDataConverterMap = {
+    [MOCK_SYSTEM_STATE_TYPE]: mockItemSystemDataConverter
+};
+
+// MARK: Collections
+class MockItemCollections {
+}
+function makeMockItemCollections(firestoreContext) {
+    return {
+        mockItemCollection: mockItemFirestoreCollection(firestoreContext),
+        mockItemPrivateCollectionFactory: mockItemPrivateFirestoreCollection(firestoreContext),
+        mockItemPrivateCollectionGroup: mockItemPrivateFirestoreCollectionGroup(firestoreContext),
+        mockItemUserCollectionFactory: mockItemUserFirestoreCollection(firestoreContext),
+        mockItemUserCollectionGroup: mockItemUserFirestoreCollectionGroup(firestoreContext),
+        mockItemSubItemCollectionFactory: mockItemSubItemFirestoreCollection(firestoreContext),
+        mockItemSubItemCollectionGroup: mockItemSubItemFirestoreCollectionGroup(firestoreContext),
+        mockItemSubItemDeepCollectionFactory: mockItemSubItemDeepFirestoreCollection(firestoreContext),
+        mockItemSubItemDeepCollectionGroup: mockItemSubItemDeepFirestoreCollectionGroup(firestoreContext),
+        mockItemSystemStateCollection: systemStateFirestoreCollection(firestoreContext, mockItemSystemStateStoredDataConverterMap)
+    };
+}
+// MARK: Models
+const mockItemFirebaseModelServiceFactory = firebaseModelServiceFactory({
+    roleMapForModel: function (output, context, model) {
+        const roles = context.rolesToReturn ?? { read: true };
+        return roles;
+    },
+    getFirestoreCollection: (c) => c.app.mockItemCollection
+});
+const mockItemPrivateFirebaseModelServiceFactory = firebaseModelServiceFactory({
+    roleMapForModel: function (output, context, model) {
+        const roles = context.rolesToReturn ?? { read: true };
+        return roles;
+    },
+    getFirestoreCollection: (c) => c.app.mockItemPrivateCollectionGroup
+});
+const mockItemUserFirebaseModelServiceFactory = firebaseModelServiceFactory({
+    roleMapForModel: function (output, context, model) {
+        const isOwnerUser = context.auth?.uid === model.documentRef.id;
+        const roles = context.rolesToReturn ?? { read: isOwnerUser };
+        return roles;
+    },
+    getFirestoreCollection: (c) => c.app.mockItemUserCollectionGroup
+});
+const mockItemSubItemFirebaseModelServiceFactory = firebaseModelServiceFactory({
+    roleMapForModel: function (output, context, model) {
+        const roles = context.rolesToReturn ?? { read: true };
+        return roles;
+    },
+    getFirestoreCollection: (c) => c.app.mockItemSubItemCollectionGroup
+});
+const mockItemSubItemDeepFirebaseModelServiceFactory = firebaseModelServiceFactory({
+    roleMapForModel: function (output, context, model) {
+        const roles = context.rolesToReturn ?? { read: true };
+        return roles;
+    },
+    getFirestoreCollection: (c) => c.app.mockItemSubItemDeepCollectionGroup
+});
+const mockItemSystemStateFirebaseModelServiceFactory = firebaseModelServiceFactory({
+    roleMapForModel: function (output, context, model) {
+        return grantFullAccessIfAdmin(context); // only sys-admin allowed
+    },
+    getFirestoreCollection: (c) => c.app.mockItemSystemStateCollection
+});
+const MOCK_FIREBASE_MODEL_SERVICE_FACTORIES = {
+    systemState: mockItemSystemStateFirebaseModelServiceFactory,
+    mockItem: mockItemFirebaseModelServiceFactory,
+    mockItemPrivate: mockItemPrivateFirebaseModelServiceFactory,
+    mockItemUser: mockItemUserFirebaseModelServiceFactory,
+    mockItemSub: mockItemSubItemFirebaseModelServiceFactory,
+    mockItemSubItemDeep: mockItemSubItemDeepFirebaseModelServiceFactory
+};
+const mockFirebaseModelServices = firebaseModelsService(MOCK_FIREBASE_MODEL_SERVICE_FACTORIES);
+
+// MARK: Test Item Testing Fixture
+class MockItemCollectionFixtureInstance {
+    fixture;
+    collections;
+    get collection() {
+        return this.mockItemCollection.collection;
+    }
+    /**
+     * @deprecated Use mockItemCollection instead.
+     */
+    get firestoreCollection() {
+        return this.collections.mockItemCollection;
+    }
+    get mockItemCollection() {
+        return this.collections.mockItemCollection;
+    }
+    get mockItemPrivateCollection() {
+        return this.collections.mockItemPrivateCollectionFactory;
+    }
+    get mockItemSubItemCollection() {
+        return this.collections.mockItemSubItemCollectionFactory;
+    }
+    get mockItemSubItemCollectionGroup() {
+        return this.collections.mockItemSubItemCollectionGroup;
+    }
+    get mockItemUserCollection() {
+        return this.collections.mockItemUserCollectionFactory;
+    }
+    get mockItemUserCollectionGroup() {
+        return this.collections.mockItemUserCollectionGroup;
+    }
+    get mockItemSubItemDeepCollection() {
+        return this.collections.mockItemSubItemDeepCollectionFactory;
+    }
+    get mockItemSubItemDeepCollectionGroup() {
+        return this.collections.mockItemSubItemDeepCollectionGroup;
+    }
+    get mockItemSystemState() {
+        return this.collections.mockItemSystemStateCollection;
+    }
+    constructor(fixture) {
+        this.fixture = fixture;
+        this.collections = makeMockItemCollections(fixture.parent.firestoreContext);
+    }
+}
+/**
+ * Used to expose a CollectionReference to MockItem for simple tests.
+ */
+class MockItemCollectionFixture extends AbstractWrappedFixtureWithInstance {
+}
+function testWithMockItemCollectionFixture(config) {
+    return instanceWrapTestContextFactory({
+        wrapFixture: (fixture) => new MockItemCollectionFixture(fixture),
+        makeInstance: (wrap) => new MockItemCollectionFixtureInstance(wrap),
+        teardownInstance: (instance) => { }
+        // TODO(FUTURE): Utilize config here using the setup/teardown later if needed.
+    });
+}
+
+// MARK: Test Item Testing Fixture
+class MockItemStorageFixtureInstance {
+    fixture;
+    constructor(fixture) {
+        this.fixture = fixture;
+    }
+    get storage() {
+        return this.fixture.parent.storage;
+    }
+    get storageContext() {
+        return this.fixture.parent.storageContext;
+    }
+}
+/**
+ * Used to expose a CollectionReference to MockItem for simple tests.
+ */
+class MockItemStorageFixture extends AbstractWrappedFixtureWithInstance {
+    get storage() {
+        return this.instance.storage;
+    }
+    get storageContext() {
+        return this.instance.storageContext;
+    }
+}
+function testWithMockItemStorageFixture(config) {
+    return instanceWrapTestContextFactory({
+        wrapFixture: (fixture) => new MockItemStorageFixture(fixture),
+        makeInstance: (wrap) => new MockItemStorageFixtureInstance(wrap),
+        teardownInstance: (instance) => { }
+        // TODO(FUTURE): Utilize config here using the setup/teardown later if needed.
+    });
+}
+
+/**
+ * Convenience mock instance for collection tests within an authorized firebase context.
+ *
+ * Uses @firebase/firestore. This is ONLY for the client.
+ */
+const authorizedTestWithMockItemCollection = testWithMockItemCollectionFixture()(authorizedFirebaseFactory);
+/**
+ * Convenience mock instance for storage tests within an authorized firebase context.
+ *
+ * Uses @firebase/storage. This is ONLY for the client.
+ */
+const authorizedTestWithMockItemStorage = testWithMockItemStorageFixture()(authorizedFirebaseFactory);
+
+class TestFirestoreInstance {
+    firestoreContext;
+    constructor(firestoreContext) {
+        this.firestoreContext = firestoreContext;
+    }
+    get firestore() {
+        return this.firestoreContext.firestore;
+    }
+}
+class TestFirestoreContextFixture extends AbstractTestContextFixture {
+    get firestore() {
+        return this.instance.firestore;
+    }
+    get firestoreContext() {
+        return this.instance.firestoreContext;
+    }
+}
+
+function mockItemWithValue(value) {
+    return where('value', '==', value);
+}
+function mockItemWithTestValue(test) {
+    return where('test', '==', test);
+}
+/**
+ * This sorts all fields by their document ID, then filters in between two specific document id paths in order to only return values between a specific path.
+ *
+ * Visual Example:
+ *
+ * /a/b/c/c/a
+ * /a/b/c/d/A
+ * /a/b/c/d/B
+ * /a/b/c/d/C
+ * /a/b/c/e/a
+ *
+ * From:
+ * https://medium.com/firebase-developers/how-to-query-collections-in-firestore-under-a-certain-path-6a0d686cebd2
+ *
+ * @param parent
+ * @returns
+ */
+function allChildMockItemSubItemDeepsWithinMockItem(mockItem) {
+    return allChildDocumentsUnderParent(mockItem);
+}
+
+/**
+ * Describes accessor driver tests, using a MockItemCollectionFixture.
+ *
+ * @param f
+ */
+function describeFirestoreAccessorDriverTests(f) {
+    describe('FirestoreAccessorDriver', () => {
+        const testDocumentCount = 5;
+        let mockItemFirestoreDocumentAccessor;
+        let items;
+        beforeEach(async () => {
+            mockItemFirestoreDocumentAccessor = f.instance.firestoreCollection.documentAccessor();
+            items = await makeDocuments(f.instance.firestoreCollection.documentAccessor(), {
+                count: testDocumentCount,
+                init: (i) => {
+                    return {
+                        value: `${i}`,
+                        test: true,
+                        string: ''
+                    };
+                }
+            });
+        });
+        describe('MockItem', () => {
+            let itemDocument;
+            beforeEach(() => {
+                itemDocument = items[0];
+                itemDocument.accessor;
+            });
+            describe('accessors', () => {
+                describeFirestoreDocumentAccessorTests(() => ({
+                    context: f.parent.firestoreContext,
+                    firestoreDocument: () => itemDocument,
+                    dataForFirstOfTwoUpdates: () => ({ test: true, tags: ['a'] }),
+                    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)
+                }));
+                describe('increment()', () => {
+                    it(`should increase the item's value`, async () => {
+                        let data = await itemDocument.snapshotData();
+                        expect(data?.number).toBe(undefined);
+                        const update = { number: 3 };
+                        await itemDocument.increment(update);
+                        data = await itemDocument.snapshotData();
+                        expect(data?.number).toBe(update.number);
+                        // increment again
+                        await itemDocument.increment(update);
+                        data = await itemDocument.snapshotData();
+                        expect(data?.number).toBe(update.number * 2);
+                    });
+                    it(`should decrease the item's value`, async () => {
+                        let data = await itemDocument.snapshotData();
+                        expect(data?.number).toBe(undefined);
+                        const update = { number: -3 };
+                        await itemDocument.increment(update);
+                        data = await itemDocument.snapshotData();
+                        expect(data?.number).toBe(update.number);
+                        // increment again
+                        await itemDocument.increment(update);
+                        data = await itemDocument.snapshotData();
+                        expect(data?.number).toBe(update.number * 2);
+                    });
+                    it(`should increase and decrease the item's value`, async () => {
+                        let data = await itemDocument.snapshotData();
+                        expect(data?.number).toBe(undefined);
+                        const update = { number: 3 };
+                        await itemDocument.increment(update);
+                        const update2 = { number: -6 };
+                        await itemDocument.increment(update2);
+                        data = await itemDocument.snapshotData();
+                        expect(data?.number).toBe(update.number + update2.number);
+                    });
+                    describe('in transaction', () => {
+                        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 data = await itemDocumentInTransaction.snapshotData();
+                                expect(data?.number).toBe(undefined);
+                                await itemDocumentInTransaction.increment(update);
+                            });
+                            const result = await itemDocument.snapshotData();
+                            expect(result?.number).toBe(update.number);
+                        });
+                    });
+                    describe('in write batch', () => {
+                        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);
+                            await itemDocumentForWriteBatch.increment(update);
+                            await writeBatch.commit();
+                            const result = await itemDocument.snapshotData();
+                            expect(result?.number).toBe(update.number);
+                        });
+                    });
+                });
+                describe('arrayUpdate()', () => {
+                    describe('union', () => {
+                        it('should add to the array', async () => {
+                            await itemDocument.accessor.update({
+                                tags: ['a']
+                            });
+                            await itemDocument.arrayUpdate({
+                                union: {
+                                    tags: ['b', 'c']
+                                }
+                            });
+                            const result = await itemDocument.snapshotData();
+                            expect(result?.tags).toEqual(['a', 'b', 'c']);
+                        });
+                    });
+                    describe('remove', () => {
+                        it('should remove from the array', async () => {
+                            await itemDocument.accessor.update({
+                                tags: ['a', 'b', 'c']
+                            });
+                            await itemDocument.arrayUpdate({
+                                remove: {
+                                    tags: ['a', 'b']
+                                }
+                            });
+                            const result = await itemDocument.snapshotData();
+                            expect(result?.tags).toEqual(['c']);
+                        });
+                    });
+                });
+            });
+            describe('Subcollections', () => {
+                describe('singleItemFirestoreCollection (MockItemUser)', () => {
+                    let testUserId;
+                    let mockItemUserFirestoreCollection;
+                    let itemUserDataDocument;
+                    beforeEach(() => {
+                        testUserId = 'userid' + Math.ceil(Math.random() * 100000);
+                        mockItemUserFirestoreCollection = f.instance.collections.mockItemUserCollectionFactory(itemDocument);
+                        itemUserDataDocument = mockItemUserFirestoreCollection.documentAccessor().loadDocumentForId(testUserId);
+                        itemUserDataDocument.accessor;
+                    });
+                    describe('create()', () => {
+                        describe('mockItemUserAccessorFactory usage', () => {
+                            it('should copy the documents identifier to the uid field on create.', async () => {
+                                await itemUserDataDocument.accessor.create({
+                                    uid: '', // the mockItemUserAccessorFactory silently enforces the uid to be the same as the document.
+                                    name: 'hello'
+                                });
+                                const snapshot = await itemUserDataDocument.accessor.get();
+                                expect(snapshot.data()?.uid).toBe(testUserId);
+                            });
+                        });
+                    });
+                    describe('set()', () => {
+                        describe('mockItemUserAccessorFactory usage', () => {
+                            it('should copy the documents identifier to the uid field on set.', async () => {
+                                await itemUserDataDocument.accessor.set({
+                                    uid: '', // the mockItemUserAccessorFactory silently enforces the uid to be the same as the document.
+                                    name: 'hello'
+                                });
+                                const snapshot = await itemUserDataDocument.accessor.get();
+                                expect(snapshot.data()?.uid).toBe(testUserId);
+                            });
+                        });
+                    });
+                });
+                describe('singleItemFirestoreCollection (MockItemPrivate)', () => {
+                    let mockItemPrivateFirestoreCollection;
+                    let itemPrivateDataDocument;
+                    let privateDataAccessor;
+                    let privateSub;
+                    beforeEach(() => {
+                        mockItemPrivateFirestoreCollection = f.instance.collections.mockItemPrivateCollectionFactory(itemDocument);
+                        itemPrivateDataDocument = mockItemPrivateFirestoreCollection.loadDocument();
+                        privateDataAccessor = itemPrivateDataDocument.accessor;
+                        privateSub = new SubscriptionObject();
+                    });
+                    afterEach(() => {
+                        privateSub.destroy();
+                    });
+                    describe('singleItemFirestoreCollection accessor', () => {
+                        it('should implement FirestoreSingleDocumentAccessor', () => {
+                            expect(mockItemPrivateFirestoreCollection.singleItemIdentifier).toBeDefined();
+                            expect(mockItemPrivateFirestoreCollection.documentRef).toBeDefined();
+                            expect(mockItemPrivateFirestoreCollection.loadDocument).toBeDefined();
+                            expect(mockItemPrivateFirestoreCollection.loadDocumentForTransaction).toBeDefined();
+                            expect(mockItemPrivateFirestoreCollection.loadDocumentForWriteBatch).toBeDefined();
+                        });
+                    });
+                    describe('get()', () => {
+                        it('should read that data using the configured converter', async () => {
+                            await itemPrivateDataDocument.accessor.set({ values: null });
+                            const dataWithoutConverter = (await itemPrivateDataDocument.accessor.getWithConverter(null)).data();
+                            expect(dataWithoutConverter).toBeDefined();
+                            expect(dataWithoutConverter.values).toBeNull();
+                            // converter on client, _converter on server
+                            expect(itemPrivateDataDocument.documentRef.converter ?? itemPrivateDataDocument.documentRef._converter).toBeDefined();
+                            const data = await itemPrivateDataDocument.snapshotData();
+                            expect(data?.values).toBeDefined();
+                            expect(data?.values).not.toBeNull(); // should not be null due to the snapshot converter config
+                        });
+                    });
+                    describe('getWithConverter()', () => {
+                        it('should get the results with the input converter', async () => {
+                            await itemPrivateDataDocument.accessor.set({ values: null });
+                            const data = await itemPrivateDataDocument.snapshotData();
+                            expect(data?.values).toBeDefined();
+                            const dataWithoutConverter = (await itemPrivateDataDocument.accessor.getWithConverter(null)).data();
+                            expect(dataWithoutConverter).toBeDefined();
+                            expect(dataWithoutConverter.values).toBeNull();
+                        });
+                        it('should get the results with the input converter with a type', async () => {
+                            await itemPrivateDataDocument.accessor.set({ values: null });
+                            const data = await itemPrivateDataDocument.snapshotData();
+                            expect(data?.values).toBeDefined();
+                            const converter = mockItemConverter;
+                            const dataWithoutConverter = await itemPrivateDataDocument.accessor.getWithConverter(converter);
+                            expect(dataWithoutConverter).toBeDefined();
+                        });
+                    });
+                    describe('update()', () => {
+                        itShouldFail('if the item does not exist', async () => {
+                            const exists = await itemPrivateDataDocument.accessor.exists();
+                            expect(exists).toBe(false);
+                            await expectFail(() => itemPrivateDataDocument.update({ createdAt: new Date() }));
+                        });
+                        it('should update the item if it exist', async () => {
+                            await itemPrivateDataDocument.create({
+                                createdAt: new Date(),
+                                num: 0,
+                                values: [],
+                                settings: {
+                                    test: {
+                                        north: true,
+                                        south: true
+                                    }
+                                }
+                            });
+                            const newDate = new Date(0);
+                            const exists = await itemPrivateDataDocument.accessor.exists();
+                            expect(exists).toBe(true);
+                            await itemPrivateDataDocument.update({ createdAt: newDate });
+                            const data = await itemPrivateDataDocument.snapshotData();
+                            expect(data?.createdAt.getTime()).toBe(newDate.getTime());
+                            // check was not modified
+                            expect(data?.settings['test'].north).toBe(true);
+                            expect(data?.settings['test'].south).toBe(true);
+                            expect(data?.settings['test'].east).toBeUndefined();
+                            expect(data?.settings['test'].west).toBeUndefined();
+                        });
+                    });
+                    describe('set()', () => {
+                        it('should create the item', async () => {
+                            let exists = await privateDataAccessor.exists();
+                            expect(exists).toBe(false);
+                            const createdAt = new Date();
+                            const settings = {
+                                test: {
+                                    north: true
+                                }
+                            };
+                            await privateDataAccessor.set({
+                                values: [],
+                                num: 0,
+                                createdAt,
+                                settings
+                            });
+                            exists = await privateDataAccessor.exists();
+                            expect(exists).toBe(true);
+                            const getResult = await privateDataAccessor.get();
+                            const data = getResult.data();
+                            expect(data).toBeDefined();
+                            expect(data?.num).toBe(0);
+                            expect(data?.values).toEqual([]);
+                            expect(data?.createdAt).toBeInstanceOf(Date);
+                            expect(data?.createdAt.toISOString()).toBe(createdAt.toISOString());
+                            expect(data?.settings).toEqual(settings);
+                        });
+                    });
+                    describe('with item', () => {
+                        beforeEach(async () => {
+                            await privateDataAccessor.set({ num: 0, values: [], createdAt: new Date(), settings: {} });
+                        });
+                        describe('increment()', () => {
+                            it(`should increase the item's value`, async () => {
+                                let data = await itemPrivateDataDocument.snapshotData();
+                                expect(data?.num).toBe(0);
+                                const update = { num: 3 };
+                                await itemPrivateDataDocument.increment(update);
+                                data = await itemPrivateDataDocument.snapshotData();
+                                expect(data?.num).toBe(update.num);
+                            });
+                        });
+                        describe('accessors', () => {
+                            const TEST_COMMENTS = 'test';
+                            describeFirestoreDocumentAccessorTests(() => ({
+                                context: f.parent.firestoreContext,
+                                firestoreDocument: () => itemPrivateDataDocument,
+                                dataForFirstOfTwoUpdates: () => ({ comments: 'not_test_comments', values: ['a'] }),
+                                hasRemainingDataFromFirstOfTwoUpdate: (data) => data.values.length > 0 && data.values[0] === 'a',
+                                dataForUpdate: () => ({ comments: TEST_COMMENTS }),
+                                hasDataFromUpdate: (data) => data.comments === TEST_COMMENTS,
+                                loadDocumentForTransaction: (transaction, ref) => mockItemPrivateFirestoreCollection.loadDocumentForTransaction(transaction),
+                                loadDocumentForWriteBatch: (writeBatch, ref) => mockItemPrivateFirestoreCollection.loadDocumentForWriteBatch(writeBatch)
+                            }));
+                        });
+                    });
+                });
+                describe('MockItemSubItem', () => {
+                    let subItemDocument;
+                    beforeEach(async () => {
+                        subItemDocument = f.instance.collections.mockItemSubItemCollectionFactory(itemDocument).documentAccessor().newDocument();
+                        await subItemDocument.accessor.set({ value: 0 });
+                    });
+                    describe('firestoreCollectionWithParent (MockItemSubItem)', () => {
+                        let mockItemSubItemFirestoreCollection;
+                        beforeEach(() => {
+                            mockItemSubItemFirestoreCollection = f.instance.collections.mockItemSubItemCollectionFactory(itemDocument);
+                        });
+                        describe('with item', () => {
+                            describe('accessors', () => {
+                                const TEST_VALUE = 1234;
+                                describeFirestoreDocumentAccessorTests(() => ({
+                                    context: f.parent.firestoreContext,
+                                    firestoreDocument: () => subItemDocument,
+                                    dataForFirstOfTwoUpdates: () => ({ value: TEST_VALUE - 10 }),
+                                    dataForUpdate: () => ({ value: TEST_VALUE }),
+                                    hasDataFromUpdate: (data) => data.value === TEST_VALUE,
+                                    loadDocumentForTransaction: (transaction, ref) => mockItemSubItemFirestoreCollection.documentAccessorForTransaction(transaction).loadDocument(ref),
+                                    loadDocumentForWriteBatch: (writeBatch, ref) => mockItemSubItemFirestoreCollection.documentAccessorForWriteBatch(writeBatch).loadDocument(ref)
+                                }));
+                            });
+                        });
+                    });
+                    describe('firestoreCollectionGroup (MockItemSubItem)', () => {
+                        let mockItemSubItemFirestoreCollectionGroup;
+                        beforeEach(() => {
+                            mockItemSubItemFirestoreCollectionGroup = f.instance.collections.mockItemSubItemCollectionGroup;
+                        });
+                        describe('with item', () => {
+                            describe('accessors', () => {
+                                const TEST_VALUE = 1234;
+                                describeFirestoreDocumentAccessorTests(() => ({
+                                    context: f.parent.firestoreContext,
+                                    firestoreDocument: () => subItemDocument,
+                                    dataForFirstOfTwoUpdates: () => ({ value: TEST_VALUE - 10 }),
+                                    dataForUpdate: () => ({ value: TEST_VALUE }),
+                                    hasDataFromUpdate: (data) => data.value === TEST_VALUE,
+                                    loadDocumentForTransaction: (transaction, ref) => mockItemSubItemFirestoreCollectionGroup.documentAccessorForTransaction(transaction).loadDocument(ref),
+                                    loadDocumentForWriteBatch: (writeBatch, ref) => mockItemSubItemFirestoreCollectionGroup.documentAccessorForWriteBatch(writeBatch).loadDocument(ref)
+                                }));
+                            });
+                        });
+                    });
+                });
+            });
+        });
+        describe('documentAccessor()', () => {
+            describe('loadDocumentForKey()', () => {
+                it('should load an existing document from the path.', async () => {
+                    const document = mockItemFirestoreDocumentAccessor.loadDocumentForKey(items[0].key);
+                    const exists = await document.accessor.exists();
+                    expect(exists).toBe(true);
+                });
+                itShouldFail('if the path is invalid (points to collection)', () => {
+                    expectFail(() => {
+                        mockItemFirestoreDocumentAccessor.loadDocumentForKey('path');
+                    });
+                });
+                itShouldFail('if the path points to a different type/collection', () => {
+                    expectFail(() => {
+                        mockItemFirestoreDocumentAccessor.loadDocumentForKey('path/id');
+                    });
+                });
+                itShouldFail('if the path is empty.', () => {
+                    expectFail(() => {
+                        mockItemFirestoreDocumentAccessor.loadDocumentForKey('');
+                    });
+                });
+                itShouldFail('if the path is undefined.', () => {
+                    expectFail(() => {
+                        mockItemFirestoreDocumentAccessor.loadDocumentForKey(undefined);
+                    });
+                });
+                itShouldFail('if the path is null.', () => {
+                    expectFail(() => {
+                        mockItemFirestoreDocumentAccessor.loadDocumentForKey(null);
+                    });
+                });
+            });
+            describe('loadDocumentForId()', () => {
+                it('should return a document with the given id.', () => {
+                    const document = mockItemFirestoreDocumentAccessor.loadDocumentForId('id');
+                    expect(document).toBeDefined();
+                });
+                itShouldFail('if the id is empty.', () => {
+                    expectFail(() => {
+                        mockItemFirestoreDocumentAccessor.loadDocumentForId('');
+                    });
+                });
+                itShouldFail('if the id is undefined.', () => {
+                    expectFail(() => {
+                        mockItemFirestoreDocumentAccessor.loadDocumentForId(undefined);
+                    });
+                });
+            });
+        });
+    });
+}
+function describeFirestoreDocumentAccessorTests(init) {
+    let c;
+    let sub;
+    let firestoreDocument;
+    let accessor;
+    beforeEach(() => {
+        sub = new SubscriptionObject();
+        c = init();
+        firestoreDocument = c.firestoreDocument();
+        accessor = firestoreDocument.accessor;
+    });
+    afterEach(() => {
+        sub.destroy();
+    });
+    describe('utilities', () => {
+        describe('getDocumentSnapshotPairs()', () => {
+            it('should return the document and snapshot pairs for the input.', async () => {
+                const pairs = await getDocumentSnapshotPairs([firestoreDocument]);
+                expect(pairs.length).toBe(1);
+                expect(pairs[0]).toBeDefined();
+                expect(pairs[0].document).toBe(firestoreDocument);
+                expect(pairs[0].snapshot).toBeDefined();
+                expect(pairs[0].snapshot.data()).toBeDefined();
+            });
+        });
+        describe('useDocumentSnapshot()', () => {
+            it(`should use the input document value if it exists`, async () => {
+                const exists = await firestoreDocument.exists();
+                expect(exists).toBe(true);
+                let snapshotUsed = false;
+                await useDocumentSnapshot(firestoreDocument, (snapshot) => {
+                    expect(snapshot).toBeDefined();
+                    snapshotUsed = true;
+                });
+                expect(snapshotUsed).toBe(true);
+            });
+            it(`should not use the input undefined value`, async () => {
+                let snapshotUsed = false;
+                await useDocumentSnapshot(undefined, (snapshot) => {
+                    expect(snapshot).toBeDefined();
+                    snapshotUsed = true;
+                });
+                expect(snapshotUsed).toBe(false);
+            });
+        });
+        describe('useDocumentSnapshotData()', () => {
+            it(`should use the input document's snapshot data if it exists`, async () => {
+                const exists = await firestoreDocument.exists();
+                expect(exists).toBe(true);
+                let snapshotUsed = false;
+                await useDocumentSnapshotData(firestoreDocument, (data) => {
+                    expect(data).toBeDefined();
+                    snapshotUsed = true;
+                });
+                expect(snapshotUsed).toBe(true);
+            });
+        });
+    });
+    describe('AbstractFirestoreDocument', () => {
+        describe('snapshot()', () => {
+            it('should return the snapshot.', async () => {
+                const snapshot = await firestoreDocument.snapshot();
+                expect(snapshot).toBeDefined();
+            });
+        });
+        describe('snapshotData()', () => {
+            it('should return the snapshot data if the model exists.', async () => {
+                const exists = await firestoreDocument.exists();
+                expect(exists).toBe(true);
+                const data = await firestoreDocument.snapshotData();
+                expect(data).toBeDefined();
+            });
+            it('should return the undefined if the model does not exist.', async () => {
+                await accessor.delete();
+                const exists = await firestoreDocument.exists();
+                expect(exists).toBe(false);
+                const data = await firestoreDocument.snapshotData();
+                expect(data).toBeUndefined();
+            });
+        });
+        describe('create()', () => {
+            it('should create the document if it does not exist.', async () => {
+                const snapshot = await firestoreDocument.snapshot();
+                await accessor.delete();
+                let exists = await firestoreDocument.exists();
+                expect(exists).toBe(false);
+                await firestoreDocument.create(snapshot.data());
+                exists = await firestoreDocument.exists();
+                expect(exists).toBe(true);
+            });
+            itShouldFail('if the document exists.', async () => {
+                const snapshot = await firestoreDocument.snapshot();
+                const exists = await firestoreDocument.exists();
+                expect(exists).toBe(true);
+                await expectFail(() => firestoreDocument.create(snapshot.data()));
+            });
+        });
+        describe('update()', () => {
+            it('should update the data if the document exists.', async () => {
+                const data = c.dataForUpdate();
+                await firestoreDocument.update(data);
+                const snapshot = await firestoreDocument.snapshot();
+                expect(c.hasDataFromUpdate(snapshot.data())).toBe(true);
+            });
+            itShouldFail('if the document does not exist.', async () => {
+                await accessor.delete();
+                const snapshot = await firestoreDocument.snapshot();
+                expect(snapshot.data()).toBe(undefined);
+                const exists = await firestoreDocument.exists();
+                expect(exists).toBe(false);
+                await expectFail(() => firestoreDocument.update(c.dataForUpdate()));
+            });
+            it('should not throw an error if the input update data is empty.', async () => {
+                await firestoreDocument.update({});
+            });
+        });
+        describe('transaction', () => {
+            describe('stream$', () => {
+                it('should not cause the transaction to fail if the document is loaded after changes have begun.', async () => {
+                    await c.context.runTransaction(async (transaction) => {
+                        const transactionDocument = await c.loadDocumentForTransaction(transaction, firestoreDocument.documentRef);
+                        const currentData = await transactionDocument.snapshotData();
+                        expect(currentData).toBeDefined();
+                        const data = c.dataForUpdate();
+                        await transactionDocument.update(data);
+                        // stream$ and data$ do not call stream() until called directly.
+                        const secondLoading = await c.loadDocumentForTransaction(transaction, firestoreDocument.documentRef);
+                        expect(secondLoading).toBeDefined();
+                    });
+                });
+                itShouldFail('if stream$ is called after an update has occured in the transaction', async () => {
+                    await expectFail(() => c.context.runTransaction(async (transaction) => {
+                        const transactionDocument = await c.loadDocumentForTransaction(transaction, firestoreDocument.documentRef);
+                        const currentData = await transactionDocument.snapshotData();
+                        expect(currentData).toBeDefined();
+                        const data = c.dataForUpdate();
+                        await transactionDocument.update(data);
+                        // read the stream using a promise so the error is captured
+                        await firstValueFrom(c.loadDocumentForTransaction(transaction, firestoreDocument.documentRef).stream$);
+                    }));
+                });
+            });
+            describe('update()', () => {
+                it('should update the data if the document exists.', async () => {
+                    await c.context.runTransaction(async (transaction) => {
+                        const transactionDocument = await c.loadDocumentForTransaction(transaction, firestoreDocument.documentRef);
+                        const currentData = await transactionDocument.snapshotData();
+                        expect(currentData).toBeDefined();
+                        const data = c.dataForUpdate();
+                        await transactionDocument.update(data);
+                    });
+                    const snapshot = await firestoreDocument.snapshot();
+                    expect(c.hasDataFromUpdate(snapshot.data())).toBe(true);
+                });
+                describe('multiple updates', () => {
+                    it('should merge the updates together and override the values from the first update that are defined in the second update', async () => {
+                        await c.context.runTransaction(async (transaction) => {
+                            const transactionDocument = await c.loadDocumentForTransaction(transaction, firestoreDocument.documentRef);
+                            const currentData = await transactionDocument.snapshotData();
+                            expect(currentData).toBeDefined();
+                            const firstData = c.dataForFirstOfTwoUpdates();
+                            await transactionDocument.update(firstData);
+                            const data = c.dataForUpdate();
+                            await transactionDocument.update(data);
+                        });
+                        const snapshot = await firestoreDocument.snapshot();
+                        expect(c.hasDataFromUpdate(snapshot.data())).toBe(true);
+                        if (c.hasRemainingDataFromFirstOfTwoUpdate != null) {
+                            expect(c.hasRemainingDataFromFirstOfTwoUpdate(snapshot.data())).toBe(true);
+                        }
+                    });
+                });
+            });
+        });
+        describe('write batch', () => {
+            describe('update()', () => {
+                it('should update the data if the document exists.', async () => {
+                    const batch = c.context.batch();
+                    const batchDocument = await c.loadDocumentForWriteBatch(batch, firestoreDocument.documentRef);
+                    const data = c.dataForUpdate();
+                    await batchDocument.update(data);
+                    await batch.commit();
+                    const snapshot = await firestoreDocument.snapshot();
+                    expect(c.hasDataFromUpdate(snapshot.data())).toBe(true);
+                });
+            });
+        });
+    });
+    describe('accessor', () => {
+        describe('stream()', () => {
+            it('should return a snapshot stream', async () => {
+                const result = await accessor.stream();
+                expect(result).toBeDefined();
+            });
+            it('should emit values on updates from the observable.', callbackTest((done) => {
+                let count = 0;
+                sub.subscription = accessor.stream().subscribe((item) => {
+                    count += 1;
+                    if (count === 1) {
+                        expect(c.hasDataFromUpdate(item.data())).toBe(false);
+                    }
+                    else if (count === 2) {
+                        expect(c.hasDataFromUpdate(item.data())).toBe(true);
+                        done();
+                    }
+                });
+                setTimeout(() => {
+                    accessor.update(c.dataForUpdate());
+                }, 100);
+            }));
+            describe('in transition context', () => {
+                let runTransaction;
+                beforeEach(() => {
+                    runTransaction = c.context.runTransaction;
+                });
+                it('should return the first emitted value (observable completes immediately)', async () => {
+                    await runTransaction(async (transaction) => {
+                        const transactionItemDocument = c.loadDocumentForTransaction(transaction, accessor.documentRef);
+                        // load the value
+                        const value = await firstValueFrom(transactionItemDocument.accessor.stream());
+                        expect(value).toBeDefined();
+                        // set to make the transaction valid
+                        await transactionItemDocument.accessor.set({ value: 0 }, { merge: true });
+                        return value;
+                    });
+                });
+            });
+            describe('in batch context', () => {
+                it('should return the first emitted value (observable completes immediately)', async () => {
+                    const writeBatch = c.context.batch();
+                    const batchItemDocument = c.loadDocumentForWriteBatch(writeBatch, accessor.documentRef);
+                    // load the value
+                    const value = await firstValueFrom(batchItemDocument.accessor.stream());
+                    expect(value).toBeDefined();
+                    // set to make the batch changes valid
+                    await batchItemDocument.accessor.set({ value: 0 }, { merge: true });
+                    // commit the changes
+                    await writeBatch.commit();
+                });
+            });
+        });
+        describe('create()', () => {
+            it('should create the document if it does not exist.', async () => {
+                const snapshot = await accessor.get();
+                await accessor.delete();
+                let exists = await accessor.exists();
+                expect(exists).toBe(false);
+                await accessor.create(snapshot.data());
+                exists = await accessor.exists();
+                expect(exists).toBe(true);
+            });
+            itShouldFail('if the document exists.', async () => {
+                const snapshot = await accessor.get();
+                const exists = await accessor.exists();
+                expect(exists).toBe(true);
+                await expectFail(() => accessor.create(snapshot.data()));
+            });
+        });
+        describe('get()', () => {
+            it('should return a snapshot', async () => {
+                const result = await accessor.get();
+                expect(result).toBeDefined();
+                expect(result.id).toBeDefined();
+            });
+        });
+        describe('exists()', () => {
+            it('should return true if the document exists', async () => {
+                const exists = await accessor.exists();
+                expect(exists).toBe(true);
+            });
+            it('should return false if the document does not exist', async () => {
+                await accessor.delete();
+                const exists = await accessor.exists();
+                expect(exists).toBe(false);
+            });
+        });
+        describe('update()', () => {
+            it('should update the data if the document exists.', async () => {
+                const data = c.dataForUpdate();
+                await accessor.update(data);
+                const snapshot = await accessor.get();
+                expect(c.hasDataFromUpdate(snapshot.data())).toBe(true);
+            });
+            itShouldFail('if the document does not exist.', async () => {
+                await accessor.delete();
+                const snapshot = await accessor.get();
+                expect(snapshot.data()).toBe(undefined);
+                const exists = await accessor.exists();
+                expect(exists).toBe(false);
+                await expectFail(() => accessor.update(c.dataForUpdate()));
+            });
+            itShouldFail('if the input is an empty object.', async () => {
+                await expectFail(() => accessor.update({}));
+            });
+            // TODO(TEST): test that update does not call the converter when setting values.
+        });
+        describe('set()', () => {
+            it('should create the object if it does not exist.', async () => {
+                await accessor.delete();
+                let exists = await accessor.exists();
+                expect(exists).toBe(false);
+                const data = c.dataForUpdate();
+                await accessor.set(data);
+                exists = await accessor.exists();
+                expect(exists).toBe(true);
+                const snapshot = await accessor.get();
+                expect(c.hasDataFromUpdate(snapshot.data())).toBe(true);
+            });
+            it('should update the data on the document for fields that are not undefined.', async () => {
+                const data = c.dataForUpdate();
+                await accessor.set(data);
+                const snapshot = await accessor.get();
+                expect(c.hasDataFromUpdate(snapshot.data())).toBe(true);
+            });
+            describe('merge=true', () => {
+                it('should update the data if the document exists.', async () => {
+                    const data = c.dataForUpdate();
+                    await accessor.set(data, { merge: true });
+                    const snapshot = await accessor.get();
+                    expect(c.hasDataFromUpdate(snapshot.data())).toBe(true);
+                });
+                it('should succeed if the document does not exist.', async () => {
+                    await accessor.delete();
+                    let snapshot = await accessor.get();
+                    expect(snapshot.data()).toBe(undefined);
+                    const exists = await accessor.exists();
+                    expect(exists).toBe(false);
+                    await accessor.set(c.dataForUpdate(), { merge: true });
+                    snapshot = await accessor.get();
+                    expect(c.hasDataFromUpdate(snapshot.data())).toBe(true);
+                });
+            });
+            // TODO(TEST): test that set calls the converter when setting values.
+        });
+        describe('delete()', () => {
+            it('should delete the document.', async () => {
+                await accessor.delete();
+                const snapshot = await accessor.get();
+                expect(snapshot.data()).toBe(undefined);
+                const exists = await accessor.exists();
+                expect(exists).toBe(false);
+            });
+        });
+    });
+}
+
+/**
+ * Describes query driver tests, using a MockItemCollectionFixture.
+ *
+ * @param f
+ */
+function describeFirestoreQueryDriverTests(f) {
+    describe('FirestoreQueryDriver', () => {
+        const testDocumentCount = 5;
+        let items;
+        const startDate = addDays(startOfDay(new Date()), 1);
+        const EVEN_TAG = 'even';
+        const ODD_TAG = 'odd';
+        beforeEach(async () => {
+            items = await makeDocuments(f.instance.firestoreCollection.documentAccessor(), {
+                count: testDocumentCount,
+                init: (i) => {
+                    return {
+                        value: `${i}`,
+                        number: i,
+                        date: addHours(startDate, i),
+                        tags: [`${i}`, `${isEvenNumber(i) ? EVEN_TAG : ODD_TAG}`],
+                        test: true
+                    };
+                }
+            });
+        });
+        describe('firestoreIdBatchVerifierFactory()', () => {
+            const mockItemIdBatchVerifier = firestoreIdBatchVerifierFactory({
+                readKeys: (x) => [x.id],
+                fieldToQuery: '_id'
+            });
+            it('should query on the id field.', async () => {
+                const takenIds = items.map((x) => x.id);
+                const result = await f.instance.mockItemCollection.queryDocument(whereDocumentId('in', takenIds)).getDocs();
+                expect(result).toBeDefined();
+                expect(result.length).toBe(takenIds.length);
+                expect(result.map((x) => x.id)).toContain(takenIds[0]);
+            });
+            it('should return ids that are not taken.', async () => {
+                const takenIds = items.map((x) => x.id);
+                const idFactory = arrayFactory(mapGetter(randomNumberFactory(10000000), (x) => `test-id-${x}`));
+                const random = randomFromArrayFactory(takenIds);
+                const factory = idBatchFactory({
+                    verifier: mockItemIdBatchVerifier(f.instance.mockItemCollection),
+                    factory: (count) => {
+                        const ids = [random(), ...idFactory(count)];
+                        return ids;
+                    }
+                });
+                const idsToMake = 30;
+                const result = await factory(idsToMake);
+                expect(result).toBeDefined();
+                expect(unique(result).length).toBe(idsToMake);
+                expect(unique(result, takenIds).length).toBe(idsToMake);
+            });
+        });
+        describe('mockItemUser', () => {
+            let testUserId;
+            let allMockUserItems;
+            beforeEach(async () => {
+                testUserId = 'userid' + Math.ceil(Math.random() * 100000);
+                const results = await Promise.all(items.map((parent) => makeDocuments(f.instance.mockItemUserCollection(parent).documentAccessor(), {
+                    count: 1,
+                    newDocument: (x) => x.loadDocumentForId(testUserId),
+                    init: (i) => {
+                        return {
+                            uid: '',
+                            name: `name ${i}`
+                        };
+                    }
+                })));
+                allMockUserItems = results.flat();
+            });
+            describe('utils', () => {
+                describe('iterate load firestore utilities', () => {
+                    describe('loadAllFirestoreDocumentSnapshotPairs()', () => {
+                        it('should iterate batches of snapshot pairs.', async () => {
+                            const documentAccessor = f.instance.mockItemUserCollectionGroup.documentAccessor();
+                            const mockUserItemsVisited = new Set();
+                            const result = await loadAllFirestoreDocumentSnapshotPairs({
+                                documentAccessor,
+                                iterateSnapshotPairsBatch: async (x) => {
+                                    x.forEach((y) => mockUserItemsVisited.add(y.document.key));
+                                    const pair = x[0];
+                                    expect(pair.data).toBeDefined();
+                                    expect(pair.snapshot).toBeDefined();
+                                    expect(pair.document).toBeDefined();
+                                },
+                                queryFactory: f.instance.mockItemUserCollectionGroup,
+                                constraintsFactory: [] // no constraints
+                            });
+                            expect(result.totalSnapshotsVisited).toBe(allMockUserItems.length);
+                            expect(mockUserItemsVisited.size).toBe(allMockUserItems.length);
+                            expect(result.snapshotPairs.length).toBe(allMockUserItems.length);
+                            expect(result.snapshotPairs[0].data).toBeDefined();
+                            expect(result.snapshotPairs[0].document).toBeDefined();
+                            expect(result.snapshotPairs[0].snapshot).toBeDefined();
+                        });
+                    });
+                    describe('loadAllFirestoreDocumentSnapshot()', () => {
+                        it('should iterate batches of snapshot pairs.', async () => {
+                            const mockUserItemsVisited = new Set();
+                            const result = await loadAllFirestoreDocumentSnapshot({
+                                iterateSnapshotsForCheckpoint: async (x) => {
+                                    x.forEach((y) => mockUserItemsVisited.add(y.ref.path));
+                                    const snapshot = x[0];
+                                    expect(snapshot.ref).toBeDefined();
+                                    expect(snapshot.data()).toBeDefined();
+                                },
+                                queryFactory: f.instance.mockItemUserCollectionGroup,
+                                constraintsFactory: [] // no constraints
+                            });
+                            expect(result.totalSnapshotsVisited).toBe(allMockUserItems.length);
+                            expect(mockUserItemsVisited.size).toBe(allMockUserItems.length);
+                            expect(result.snapshots.length).toBe(allMockUserItems.length);
+                            expect(result.snapshots[0].ref).toBeDefined();
+                            expect(result.snapshots[0].data()).toBeDefined();
+                        });
+                    });
+                });
+                describe('iterate firestore utilities', () => {
+                    describe('iterateFirestoreDocumentSnapshotPairs()', () => {
+                        it('should iterate across all mock users by each snapshot pair.', async () => {
+                            const documentAccessor = f.instance.mockItemUserCollectionGroup.documentAccessor();
+                            const mockUserItemsVisited = new Set();
+                            const batchSize = 2;
+                            const result = await iterateFirestoreDocumentSnapshotPairs({
+                                batchSize,
+                                handleRepeatCursor: false, // exit immediately if the cursor is visited again
+                                filterCheckpointSnapshots: async (x) => {
+                                    return x;
+                                },
+                                iterateSnapshotPair: async (x) => {
+                                    expect(x.data).toBeDefined();
+                                    expect(x.snapshot).toBeDefined();
+                                    expect(x.document).toBeDefined();
+                                    const key = x.document.key;
+                                    if (mockUserItemsVisited.has(key)) {
+                                        throw new Error('encountered repeat key');
+                                    }
+                                    else {
+                                        mockUserItemsVisited.add(key);
+                                    }
+                                },
+                                useCheckpointResult: async (x) => {
+                                    if (x.docSnapshots.length > 0) {
+                                        expect(x.results[0].snapshots.length).toBeLessThanOrEqual(batchSize);
+                                    }
+                                },
+                                documentAccessor,
+                                queryFactory: f.instance.mockItemUserCollectionGroup,
+                                constraintsFactory: [] // no constraints
+                            });
+                            expect(result.totalSnapshotsVisited).toBe(allMockUserItems.length);
+                            expect(mockUserItemsVisited.size).toBe(allMockUserItems.length);
+                        });
+                        describe('1 item exists', () => {
+                            let onlyItem;
+                            beforeEach(async () => {
+                                onlyItem = allMockUserItems.pop();
+                                await Promise.all(allMockUserItems.map((x) => x.accessor.delete()));
+                                allMockUserItems = [onlyItem];
+                            });
+                            it('should iterate the single item', async () => {
+                                const documentAccessor = f.instance.mockItemUserCollectionGroup.documentAccessor();
+                                const mockUserItemsVisited = new Set();
+                                expect(allMockUserItems).toHaveLength(1);
+                                const result = await iterateFirestoreDocumentSnapshotPairs({
+                                    iterateSnapshotPair: async (x) => {
+                                        expect(x.data).toBeDefined();
+                                        expect(x.snapshot).toBeDefined();
+                                        expect(x.document).toBeDefined();
+                                        const key = x.document.key;
+                                        if (mockUserItemsVisited.has(key)) {
+                                            throw new Error('encountered repeat key');
+                                        }
+                                        else {
+                                            mockUserItemsVisited.add(key);
+                                        }
+                                    },
+                                    documentAccessor,
+                                    queryFactory: f.instance.mockItemUserCollectionGroup,
+                                    batchSize: null,
+                                    limitPerCheckpoint: 200,
+                                    totalSnapshotsLimit: 100,
+                                    performTasksConfig: {
+                                        maxParallelTasks: 20
+                                    },
+                                    constraintsFactory: [] // no constraints
+                                });
+                                expect(mockUserItemsVisited.size).toBe(allMockUserItems.length);
+                                expect(result.totalSnapshotsVisited).toBe(allMockUserItems.length);
+                            });
+                            // TODO(TEST): Case where a document was visited twice via iteration after it was updated. Assumed
+                            // to occur when the updated item matches an "or" case or other value when using "in". Cannot
+                            // reproduce at the moment.
+                            /*
+                            describe('scenario', () => {
+              
+                              it('should visit the item twice if it is updated and matches a different filter', async () => {
+                                const onlyItemValue = await onlyItem.snapshotData() as MockItemUser;
+                                const nameToChangeTo = `${onlyItemValue.name}-changed`;
+                                const namesToFilter = [onlyItemValue.name, nameToChangeTo];
+              
+                                const documentAccessor = f.instance.mockItemUserCollectionGroup.documentAccessor();
+                                const mockUserItemsVisited = new Set<MockItemUserKey>();
+                                let updates = 0;
+              
+                                expect(allMockUserItems).toHaveLength(1);
+              
+                                const result = await iterateFirestoreDocumentSnapshotPairs({
+                                  iterateSnapshotPair: async (x) => {
+                                    expect(x.data).toBeDefined();
+                                    expect(x.snapshot).toBeDefined();
+                                    expect(x.document).toBeDefined();
+              
+                                    await x.document.update({ name: nameToChangeTo });
+                                    updates += 1;
+              
+                                    const key = x.document.key;
+                                    mockUserItemsVisited.add(key);
+                                  },
+                                  documentAccessor,
+                                  queryFactory: f.instance.mockItemUserCollectionGroup,
+                                  batchSize: null,
+                                  limitPerCheckpoint: 200,
+                                  totalSnapshotsLimit: 100,
+                                  performTasksConfig: {
+                                    maxParallelTasks: 20
+                                  },
+                                  constraintsFactory: () => [where<MockItemUser>('name', 'in', namesToFilter)],
+                                });
+              
+                                expect(updates).toBe(2);
+                                expect(result.totalSnapshotsVisited).toBe(2);
+                                expect(mockUserItemsVisited.size).toBe(1);
+                              });
+              
+                            });
+                            */
+                        });
+                        describe('0 items exists', () => {
+                            beforeEach(async () => {
+                                await Promise.all(allMockUserItems.map((x) => x.accessor.delete()));
+                            });
+                            it('should iterate no items', async () => {
+                                const documentAccessor = f.instance.mockItemUserCollectionGroup.documentAccessor();
+                                const mockUserItemsVisited = new Set();
+                                const result = await iterateFirestoreDocumentSnapshotPairs({
+                                    iterateSnapshotPair: async (x) => {
+                                        expect(x.data).toBeDefined();
+                                        expect(x.snapshot).toBeDefined();
+                                        expect(x.document).toBeDefined();
+                                        const key = x.document.key;
+                                        if (mockUserItemsVisited.has(key)) {
+                                            throw new Error('encountered repeat key');
+                                        }
+                                        else {
+                                            mockUserItemsVisited.add(key);
+                                        }
+                                    },
+                                    documentAccessor,
+                                    queryFactory: f.instance.mockItemUserCollectionGroup,
+                                    constraintsFactory: [] // no constraints
+                                });
+                                expect(result.totalSnapshotsVisited).toBe(0);
+                                expect(mockUserItemsVisited.size).toBe(0);
+                            });
+                        });
+                    });
+                    describe('iterateFirestoreDocumentSnapshots()', () => {
+                        it('should iterate across all mock users by each snapshot.', async () => {
+                            f.instance.mockItemUserCollectionGroup.documentAccessor();
+                            const mockUserItemsVisited = new Set();
+                            const batchSize = 2;
+                            const result = await iterateFirestoreDocumentSnapshots({
+                                batchSize,
+                                iterateSnapshot: async (x) => {
+                                    const key = x.ref.path;
+                                    if (mockUserItemsVisited.has(key)) {
+                                        throw new Error('encountered repeat key');
+                                    }
+                                    else {
+                                        mockUserItemsVisited.add(key);
+                                    }
+                                },
+                                useCheckpointResult: async (x) => {
+                                    if (x.docSnapshots.length > 0) {
+                                        expect(x.results[0].snapshots.length).toBeLessThanOrEqual(batchSize);
+                                    }
+                                },
+                                queryFactory: f.instance.mockItemUserCollectionGroup,
+                                constraintsFactory: [] // no constraints
+                            });
+                            expect(result.totalSnapshotsVisited).toBe(allMockUserItems.length);
+                            expect(mockUserItemsVisited.size).toBe(allMockUserItems.length);
+                        });
+                    });
+                    describe('iterateFirestoreDocumentSnapshotPairBatches()', () => {
+                        it('should iterate batches of snapshot pairs.', async () => {
+                            const documentAccessor = f.instance.mockItemUserCollectionGroup.documentAccessor();
+                            const mockUserItemsVisited = new Set();
+                            const batchSize = 2;
+                            const result = await iterateFirestoreDocumentSnapshotPairBatches({
+                                documentAccessor,
+                                batchSize, // use specific batch size
+                                iterateSnapshotPairsBatch: async (x) => {
+                                    expect(x.length).toBeLessThanOrEqual(batchSize);
+                                    const pair = x[0];
+                                    expect(pair.data).toBeDefined();
+                                    expect(pair.snapshot).toBeDefined();
+                                    expect(pair.document).toBeDefined();
+                                },
+                                useCheckpointResult: async (x) => {
+                                    x.docSnapshots.forEach((y) => mockUserItemsVisited.add(y.ref.path));
+                                },
+                                queryFactory: f.instance.mockItemUserCollectionGroup,
+                                constraintsFactory: [] // no constraints
+                            });
+                            expect(result.totalSnapshotsVisited).toBe(allMockUserItems.length);
+                            expect(mockUserItemsVisited.size).toBe(allMockUserItems.length);
+                        });
+                    });
+                    describe('iterateFirestoreDocumentSnapshotBatches()', () => {
+                        it('should iterate batches of snapshots.', async () => {
+                            const mockUserItemsVisited = new Set();
+                            const batchSize = 2;
+                            const result = await iterateFirestoreDocumentSnapshotBatches({
+                                batchSize, // use specific batch size
+                                iterateSnapshotBatch: async (x) => {
+                                    expect(x.length).toBeLessThanOrEqual(batchSize);
+                                },
+                                useCheckpointResult: async (x) => {
+                                    x.docSnapshots.forEach((y) => mockUserItemsVisited.add(y.ref.path));
+                                },
+                                queryFactory: f.instance.mockItemUserCollectionGroup,
+                                constraintsFactory: [] // no constraints
+                            });
+                            expect(result.totalSnapshotsVisited).toBe(allMockUserItems.length);
+                            expect(mockUserItemsVisited.size).toBe(allMockUserItems.length);
+                        });
+                        describe('limitPerCheckpoint', () => {
+                            describe('limitPerCheckpoint = 0', () => {
+                                it('should not iterate any batches', async () => {
+                                    const result = await iterateFirestoreDocumentSnapshotBatches({
+                                        limitPerCheckpoint: 0,
+                                        iterateSnapshotBatch: async (x) => {
+                                            expect(x.length).toBe(0);
+                                        },
+                                        useCheckpointResult: async (x) => {
+                                            expect(x.docSnapshots.length).toBe(0);
+                                        },
+                                        queryFactory: f.instance.mockItemUserCollectionGroup,
+                                        constraintsFactory: [] // no constraints
+                                    });
+                                    expect(result.totalSnapshotsVisited).toBe(0);
+                                    expect(result.totalSnapshotsLimitReached).toBe(true);
+                                });
+                            });
+                        });
+                        describe('maxParallelCheckpoints>1', () => {
+                            it('should process the checkpoints in parallel.', async () => {
+                                const mockUserItemsVisited = new Set();
+                                const batchSize = 1;
+                                const maxParallelCheckpoints = 4;
+                                let currentRunningTasks = 0;
+                                let maxRunningTasks = 0;
+                                const result = await iterateFirestoreDocumentSnapshotBatches({
+                                    batchSize, // use specific batch size
+                                    limitPerCheckpoint: 1,
+                                    maxParallelCheckpoints, // do four checkpoints in parallel
+                                    iterateSnapshotBatch: async (x, batchIndex) => {
+                                        currentRunningTasks += 1;
+                                        await waitForMs(1000);
+                                        maxRunningTasks = Math.max(maxRunningTasks, currentRunningTasks);
+                                        currentRunningTasks -= 1;
+                                    },
+                                    useCheckpointResult: async (x) => {
+                                        x.docSnapshots.forEach((y) => mockUserItemsVisited.add(y.ref.path));
+                                    },
+                                    queryFactory: f.instance.mockItemUserCollectionGroup,
+                                    constraintsFactory: [] // no constraints
+                                });
+                                expect(maxRunningTasks).toBe(maxParallelCheckpoints);
+                                expect(result.totalSnapshotsVisited).toBe(allMockUserItems.length);
+                                expect(mockUserItemsVisited.size).toBe(allMockUserItems.length);
+                            });
+                        });
+                        describe('batchSize=null', () => {
+                            it('should iterate with a single batch', async () => {
+                                const mockUserItemsVisited = new Set();
+                                const batchSize = null;
+                                const result = await iterateFirestoreDocumentSnapshotBatches({
+                                    batchSize, // use specific batch size
+                                    iterateSnapshotBatch: async (x) => {
+                                        expect(x.length).toBe(allMockUserItems.length);
+                                    },
+                                    useCheckpointResult: async (x) => {
+                                        x.docSnapshots.forEach((y) => mockUserItemsVisited.add(y.ref.path));
+                                    },
+                                    queryFactory: f.instance.mockItemUserCollectionGroup,
+                                    constraintsFactory: [] // no constraints
+                                });
+                                expect(result.totalSnapshotsVisited).toBe(allMockUserItems.length);
+                                expect(mockUserItemsVisited.size).toBe(allMockUserItems.length);
+                            });
+                        });
+                        describe('batchSizeForSnapshots: () => null', () => {
+                            it('should iterate with a single batch', async () => {
+                                const mockUserItemsVisited = new Set();
+                                const result = await iterateFirestoreDocumentSnapshotBatches({
+                                    batchSizeForSnapshots: () => null,
+                                    iterateSnapshotBatch: async (x) => {
+                                        expect(x.length).toBe(allMockUserItems.length);
+                                    },
+                                    useCheckpointResult: async (x) => {
+                                        x.docSnapshots.forEach((y) => mockUserItemsVisited.add(y.ref.path));
+                                    },
+                                    queryFactory: f.instance.mockItemUserCollectionGroup,
+                                    constraintsFactory: [] // no constraints
+                                });
+                                expect(result.totalSnapshotsVisited).toBe(allMockUserItems.length);
+                                expect(mockUserItemsVisited.size).toBe(allMockUserItems.length);
+                            });
+                        });
+                    });
+                });
+            });
+            describe('collection group', () => {
+                describe('query', () => {
+                    describe('constraints', () => {
+                        describe('where', () => {
+                            it('should return the documents matching the input uid', async () => {
+                                const result = await f.instance.mockItemUserCollectionGroup.query(where('uid', '==', testUserId)).getDocs();
+                                expect(result.docs.length).toBe(testDocumentCount);
+                                result.docs.forEach((x) => {
+                                    expect(x.data().uid).toBe(testUserId);
+                                });
+                            });
+                        });
+                    });
+                });
+            });
+        });
+        describe('nested items', () => {
+            const subItemCountPerItem = 2;
+            const totalSubItemsCount = subItemCountPerItem * testDocumentCount;
+            let parentA;
+            let querySubItems;
+            let allSubItems;
+            beforeEach(async () => {
+                querySubItems = f.instance.mockItemSubItemCollectionGroup.query;
+                parentA = items[0];
+                const results = await Promise.all(items.map((parent) => makeDocuments(f.instance.mockItemSubItemCollection(parent).documentAccessor(), {
+                    count: subItemCountPerItem,
+                    init: (i) => {
+                        return {
+                            value: i
+                        };
+                    }
+                })));
+                allSubItems = results.flat();
+            });
+            describe('sub sub item', () => {
+                const deepSubItemCountPerItem = 1;
+                const totalDeepSubItemsPerMockItem = subItemCountPerItem * deepSubItemCountPerItem;
+                let queryDeepSubItems;
+                beforeEach(async () => {
+                    queryDeepSubItems = f.instance.mockItemSubItemDeepCollectionGroup.query;
+                    allSubItems[0];
+                    const results = await Promise.all(allSubItems.map((parent) => makeDocuments(f.instance.mockItemSubItemDeepCollection(parent).documentAccessor(), {
+                        count: deepSubItemCountPerItem,
+                        init: (i) => {
+                            return {
+                                value: i
+                            };
+                        }
+                    })));
+                    results.flat();
+                });
+                // tests querying for all nested items under a parent
+                it('querying for only items belonging to mock item parentA', async () => {
+                    const result = await queryDeepSubItems(allChildMockItemSubItemDeepsWithinMockItem(parentA.documentRef)).getDocs();
+                    expect(result.docs.length).toBe(totalDeepSubItemsPerMockItem);
+                    result.docs.forEach((x) => expect(x.ref.parent?.parent?.parent?.parent?.path).toBe(parentA.documentRef.path));
+                });
+                // TODO(TEST): Add tests for allChildDocumentsUnderRelativePath
+            });
+            describe('sub item', () => {
+                describe('collection group', () => {
+                    describe('query', () => {
+                        it('should return sub items', async () => {
+                            const result = await querySubItems().getDocs();
+                            expect(result.docs.length).toBe(totalSubItemsCount);
+                        });
+                        describe('constraints', () => {
+                            describe('where', () => {
+                                it('should return the documents matching the query.', async () => {
+                                    const value = 0;
+                                    const result = await querySubItems(where('value', '==', value)).getDocs();
+                                    expect(result.docs.length).toBe(testDocumentCount);
+                                    expect(result.docs[0].data().value).toBe(value);
+                                    const ref = result.docs[0].ref;
+                                    expect(ref).toBeDefined();
+                                    expect(ref.parent).toBeDefined();
+                                });
+                            });
+                            describe('whereDocumentId', () => {
+                                itShouldFail('to query on collection groups.', async () => {
+                                    // https://stackoverflow.com/questions/56149601/firestore-collection-group-query-on-documentid
+                                    const targetId = 'targetid';
+                                    /*
+                                    const results = await Promise.all(
+                                      allSubItems.map((parent: MockItemSubItemDocument) =>
+                                        makeDocuments(f.instance.mockItemSubItemDeepCollection(parent).documentAccessor(), {
+                                          count: 1,
+                                          newDocument: (x) => x.loadDocumentForId(targetId),
+                                          init: (i) => {
+                                            return {
+                                              value: i
+                                            };
+                                          }
+                                        })
+                                      )
+                                    );
+                                    */
+                                    await expectFail(() => querySubItems(whereDocumentId('==', targetId)).getDocs());
+                                });
+                            });
+                        });
+                        describe('streamDocs()', () => {
+                            let sub;
+                            beforeEach(() => {
+                                sub = new SubscriptionObject();
+                            });
+                            afterEach(() => {
+                                sub.destroy();
+                            });
+                            it('should emit when the query results update (an item is added).', callbackTest((done) => {
+                                const itemsToAdd = 1;
+                                let addCompleted = false;
+                                let addSeen = false;
+                                function tryComplete() {
+                                    if (addSeen && addCompleted) {
+                                        done();
+                                    }
+                                }
+                                sub.subscription = querySubItems()
+                                    .streamDocs()
+                                    .pipe(filter((x) => x.docs.length > allSubItems.length))
+                                    .subscribe((results) => {
+                                    addSeen = true;
+                                    expect(results.docs.length).toBe(allSubItems.length + itemsToAdd);
+                                    tryComplete();
+                                });
+                                // add one item
+                                makeDocuments(f.instance.mockItemSubItemCollection(parentA).documentAccessor(), {
+                                    count: itemsToAdd,
+                                    init: (i) => {
+                                        return {
+                                            value: i
+                                        };
+                                    }
+                                }).then(() => {
+                                    addCompleted = true;
+                                    tryComplete();
+                                });
+                            }));
+                            it('should emit when the query results update (an item is removed).', callbackTest((done) => {
+                                const itemsToRemove = 1;
+                                let deleteCompleted = false;
+                                let deleteSeen = false;
+                                function tryComplete() {
+                                    if (deleteSeen && deleteCompleted) {
+                                        done();
+                                    }
+                                }
+                                sub.subscription = querySubItems()
+                                    .streamDocs()
+                                    .pipe(filter((x) => x.docs.length < allSubItems.length))
+                                    .subscribe((results) => {
+                                    deleteSeen = true;
+                                    expect(results.docs.length).toBe(allSubItems.length - itemsToRemove);
+                                    tryComplete();
+                                });
+                                allSubItems[0].accessor.exists().then((exists) => {
+                                    expect(exists).toBe(true);
+                                    // remove one item
+                                    return allSubItems[0].accessor.delete().then(() => {
+                                        deleteCompleted = true;
+                                        tryComplete();
+                                    });
+                                });
+                            }));
+                        });
+                    });
+                });
+            });
+        });
+        describe('queryDocument', () => {
+            let queryDocument;
+            beforeEach(async () => {
+                queryDocument = f.instance.firestoreCollection.queryDocument;
+            });
+            describe('filter()', () => {
+                it('should apply the filter to the query', async () => {
+                    const results = (await queryDocument()
+                        .filter(where('tags', 'array-contains', EVEN_TAG))
+                        .getDocSnapshotDataPairs());
+                    expect(results).toBeDefined();
+                    results.forEach((result) => {
+                        expect(result.data).toBeDefined();
+                        expect(result.data?.tags).toContain(EVEN_TAG);
+                        expect(result.document).toBeDefined();
+                        expect(result.document instanceof MockItemDocument).toBe(true);
+                        expect(result.snapshot).toBeDefined();
+                        expect(result.snapshot.data()).toBeDefined();
+                        expect(result.snapshot.ref).toBeDefined();
+                        expect(result.snapshot.id).toBe(result.document.id);
+                    });
+                });
+                it('should add more filters to the existing query', async () => {
+                    const results = (await queryDocument()
+                        .filter(where('tags', 'array-contains', EVEN_TAG))
+                        .filter(where('number', '>=', 4))
+                        .getDocSnapshotDataPairs());
+                    expect(results).toBeDefined();
+                    expect(results.length).toBe(1);
+                    results.forEach((result) => {
+                        expect(result.data).toBeDefined();
+                        expect(result.data?.tags).toContain(EVEN_TAG);
+                        expect(result.data?.number).toBeGreaterThanOrEqual(4);
+                        expect(result.document).toBeDefined();
+                        expect(result.document instanceof MockItemDocument).toBe(true);
+                        expect(result.snapshot).toBeDefined();
+                        expect(result.snapshot.data()).toBeDefined();
+                        expect(result.snapshot.ref).toBeDefined();
+                        expect(result.snapshot.id).toBe(result.document.id);
+                    });
+                });
+            });
+            describe('getFirstDocSnapshotDataPair()', () => {
+                it('should return undefined if the query contains nothing', async () => {
+                    const result = (await queryDocument(where('value', '==', '_DOES_NOT_EXIST_')).getFirstDocSnapshotDataPair());
+                    expect(result).not.toBeDefined();
+                });
+                it('should return the first doc that matches if it exists', async () => {
+                    const result = (await queryDocument().getFirstDocSnapshotDataPair());
+                    expect(result).toBeDefined();
+                    expect(result.data).toBeDefined();
+                    expect(result.document).toBeDefined();
+                    expect(result.document instanceof MockItemDocument).toBe(true);
+                    expect(result.snapshot).toBeDefined();
+                    expect(result.snapshot.data()).toBeDefined();
+                    expect(result.snapshot.ref).toBeDefined();
+                    expect(result.snapshot.id).toBe(result.document.id);
+                });
+            });
+            describe('getDocSnapshotDataPairs()', () => {
+                it('should return an empty array if the query returns nothing', async () => {
+                    const result = await queryDocument(where('value', '==', '_DOES_NOT_EXIST_')).getDocSnapshotDataPairs();
+                    expect(result).toBeDefined();
+                    expect(result.length).toBe(0);
+                });
+                it('should return the matching results', async () => {
+                    const results = await queryDocument().getDocSnapshotDataPairs();
+                    expect(results).toBeDefined();
+                    expect(results.length).toBeGreaterThan(0);
+                    results.forEach((result) => {
+                        expect(result).toBeDefined();
+                        expect(result.data).toBeDefined();
+                        expect(result.document).toBeDefined();
+                        expect(result.document instanceof MockItemDocument).toBe(true);
+                        expect(result.snapshot).toBeDefined();
+                        expect(result.snapshot.data()).toBeDefined();
+                        expect(result.snapshot.ref).toBeDefined();
+                        expect(result.snapshot.id).toBe(result.document.id);
+                    });
+                });
+            });
+            describe('streamDocs()', () => {
+                let sub;
+                beforeEach(() => {
+                    sub = new SubscriptionObject();
+                });
+                afterEach(() => {
+                    sub.destroy();
+                });
+                it('should emit when the query results update (an item is added).', callbackTest((done) => {
+                    const itemsToAdd = 1;
+                    let addCompleted = false;
+                    let addSeen = false;
+                    function tryComplete() {
+                        if (addSeen && addCompleted) {
+                            done();
+                        }
+                    }
+                    sub.subscription = queryDocument()
+                        .streamDocs()
+                        .pipe(filter((documents) => documents.length > items.length))
+                        .subscribe((documents) => {
+                        addSeen = true;
+                        expect(documents.length).toBe(items.length + itemsToAdd);
+                        tryComplete();
+                    });
+                    // add one item
+                    waitForMs(10).then(() => makeDocuments(f.instance.firestoreCollection.documentAccessor(), {
+                        count: itemsToAdd,
+                        init: (i) => {
+                            return {
+                                value: `${i + items.length}`,
+                                test: true
+                            };
+                        }
+                    }).then(() => {
+                        addCompleted = true;
+                        tryComplete();
+                    }));
+                }));
+                it('should emit when the query results update (an item is removed).', callbackTest((done) => {
+                    const itemsToRemove = 1;
+                    let deleteCompleted = false;
+                    let deleteSeen = false;
+                    function tryComplete() {
+                        if (deleteSeen && deleteCompleted) {
+                            done();
+                        }
+                    }
+                    sub.subscription = queryDocument()
+                        .streamDocs()
+                        .pipe(skip(1))
+                        .subscribe((documents) => {
+                        deleteSeen = true;
+                        expect(documents.length).toBe(items.length - itemsToRemove);
+                        tryComplete();
+                    });
+                    waitForMs(10).then(() => items[0].exists().then((exists) => {
+                        expect(exists).toBe(true);
+                        // remove one item
+                        return items[0].accessor.delete().then(() => {
+                            deleteCompleted = true;
+                            tryComplete();
+                        });
+                    }));
+                }));
+            });
+            describe('streamDocSnapshotDataPairs()', () => {
+                let sub;
+                beforeEach(() => {
+                    sub = new SubscriptionObject();
+                });
+                afterEach(() => {
+                    sub.destroy();
+                });
+                it('should emit when the query results update (an item is added).', callbackTest((done) => {
+                    const itemsToAdd = 1;
+                    let addCompleted = false;
+                    let addSeen = false;
+                    function tryComplete() {
+                        if (addSeen && addCompleted) {
+                            done();
+                        }
+                    }
+                    sub.subscription = queryDocument()
+                        .streamDocSnapshotDataPairs()
+                        .pipe(filter((documents) => documents.length > items.length))
+                        .subscribe((documents) => {
+                        addSeen = true;
+                        expect(documents.length).toBe(items.length + itemsToAdd);
+                        documents.forEach((x) => {
+                            // validate each document returned
+                            expect(x.data).toBeDefined();
+                            expect(x.document).toBeDefined();
+                            expect(x.document instanceof MockItemDocument).toBe(true);
+                            expect(x.snapshot).toBeDefined();
+                            expect(x.snapshot.data()).toBeDefined();
+                            expect(x.snapshot.ref).toBeDefined();
+                            expect(x.snapshot.id).toBe(x.document.id);
+                        });
+                        tryComplete();
+                    });
+                    // add one item
+                    waitForMs(10).then(() => makeDocuments(f.instance.firestoreCollection.documentAccessor(), {
+                        count: itemsToAdd,
+                        init: (i) => {
+                            return {
+                                value: `${i + items.length}`,
+                                test: true
+                            };
+                        }
+                    }).then(() => {
+                        addCompleted = true;
+                        tryComplete();
+                    }));
+                }));
+                it('should emit when the query results update (an item is removed).', callbackTest((done) => {
+                    const itemsToRemove = 1;
+                    let deleteCompleted = false;
+                    let deleteSeen = false;
+                    function tryComplete() {
+                        if (deleteSeen && deleteCompleted) {
+                            done();
+                        }
+                    }
+                    sub.subscription = queryDocument()
+                        .streamDocs()
+                        .pipe(skip(1))
+                        .subscribe((documents) => {
+                        deleteSeen = true;
+                        expect(documents.length).toBe(items.length - itemsToRemove);
+                        tryComplete();
+                    });
+                    waitForMs(10).then(() => items[0].exists().then((exists) => {
+                        expect(exists).toBe(true);
+                        // remove one item
+                        return items[0].accessor.delete().then(() => {
+                            deleteCompleted = true;
+                            tryComplete();
+                        });
+                    }));
+                }));
+            });
+        });
+        describe('query', () => {
+            let query;
+            beforeEach(async () => {
+                query = f.instance.firestoreCollection.query;
+            });
+            describe('streamDocs()', () => {
+                let sub;
+                beforeEach(() => {
+                    sub = new SubscriptionObject();
+                });
+                afterEach(() => {
+                    sub.destroy();
+                });
+                it('should emit when the query results update (an item is added).', callbackTest((done) => {
+                    const itemsToAdd = 1;
+                    let addCompleted = false;
+                    let addSeen = false;
+                    function tryComplete() {
+                        if (addSeen && addCompleted) {
+                            done();
+                        }
+                    }
+                    sub.subscription = query()
+                        .streamDocs()
+                        .pipe(filter((x) => x.docs.length > items.length))
+                        .subscribe((results) => {
+                        addSeen = true;
+                        expect(results.docs.length).toBe(items.length + itemsToAdd);
+                        tryComplete();
+                    });
+                    // add one item
+                    waitForMs(10).then(() => makeDocuments(f.instance.firestoreCollection.documentAccessor(), {
+                        count: itemsToAdd,
+                        init: (i) => {
+                            return {
+                                value: `${i + items.length}`,
+                                test: true
+                            };
+                        }
+                    }).then(() => {
+                        addCompleted = true;
+                        tryComplete();
+                    }));
+                }));
+                it('should emit when the query results update (an item is removed).', callbackTest((done) => {
+                    const itemsToRemove = 1;
+                    let deleteCompleted = false;
+                    let deleteSeen = false;
+                    function tryComplete() {
+                        if (deleteSeen && deleteCompleted) {
+                            done();
+                        }
+                    }
+                    sub.subscription = query()
+                        .streamDocs()
+                        .pipe(skip(1))
+                        .subscribe((results) => {
+                        deleteSeen = true;
+                        expect(results.docs.length).toBe(items.length - itemsToRemove);
+                        tryComplete();
+                    });
+                    waitForMs(10).then(() => items[0].accessor.exists().then((exists) => {
+                        expect(exists).toBe(true);
+                        // remove one item
+                        return items[0].accessor.delete().then(() => {
+                            deleteCompleted = true;
+                            tryComplete();
+                        });
+                    }));
+                }));
+            });
+            describe('constraint', () => {
+                describe('limit', () => {
+                    it('should limit the number of items returned.', async () => {
+                        const limitCount = 2;
+                        const unlimited = await query().getDocs();
+                        expect(unlimited.docs.length).toBe(testDocumentCount);
+                        const result = await query(limit(limitCount)).getDocs();
+                        expect(result.docs.length).toBe(limitCount);
+                    });
+                    it('should limit the streamed results.', callbackTest((done) => {
+                        const limitCount = 2;
+                        const resultObs = query(limit(limitCount)).streamDocs();
+                        from(resultObs)
+                            .pipe(first())
+                            .subscribe((results) => {
+                            expect(results.docs.length).toBe(limitCount);
+                            done();
+                        });
+                    }));
+                    it('should limit the number of items counted.', async () => {
+                        const limitCount = 2;
+                        const unlimited = await query().countDocs();
+                        expect(unlimited).toBe(testDocumentCount);
+                        const result = await query(limit(limitCount)).countDocs();
+                        expect(result).toBe(limitCount);
+                    });
+                });
+                describe('limitToLast', () => {
+                    it('should limit the number of items returned.', async () => {
+                        const limitCount = 2;
+                        const unlimited = await query().getDocs();
+                        expect(unlimited.docs.length).toBe(testDocumentCount);
+                        const result = await query(orderBy('value'), limitToLast(limitCount)).getDocs();
+                        expect(result.docs.length).toBe(limitCount);
+                    });
+                    it('the results should be returned from the end of the list. The results are still in the same order as requested.', async () => {
+                        const limitCount = 2;
+                        const result = await query(orderBy('value', 'asc'), limitToLast(limitCount)).getDocs();
+                        expect(result.docs.length).toBe(limitCount);
+                        expect(result.docs[0].data().value).toBe('3');
+                        expect(result.docs[1].data().value).toBe('4');
+                    });
+                    itShouldFail('if orderby is not provided.', async () => {
+                        const limitCount = 2;
+                        const unlimited = await query().getDocs();
+                        expect(unlimited.docs.length).toBe(testDocumentCount);
+                        await expectFail(() => query(limitToLast(limitCount)).getDocs());
+                    });
+                    it('should stream results.', callbackTest((done) => {
+                        const limitCount = 2;
+                        const resultObs = query(orderBy('value'), limitToLast(limitCount)).streamDocs();
+                        from(resultObs)
+                            .pipe(first())
+                            .subscribe((results) => {
+                            expect(results.docs.length).toBe(limitCount);
+                            done();
+                        });
+                    }));
+                    it('should limit the number of items counted.', async () => {
+                        const limitCount = 2;
+                        const unlimited = await query().countDocs();
+                        expect(unlimited).toBe(testDocumentCount);
+                        const result = await query(orderBy('value'), limitToLast(limitCount)).countDocs();
+                        expect(result).toBe(limitCount);
+                    });
+                });
+                describe('orderBy', () => {
+                    it('should return values sorted in ascending order.', async () => {
+                        const results = await query(orderBy('value', 'asc')).getDocs();
+                        expect(results.docs[0].data().value).toBe('0');
+                    });
+                    it('should return values sorted in descending order.', async () => {
+                        const results = await query(orderBy('value', 'desc')).getDocs();
+                        expect(results.docs[0].data().value).toBe(`${items.length - 1}`);
+                    });
+                });
+                describe('where', () => {
+                    describe('==', () => {
+                        it('should return the documents matching the query.', async () => {
+                            const value = '0';
+                            const result = await query(where('value', '==', value)).getDocs();
+                            expect(result.docs.length).toBe(1);
+                            expect(result.docs[0].data().value).toBe(value);
+                        });
+                        it('should return the count of the documents matching the query.', async () => {
+                            const value = '0';
+                            const result = await query(where('value', '==', value)).countDocs();
+                            expect(result).toBe(1);
+                        });
+                    });
+                    describe('in', () => {
+                        it('should return the documents with any of the input values.', async () => {
+                            const targetValue = ['0', '1', '2'];
+                            const result = await query(where('value', 'in', targetValue)).getDocs();
+                            expect(result.docs.length).toBe(3);
+                            const values = result.docs.map((x) => x.data().value);
+                            expect(values).toContain('0');
+                            expect(values).toContain('1');
+                            expect(values).toContain('2');
+                        });
+                        it('should return the count of documents with any of the input values.', async () => {
+                            const targetValue = ['0', '1', '2'];
+                            const result = await query(where('value', 'in', targetValue)).countDocs();
+                            expect(result).toBe(3);
+                        });
+                    });
+                    describe('not-in', () => {
+                        it('should return the documents that do not contain any of the input values.', async () => {
+                            const targetValue = ['0', '1', '2'];
+                            const result = await query(where('value', 'not-in', targetValue)).getDocs();
+                            expect(result.docs.length).toBe(2);
+                            const values = result.docs.map((x) => x.data().value);
+                            expect(values).not.toContain('0');
+                            expect(values).not.toContain('1');
+                            expect(values).not.toContain('2');
+                            expect(values).toContain('3');
+                            expect(values).toContain('4');
+                        });
+                        it('should return the count of documents that do not contain any of the input values.', async () => {
+                            const targetValue = ['0', '1', '2'];
+                            const result = await query(where('value', 'not-in', targetValue)).countDocs();
+                            expect(result).toBe(2);
+                        });
+                    });
+                    describe('searching array values', () => {
+                        describe('in', () => {
+                            it('should return the documents with arrays that only have the given values.', async () => {
+                                // NOTE: we pass an array to match exactly
+                                const targetValue = [['0', 'even']];
+                                const result = await query(where('tags', 'in', targetValue)).getDocs();
+                                expect(result.docs.length).toBe(1);
+                                expect(result.docs[0].data().value).toBe('0');
+                            });
+                            it('should not return the document with arrays that have more than the requested values.', async () => {
+                                const targetValue = [['0']];
+                                const result = await query(where('tags', 'in', targetValue)).getDocs();
+                                expect(result.docs.length).toBe(0);
+                            });
+                            it('should return the count of documents with arrays that only have the given values.', async () => {
+                                // NOTE: we pass an array to match exactly
+                                const targetValue = [['0', 'even']];
+                                const result = await query(where('tags', 'in', targetValue)).countDocs();
+                                expect(result).toBe(1);
+                            });
+                        });
+                        describe('array-contains', () => {
+                            it('should return the documents that contain the given value.', async () => {
+                                const targetValue = '0';
+                                const result = await query(where('tags', 'array-contains', targetValue)).getDocs();
+                                expect(result.docs.length).toBe(1);
+                                expect(result.docs[0].data().value).toBe('0');
+                            });
+                            itShouldFail('if an array is passed to where with array-contains', async () => {
+                                const targetValues = ['0', 'even'];
+                                await expectFail(() => query(where('tags', 'array-contains', targetValues)).getDocs());
+                            });
+                        });
+                        describe('array-contains-any', () => {
+                            it('should return the documents that contain the given value, even if it is not passed as an array.', async () => {
+                                const targetValues = 'even';
+                                const result = await query(where('tags', 'array-contains-any', targetValues)).getDocs();
+                                expect(result.docs.length).toBe(Math.floor(testDocumentCount / 2) + 1);
+                                result.docs.forEach((x) => {
+                                    expect(isEvenNumber(Number(x.data().value)));
+                                });
+                            });
+                            it('should return the documents that contain any of the given values.', async () => {
+                                const targetValues = ['0', 'even'];
+                                const result = await query(where('tags', 'array-contains-any', targetValues)).getDocs();
+                                expect(result.docs.length).toBe(Math.floor(testDocumentCount / 2) + 1);
+                                result.docs.forEach((x) => {
+                                    expect(isEvenNumber(Number(x.data().value)));
+                                });
+                            });
+                        });
+                    });
+                    describe('Compound Queries', () => {
+                        describe('Searching Strings', () => {
+                            /*
+                                Create models that have model key like string values for prefix searching.
+                               */
+                            const evenPrefix = mockItemIdentity.collectionType + '/';
+                            const oddPrefix = mockItemIdentity.collectionType + 'd' + '/'; // similar, but not quite the same
+                            const expectedNumberOfEvenValues = Math.ceil(testDocumentCount / 2);
+                            beforeEach(async () => {
+                                items = await makeDocuments(f.instance.firestoreCollection.documentAccessor(), {
+                                    count: testDocumentCount,
+                                    init: (i) => {
+                                        const isEven = isEvenNumber(i);
+                                        const prefix = isEven ? evenPrefix : oddPrefix;
+                                        return {
+                                            value: `${prefix}${i}`,
+                                            date: new Date(),
+                                            tags: [],
+                                            test: true
+                                        };
+                                    }
+                                });
+                            });
+                            describe('whereStringHasRootIdentityModelKey()', () => {
+                                it('should return only models with searched prefix', async () => {
+                                    const result = await query(whereStringHasRootIdentityModelKey('value', mockItemIdentity)).getDocs();
+                                    const values = result.docs.map((x) => x.data().value);
+                                    values.forEach((x) => {
+                                        expect(x.startsWith(evenPrefix));
+                                    });
+                                    expect(result.docs.length).toBe(expectedNumberOfEvenValues);
+                                });
+                                it('should return the count of only models with searched prefix', async () => {
+                                    const result = await query(whereStringHasRootIdentityModelKey('value', mockItemIdentity)).countDocs();
+                                    expect(result).toBe(expectedNumberOfEvenValues);
+                                });
+                            });
+                            describe('whereStringValueHasPrefix()', () => {
+                                it('should return only models with searched prefix', async () => {
+                                    const result = await query(whereStringValueHasPrefix('value', evenPrefix)).getDocs();
+                                    const values = result.docs.map((x) => x.data().value);
+                                    values.forEach((x) => {
+                                        expect(x.startsWith(evenPrefix));
+                                    });
+                                    expect(result.docs.length).toBe(expectedNumberOfEvenValues);
+                                });
+                            });
+                        });
+                        /**
+                         * Since we choose to store dates as strings, we can compare ranges of dates.
+                         */
+                        describe('Searching Date Strings', () => {
+                            describe('whereDateIsAfterWithSort()', () => {
+                                it('should return models with dates after the input.', async () => {
+                                    const startHoursLater = 2;
+                                    const start = addHours(startDate, startHoursLater);
+                                    const result = await query(whereDateIsAfterWithSort('date', start)).getDocs();
+                                    expect(result.docs.length).toBe(startHoursLater);
+                                    // ascending order by default
+                                    expect(result.docs[0].data().date?.toISOString()).toBe(addHours(start, 1).toISOString());
+                                    expect(result.docs[1].data().date?.toISOString()).toBe(addHours(start, 2).toISOString());
+                                });
+                                it('should return models with dates after the input in descending order.', async () => {
+                                    const startHoursLater = 2;
+                                    const start = addHours(startDate, startHoursLater);
+                                    const result = await query(whereDateIsAfterWithSort('date', start, 'desc')).getDocs();
+                                    expect(result.docs.length).toBe(startHoursLater);
+                                    // check descending order
+                                    expect(result.docs[0].data().date?.toISOString()).toBe(addHours(start, 2).toISOString());
+                                    expect(result.docs[1].data().date?.toISOString()).toBe(addHours(start, 1).toISOString());
+                                });
+                            });
+                            describe('whereDateIsBeforeWithSort()', () => {
+                                it('should return models with dates before the input.', async () => {
+                                    const startHoursLater = 2;
+                                    const endDate = addHours(startDate, startHoursLater);
+                                    const result = await query(whereDateIsBeforeWithSort('date', endDate)).getDocs();
+                                    expect(result.docs.length).toBe(startHoursLater);
+                                    // descending order by default
+                                    expect(result.docs[0].data().date?.toISOString()).toBe(addHours(endDate, -1).toISOString());
+                                    expect(result.docs[1].data().date?.toISOString()).toBe(addHours(endDate, -2).toISOString());
+                                });
+                                it('should return models with dates before the input in ascending order.', async () => {
+                                    const startHoursLater = 2;
+                                    const endDate = addHours(startDate, startHoursLater);
+                                    const result = await query(whereDateIsBeforeWithSort('date', endDate, 'asc')).getDocs();
+                                    expect(result.docs.length).toBe(startHoursLater);
+                                    // check ascending order
+                                    expect(result.docs[0].data().date?.toISOString()).toBe(addHours(endDate, -2).toISOString());
+                                    expect(result.docs[1].data().date?.toISOString()).toBe(addHours(endDate, -1).toISOString());
+                                });
+                            });
+                            describe('whereDateIsOnOrAfterWithSort()', () => {
+                                it('should return models with dates after the input.', async () => {
+                                    const startHoursLater = 2;
+                                    const start = addHours(startDate, startHoursLater);
+                                    const result = await query(whereDateIsOnOrAfterWithSort('date', start)).getDocs();
+                                    expect(result.docs.length).toBe(3);
+                                    // ascending order by default
+                                    expect(result.docs[0].data().date?.toISOString()).toBe(addHours(start, 0).toISOString());
+                                    expect(result.docs[1].data().date?.toISOString()).toBe(addHours(start, 1).toISOString());
+                                    expect(result.docs[2].data().date?.toISOString()).toBe(addHours(start, 2).toISOString());
+                                });
+                                it('should return models with dates after the input in descending order.', async () => {
+                                    const startHoursLater = 2;
+                                    const start = addHours(startDate, startHoursLater);
+                                    const result = await query(whereDateIsOnOrAfterWithSort('date', start, 'desc')).getDocs();
+                                    expect(result.docs.length).toBe(3);
+                                    // check descending order
+                                    expect(result.docs[0].data().date?.toISOString()).toBe(addHours(start, 2).toISOString());
+                                    expect(result.docs[1].data().date?.toISOString()).toBe(addHours(start, 1).toISOString());
+                                    expect(result.docs[2].data().date?.toISOString()).toBe(addHours(start, 0).toISOString());
+                                });
+                            });
+                            describe('whereDateIsOnOrBeforeWithSort()', () => {
+                                it('should return models with dates before the input.', async () => {
+                                    const startHoursLater = 2;
+                                    const endDate = addHours(startDate, startHoursLater);
+                                    const result = await query(whereDateIsOnOrBeforeWithSort('date', endDate)).getDocs();
+                                    expect(result.docs.length).toBe(3);
+                                    // descending order by default
+                                    expect(result.docs[0].data().date?.toISOString()).toBe(addHours(endDate, 0).toISOString());
+                                    expect(result.docs[1].data().date?.toISOString()).toBe(addHours(endDate, -1).toISOString());
+                                    expect(result.docs[2].data().date?.toISOString()).toBe(addHours(endDate, -2).toISOString());
+                                });
+                                it('should return models with dates before the input in ascending order.', async () => {
+                                    const startHoursLater = 2;
+                                    const endDate = addHours(startDate, startHoursLater);
+                                    const result = await query(whereDateIsOnOrBeforeWithSort('date', endDate, 'asc')).getDocs();
+                                    expect(result.docs.length).toBe(3);
+                                    // check ascending order
+                                    expect(result.docs[0].data().date?.toISOString()).toBe(addHours(endDate, -2).toISOString());
+                                    expect(result.docs[1].data().date?.toISOString()).toBe(addHours(endDate, -1).toISOString());
+                                    expect(result.docs[2].data().date?.toISOString()).toBe(addHours(endDate, 0).toISOString());
+                                });
+                            });
+                            describe('whereDateIsInRange()', () => {
+                                it('should return the date values within the given range.', async () => {
+                                    const startHoursLater = 1;
+                                    const totalHoursInRange = 2;
+                                    const start = addHours(startDate, startHoursLater);
+                                    const result = await query(whereDateIsInRange('date', { date: start, distance: totalHoursInRange - 1, type: DateRangeType.HOURS_RANGE })).getDocs();
+                                    expect(result.docs.length).toBe(totalHoursInRange);
+                                    expect(result.docs[0].data().date?.toISOString()).toBe(start.toISOString());
+                                    expect(result.docs[1].data().date?.toISOString()).toBe(addHours(start, 1).toISOString());
+                                });
+                            });
+                            describe('whereDateIsBetween()', () => {
+                                it('should return the date values within the given range.', async () => {
+                                    const startHoursLater = 1;
+                                    const hoursRange = 2;
+                                    const start = addHours(startDate, startHoursLater);
+                                    const end = addHours(start, hoursRange);
+                                    const result = await query(whereDateIsBetween('date', { start, end })).getDocs();
+                                    expect(result.docs.length).toBe(hoursRange);
+                                    expect(result.docs[0].data().date?.toISOString()).toBe(start.toISOString());
+                                    expect(result.docs[1].data().date?.toISOString()).toBe(addHours(start, 1).toISOString());
+                                });
+                                describe('with searching array value', () => {
+                                    it('should search the date range and values that are tagged even.', async () => {
+                                        const targetTag = 'even';
+                                        const startHoursLater = 1;
+                                        const hoursRange = 2;
+                                        const start = addHours(startDate, startHoursLater);
+                                        const end = addHours(start, hoursRange);
+                                        const result = await query([
+                                            // filter by dates first
+                                            ...whereDateIsBetween('date', { start, end }),
+                                            // only allow even items
+                                            where('tags', 'array-contains-any', targetTag)
+                                        ]).getDocs();
+                                        expect(result.docs.length).toBe(1);
+                                        const onlyResultData = result.docs[0].data();
+                                        expect(onlyResultData.date?.toISOString()).toBe(addHours(start, 1).toISOString());
+                                        expect(onlyResultData.tags).toContain(targetTag);
+                                    });
+                                });
+                            });
+                        });
+                    });
+                });
+                describe('whereDocumentId', () => {
+                    it('should return the documents matching the query.', async () => {
+                        const targetId = items[0].id;
+                        const result = await query(whereDocumentId('==', targetId)).getDocs();
+                        expect(result.docs.length).toBe(1);
+                        expect(result.docs[0].id).toBe(targetId);
+                    });
+                });
+                describe('startAt', () => {
+                    it('should return values starting from the specified startAt document.', async () => {
+                        const limitCount = 2;
+                        const firstQuery = query(limit(limitCount));
+                        const first = await firstQuery.getDocs();
+                        expect(first.docs.length).toBe(limitCount);
+                        const second = await firstQuery.filter(startAt(first.docs[1])).getDocs();
+                        expect(second.docs.length).toBe(limitCount);
+                        expect(second.docs[0].id).toBe(first.docs[1].id);
+                    });
+                    it('should return the count of values starting from the specified startAt document.', async () => {
+                        const limitCount = 2;
+                        const firstQuery = query(limit(limitCount));
+                        const first = await firstQuery.getDocs();
+                        expect(first.docs.length).toBe(limitCount);
+                        // NOTE: startAt with count requires an orderBy to be set.
+                        const secondCount = await firstQuery.filter(orderByDocumentId(), startAt(first.docs[1])).countDocs();
+                        expect(secondCount).toBe(limitCount);
+                    });
+                });
+                describe('startAtValue', () => {
+                    it('should return values starting from the specified startAt path.', async () => {
+                        const limitCount = testDocumentCount;
+                        const firstQuery = query(orderBy('value'), limit(limitCount));
+                        const first = await firstQuery.getDocs();
+                        expect(first.docs.length).toBe(limitCount);
+                        const indexToStartAt = 3;
+                        const docToStartAt = first.docs[indexToStartAt];
+                        const docToStartAtValue = docToStartAt.data().value;
+                        const second = await firstQuery.filter(startAtValue(docToStartAtValue)).getDocs();
+                        expect(second.docs.length).toBe(limitCount - indexToStartAt);
+                        expect(second.docs[0].id).toBe(docToStartAt.id);
+                    });
+                });
+                describe('startAfter', () => {
+                    it('should return values starting after the specified startAt point.', async () => {
+                        const limitCount = 3;
+                        const firstQuery = query(limit(limitCount));
+                        const first = await firstQuery.getDocs();
+                        expect(first.docs.length).toBe(limitCount);
+                        const startAfterDoc = first.docs[1];
+                        const expectedFirstDoc = first.docs[2];
+                        const second = await firstQuery.filter(startAfter(startAfterDoc)).getDocs();
+                        expect(second.docs.length).toBe(limitCount);
+                        expect(second.docs[0].id).toBe(expectedFirstDoc.id);
+                    });
+                });
+                describe('endAt', () => {
+                    it('should return values ending with the specified endAt point (inclusive).', async () => {
+                        const limitCount = 2;
+                        const firstQuery = query(limit(limitCount));
+                        const first = await firstQuery.getDocs();
+                        expect(first.docs.length).toBe(limitCount);
+                        const second = await firstQuery.filter(endAt(first.docs[0])).getDocs();
+                        expect(second.docs.length).toBe(limitCount - 1);
+                        expect(second.docs[0].id).toBe(first.docs[0].id);
+                    });
+                });
+                describe('endAtValue', () => {
+                    it('should return values starting from the specified startAt path.', async () => {
+                        const limitCount = testDocumentCount;
+                        const firstQuery = query(orderBy('value'), limit(limitCount));
+                        const first = await firstQuery.getDocs();
+                        expect(first.docs.length).toBe(limitCount);
+                        const indexToEndAt = 2;
+                        const docToEndAt = first.docs[indexToEndAt];
+                        const docToEndAtValue = docToEndAt.data().value;
+                        const second = await firstQuery.filter(endAtValue(docToEndAtValue)).getDocs();
+                        expect(second.docs.length).toBe(indexToEndAt + 1);
+                        expect(second.docs[second.docs.length - 1].id).toBe(docToEndAt.id);
+                    });
+                });
+                describe('endBefore', () => {
+                    it('should return values ending with the specified endBefore point (exclusive).', async () => {
+                        const limitCount = 2;
+                        const firstQuery = query(limit(limitCount));
+                        const first = await firstQuery.getDocs();
+                        expect(first.docs.length).toBe(limitCount);
+                        const second = await firstQuery.filter(endBefore(first.docs[1])).getDocs();
+                        expect(second.docs.length).toBe(limitCount - 1);
+                        expect(second.docs[0].id).toBe(first.docs[0].id);
+                    });
+                });
+            });
+        });
+    });
+}
+
+/**
+ * Describes accessor driver tests, using a MockItemCollectionFixture.
+ *
+ * @param f
+ */
+function describeFirestoreIterationTests(f) {
+    describe('firestoreItemPageIteration', () => {
+        const testDocumentCount = 10;
+        let firestoreIteration;
+        let items;
+        let sub;
+        beforeEach(async () => {
+            firestoreIteration = f.instance.firestoreCollection.firestoreIteration;
+            items = await makeDocuments(f.instance.firestoreCollection.documentAccessor(), {
+                count: testDocumentCount,
+                init: (i) => {
+                    return {
+                        value: `${i}`,
+                        test: true
+                    };
+                }
+            });
+            sub = new SubscriptionObject();
+        });
+        afterEach(() => {
+            sub.destroy();
+        });
+        describe('filter', () => {
+            describe('limit', () => {
+                it('should use the input limit for page size.', callbackTest((done) => {
+                    const limit = 4;
+                    const iteration = firestoreIteration({ limit });
+                    sub.subscription = iteration.latestState$.subscribe((x) => {
+                        const results = x.value;
+                        expect(results.length).toBe(limit);
+                        done();
+                    });
+                }));
+            });
+            describe('constraint', () => {
+                it('should use the constraints', callbackTest((done) => {
+                    const iteration = firestoreIteration({ constraints: mockItemWithValue('0') });
+                    sub.subscription = iteration.latestState$.subscribe((x) => {
+                        const results = x.value;
+                        expect(results.length).toBe(1);
+                        expect(results[0].id).toBe(items[0].documentRef.id);
+                        done();
+                    });
+                }));
+            });
+        });
+        describe('pagination', () => {
+            const limit = 4;
+            let iteration;
+            beforeEach(() => {
+                iteration = firestoreIteration({ limit });
+            });
+            afterEach(() => {
+                iteration.destroy();
+            });
+            describe('latestState$', () => {
+                it('should load the first state when subscribed to for the first time.', callbackTest((done) => {
+                    sub.subscription = iteration.latestState$.subscribe((latestState) => {
+                        const page = latestState.page;
+                        expect(page).toBe(0);
+                        const values = latestState.value;
+                        expect(values.length).toBe(limit);
+                        done();
+                    });
+                }));
+            });
+            describe('currentState$', () => {
+                it('should load the first items when subscribed to for the first time.', callbackTest((done) => {
+                    sub.subscription = iteration.currentState$.pipe(filter((x) => Boolean(x.value))).subscribe((currentState) => {
+                        const page = currentState.page;
+                        expect(page).toBe(0);
+                        const values = currentState.value;
+                        expect(values.length).toBe(limit);
+                        done();
+                    });
+                }));
+            });
+            describe('nextPage()', () => {
+                it('should load the next page and return when the page has finished loading.', callbackTest((done) => {
+                    iteration.nextPage().then(() => {
+                        const nextPageResult = from(iteration.nextPage());
+                        sub.subscription = nextPageResult.pipe(switchMap((x) => iteration.currentState$)).subscribe((latestState) => {
+                            const page = latestState.page;
+                            expect(page).toBe(1);
+                            const values = latestState.value;
+                            expect(values.length).toBe(limit);
+                            done();
+                        });
+                    });
+                }));
+            });
+            describe('with accumulator', () => {
+                let accumulatorSub;
+                beforeEach(() => {
+                    accumulatorSub = new SubscriptionObject();
+                });
+                afterEach(() => {
+                    accumulatorSub.destroy();
+                });
+                describe('firebaseQuerySnapshotAccumulator()', () => {
+                    let accumulator;
+                    beforeEach(() => {
+                        accumulator = firebaseQuerySnapshotAccumulator(iteration);
+                    });
+                    it('should accumulate values from the query.', () => {
+                        // todo
+                    });
+                    describe('flattenAccumulatorResultItemArray()', () => {
+                        it(`should aggregate the array of results into a single array.`, callbackTest((done) => {
+                            const pagesToLoad = 2;
+                            // load up to page 2
+                            iteratorNextPageUntilPage(iteration, pagesToLoad).then((page) => {
+                                expect(page).toBe(pagesToLoad - 1);
+                                const obs = flattenAccumulatorResultItemArray(accumulator);
+                                accumulatorSub.subscription = obs.pipe(first()).subscribe((values) => {
+                                    expect(values.length).toBe(pagesToLoad * limit);
+                                    expect(arrayContainsDuplicateValue(values.map((x) => x.id))).toBe(false);
+                                    // should not be a query snapshot
+                                    expect(values[0].ref).toBeDefined();
+                                    done();
+                                });
+                            });
+                        }));
+                    });
+                    describe('accumulatorCurrentPageListLoadingState()', () => {
+                        it('should return a loading state for the current page.', callbackTest((done) => {
+                            const obs = accumulatorCurrentPageListLoadingState(accumulator);
+                            accumulatorSub.subscription = obs.pipe(filter((x) => !x.loading)).subscribe((state) => {
+                                const value = state.value;
+                                expect(isLoadingStateFinishedLoading(state)).toBe(true);
+                                expect(value).toBeDefined();
+                                expect(Array.isArray(value)).toBe(true);
+                                expect(Array.isArray(value[0])).toBe(true);
+                                done();
+                            });
+                        }));
+                    });
+                });
+                describe('firebaseQueryItemAccumulator()', () => {
+                    let itemAccumulator;
+                    beforeEach(() => {
+                        itemAccumulator = firebaseQueryItemAccumulator(iteration);
+                    });
+                    describe('flattenAccumulatorResultItemArray()', () => {
+                        it(`should aggregate the array of results into a single array.`, callbackTest((done) => {
+                            const pagesToLoad = 2;
+                            // load up to page 2
+                            iteratorNextPageUntilPage(iteration, pagesToLoad).then((page) => {
+                                expect(page).toBe(pagesToLoad - 1);
+                                const obs = flattenAccumulatorResultItemArray(itemAccumulator);
+                                accumulatorSub.subscription = obs.pipe(first()).subscribe((values) => {
+                                    expect(values.length).toBe(pagesToLoad * limit);
+                                    expect(arrayContainsDuplicateValue(values.map((x) => x.id))).toBe(false);
+                                    done();
+                                });
+                            });
+                        }));
+                    });
+                    describe('flattenAccumulatorResultItemArray()', () => {
+                        it(`should aggregate the array of results into a single array of the items.`, callbackTest((done) => {
+                            const pagesToLoad = 2;
+                            // load up to page 2
+                            iteratorNextPageUntilPage(iteration, pagesToLoad).then((page) => {
+                                expect(page).toBe(pagesToLoad - 1);
+                                const obs = flattenAccumulatorResultItemArray(itemAccumulator);
+                                accumulatorSub.subscription = obs.pipe(first()).subscribe((values) => {
+                                    expect(values.length).toBe(pagesToLoad * limit);
+                                    expect(arrayContainsDuplicateValue(values.map((x) => x.id))).toBe(false);
+                                    // should not be a query snapshot
+                                    expect(values[0].ref).not.toBeDefined();
+                                    done();
+                                });
+                            });
+                        }));
+                    });
+                    describe('accumulatorFlattenPageListLoadingState()', () => {
+                        it('should return a loading state for the current page with all items in a single array.', callbackTest((done) => {
+                            const obs = accumulatorFlattenPageListLoadingState(itemAccumulator);
+                            accumulatorSub.subscription = obs.pipe(filter((x) => !x.loading)).subscribe((state) => {
+                                const value = state.value;
+                                expect(isLoadingStateFinishedLoading(state)).toBe(true);
+                                expect(value).toBeDefined();
+                                expect(Array.isArray(value)).toBe(true);
+                                expect(Array.isArray(value[0])).toBe(false);
+                                done();
+                            });
+                        }));
+                    });
+                    describe('accumulatorCurrentPageListLoadingState()', () => {
+                        it('should return a loading state for the current page.', callbackTest((done) => {
+                            const obs = accumulatorCurrentPageListLoadingState(itemAccumulator);
+                            accumulatorSub.subscription = obs.pipe(filter((x) => !x.loading)).subscribe((state) => {
+                                const value = state.value;
+                                expect(isLoadingStateFinishedLoading(state)).toBe(true);
+                                expect(value).toBeDefined();
+                                expect(Array.isArray(value)).toBe(true);
+                                expect(Array.isArray(value[0])).toBe(true);
+                                done();
+                            });
+                        }));
+                    });
+                });
+            });
+        });
+    });
+}
+
+class TestFirebaseStorageInstance {
+    storageContext;
+    constructor(storageContext) {
+        this.storageContext = storageContext;
+    }
+    get storage() {
+        return this.storageContext.storage;
+    }
+}
+class TestFirebaseStorageContextFixture extends AbstractTestContextFixture {
+    get storage() {
+        return this.instance.storage;
+    }
+    get storageContext() {
+        return this.instance.storageContext;
+    }
+}
+
+/**
+ * Describes accessor driver tests, using a MockItemCollectionFixture.
+ *
+ * @param f
+ */
+function describeFirebaseStorageAccessorDriverTests(f) {
+    describe('FirebaseStorageAccessor', () => {
+        describe('file()', () => {
+            const secondBucket = 'second-bucket';
+            const doesNotExistFilePath = 'test.png';
+            let doesNotExistFile;
+            const existsFilePath = 'test/exists.txt';
+            const existsFileContent = 'Hello! \ud83d\ude0a';
+            const existsFileContentType = 'text/plain';
+            let existsFile;
+            let secondBucketTarget;
+            beforeEach(async () => {
+                doesNotExistFile = f.storageContext.file(doesNotExistFilePath);
+                existsFile = f.storageContext.file(existsFilePath);
+                await existsFile.upload(existsFileContent, { stringFormat: 'raw', contentType: existsFileContentType }); // re-upload for each test
+                // delete the does not exist file and second bucket target if it exists
+                await doesNotExistFile.delete().catch(() => null);
+                secondBucketTarget = f.storageContext.file({ bucketId: secondBucket, pathString: doesNotExistFilePath });
+                await secondBucketTarget.delete().catch(() => null);
+            });
+            describe('uploading', () => {
+                let uploadFile;
+                beforeEach(() => {
+                    uploadFile = f.storageContext.file('upload.txt');
+                });
+                describe('upload()', () => {
+                    describe('string types', () => {
+                        itShouldFail('if stringFormat is not defined in the options', async () => {
+                            const contentType = 'text/plain';
+                            const data = existsFileContent;
+                            await expectFail(() => uploadFile.upload(data, { contentType }));
+                        });
+                        it('should upload a raw UTF-16 string.', async () => {
+                            const contentType = 'text/plain';
+                            const data = existsFileContent;
+                            await uploadFile.upload(data, { stringFormat: 'raw', contentType });
+                            const metadata = await uploadFile.getMetadata();
+                            expect(metadata.contentType).toBe(contentType);
+                            const result = await uploadFile.getBytes();
+                            expect(result).toBeDefined();
+                            const decoded = Buffer.from(result).toString('utf-8');
+                            expect(decoded).toBe(data);
+                        });
+                        it('should upload a base64 string.', async () => {
+                            const bytes = await existsFile.getBytes();
+                            const data = Buffer.from(bytes).toString('base64');
+                            const contentType = 'text/plain';
+                            await uploadFile.upload(data, { stringFormat: 'base64', contentType });
+                            const metadata = await uploadFile.getMetadata();
+                            expect(metadata.contentType).toBe(contentType);
+                            const result = await uploadFile.getBytes();
+                            expect(result).toBeDefined();
+                            const decoded = Buffer.from(result).toString('utf-8');
+                            expect(decoded).toBe(existsFileContent);
+                        });
+                        it('should upload a base64url string.', async () => {
+                            const bytes = await existsFile.getBytes();
+                            const data = Buffer.from(bytes).toString('base64url');
+                            const contentType = 'text/plain';
+                            await uploadFile.upload(data, { stringFormat: 'base64url', contentType });
+                            const metadata = await uploadFile.getMetadata();
+                            expect(metadata.contentType).toBe(contentType);
+                            const result = await uploadFile.getBytes();
+                            expect(result).toBeDefined();
+                            const decoded = Buffer.from(result).toString('utf-8');
+                            expect(decoded).toBe(existsFileContent);
+                        });
+                    });
+                    describe('data types', () => {
+                        // NOTE: We can really only test how a NodeJS environment will behave here.
+                        it('should upload a Uint8Array', async () => {
+                            const dataBuffer = Buffer.from(existsFileContent, 'utf-8');
+                            const data = new Uint8Array(dataBuffer);
+                            const contentType = 'text/plain';
+                            await uploadFile.upload(data, { contentType });
+                            const metadata = await uploadFile.getMetadata();
+                            expect(metadata.contentType).toBe(contentType);
+                        });
+                        it('should upload a Buffer', async () => {
+                            const buffer = Buffer.from(existsFileContent, 'utf-8');
+                            const contentType = 'text/plain';
+                            await uploadFile.upload(buffer, { contentType });
+                            const metadata = await uploadFile.getMetadata();
+                            expect(metadata.contentType).toBe(contentType);
+                        });
+                        it('should upload a Blob', async () => {
+                            const buffer = Buffer.from(existsFileContent, 'utf-8');
+                            const data = new Uint8Array(buffer);
+                            const blob = data.buffer; // blob-like
+                            const contentType = 'text/plain';
+                            await uploadFile.upload(blob, { contentType });
+                            const metadata = await uploadFile.getMetadata();
+                            expect(metadata.contentType).toBe(contentType);
+                        });
+                        // NOTE: File extends Blob, so above test should cover it ok.
+                    });
+                    // TODO(TEST): Test uploading other types.
+                    describe('custom metadata', () => {
+                        it('should upload custom metadata via customMetadata', async () => {
+                            const customMetadataKey = 'x-amz-meta-custom-key';
+                            const customMetadataValue = 'custom-value';
+                            const customMetadata = {
+                                [customMetadataKey]: customMetadataValue
+                            };
+                            const contentType = 'text/plain';
+                            const data = existsFileContent;
+                            await uploadFile.upload(data, { stringFormat: 'raw', contentType, customMetadata });
+                            const metadata = await uploadFile.getMetadata();
+                            expect(metadata.customMetadata).toEqual(customMetadata);
+                        });
+                        it('should upload custom metadata via metadata', async () => {
+                            const customMetadataKey = 'x-amz-meta-custom-key';
+                            const customMetadataValue = 'custom-value';
+                            const customMetadata = {
+                                [customMetadataKey]: customMetadataValue
+                            };
+                            const contentType = 'text/plain';
+                            const data = existsFileContent;
+                            await uploadFile.upload(data, { stringFormat: 'raw', contentType, metadata: { customMetadata } });
+                            const metadata = await uploadFile.getMetadata();
+                            expect(metadata.customMetadata).toEqual(customMetadata);
+                        });
+                        it('should upload the merged custom metadatas', async () => {
+                            const customMetadataAKey = 'x-amz-meta-custom-key';
+                            const customMetadataAValue = '1';
+                            const customMetadataBKey = 'x-axx-meta-custom-key';
+                            const customMetadataBValue = 'true';
+                            const customMetadataA = {
+                                [customMetadataAKey]: customMetadataAValue
+                            };
+                            const customMetadataB = {
+                                [customMetadataBKey]: customMetadataBValue
+                            };
+                            const contentType = 'text/plain';
+                            const data = existsFileContent;
+                            await uploadFile.upload(data, { stringFormat: 'raw', contentType, customMetadata: customMetadataA, metadata: { customMetadata: customMetadataB } });
+                            const metadata = await uploadFile.getMetadata();
+                            expect(metadata.customMetadata).toEqual({ ...customMetadataA, ...customMetadataB });
+                        });
+                    });
+                });
+                describe('uploadStream()', () => {
+                    it('should upload a string using a WritableStream', async () => {
+                        if (uploadFile.uploadStream != null) {
+                            const contentType = 'text/plain';
+                            const data = existsFileContent;
+                            const stream = uploadFile.uploadStream();
+                            await useCallback((cb) => stream.write(data, 'utf-8', cb));
+                            await useCallback((cb) => stream.end(cb));
+                            const exists = await uploadFile.exists();
+                            expect(exists).toBe(true);
+                            const metadata = await uploadFile.getMetadata();
+                            expect(metadata.contentType).toBe(contentType);
+                            const result = await uploadFile.getBytes();
+                            expect(result).toBeDefined();
+                            const decoded = Buffer.from(result).toString('utf-8');
+                            expect(decoded).toBe(data);
+                        }
+                    });
+                    it('should upload a string using a stream using a WritableStream', async () => {
+                        if (uploadFile.uploadStream != null) {
+                            const myText = 'This is a test string.';
+                            // Create a readable stream from the string
+                            const readableStream = Readable.from(myText, { encoding: 'utf-8' });
+                            await uploadFileWithStream(uploadFile, readableStream);
+                            const exists = await uploadFile.exists();
+                            expect(exists).toBe(true);
+                            const metadata = await uploadFile.getMetadata();
+                            expect(metadata.contentType).toBe('text/plain');
+                            const result = await uploadFile.getBytes();
+                            expect(result).toBeDefined();
+                            const decoded = Buffer.from(result).toString('utf-8');
+                            expect(decoded).toBe(myText);
+                        }
+                    });
+                    it('should upload a png using a stream using a WritableStream', async () => {
+                        if (uploadFile.uploadStream != null) {
+                            const testFilePath = `${__dirname}/assets/testpng.png`;
+                            const contentType = 'image/png';
+                            const testFileStream = createReadStream(testFilePath, {});
+                            await uploadFileWithStream(uploadFile, testFileStream, { contentType });
+                            const exists = await uploadFile.exists();
+                            expect(exists).toBe(true);
+                            const metadata = await uploadFile.getMetadata();
+                            expect(metadata.contentType).toBe(contentType);
+                            const result = await uploadFile.getBytes();
+                            expect(result).toBeDefined();
+                        }
+                    });
+                });
+            });
+            describe('copy()', () => {
+                it('should copy the file to a new location in the same bucket.', async () => {
+                    if (existsFile.copy != null) {
+                        const exists = await doesNotExistFile.exists();
+                        expect(exists).toBe(false);
+                        const targetPath = doesNotExistFile.storagePath;
+                        const result = await existsFile.copy(targetPath);
+                        expect(result.storagePath.pathString).toBe(targetPath.pathString);
+                        const doesNotExistFileExists = await doesNotExistFile.exists();
+                        expect(doesNotExistFileExists).toBe(true);
+                        const existsStillExists = await existsFile.exists();
+                        expect(existsStillExists).toBe(true); // original still exists
+                    }
+                });
+                it('should copy the file to a new location to a different bucket.', async () => {
+                    if (existsFile.copy != null) {
+                        const secondBucket = {
+                            bucketId: 'second-bucket',
+                            pathString: secondBucketTarget.storagePath.pathString
+                        };
+                        const targetFile = f.storageContext.file(secondBucket);
+                        const exists = await targetFile.exists();
+                        expect(exists).toBe(false);
+                        const targetPath = targetFile.storagePath;
+                        const result = await existsFile.copy(targetPath);
+                        expect(result.storagePath.pathString).toBe(targetPath.pathString);
+                        const targetFileExists = await targetFile.exists();
+                        expect(targetFileExists).toBe(true);
+                        const doesNotExistExists = await doesNotExistFile.exists();
+                        expect(doesNotExistExists).toBe(false); // on a different bucket
+                        const existsStillExists = await existsFile.exists();
+                        expect(existsStillExists).toBe(true); // original still exists
+                    }
+                });
+            });
+            describe('move()', () => {
+                it('should move the file to a new location in the same bucket.', async () => {
+                    if (existsFile.move != null) {
+                        const exists = await doesNotExistFile.exists();
+                        expect(exists).toBe(false);
+                        const targetPath = doesNotExistFile.storagePath;
+                        const result = await existsFile.move(targetPath);
+                        expect(result.storagePath.pathString).toBe(targetPath.pathString);
+                        const doesNotExistExists = await doesNotExistFile.exists();
+                        expect(doesNotExistExists).toBe(true);
+                        const existsStillExists = await existsFile.exists();
+                        expect(existsStillExists).toBe(false); // check was moved
+                    }
+                });
+                it('should move the file to a new location to a different bucket.', async () => {
+                    if (existsFile.move != null) {
+                        const secondBucket = {
+                            bucketId: 'second-bucket',
+                            pathString: doesNotExistFile.storagePath.pathString
+                        };
+                        const targetFile = f.storageContext.file(secondBucket);
+                        const exists = await targetFile.exists();
+                        expect(exists).toBe(false);
+                        const targetPath = targetFile.storagePath;
+                        const result = await existsFile.move(targetPath);
+                        expect(result.storagePath.pathString).toBe(targetPath.pathString);
+                        const targetFileExists = await targetFile.exists();
+                        expect(targetFileExists).toBe(true);
+                        const doesNotExistStillDoesNotExists = await doesNotExistFile.exists();
+                        expect(doesNotExistStillDoesNotExists).toBe(false);
+                        const existsStillExists = await existsFile.exists();
+                        expect(existsStillExists).toBe(false); // check was moved
+                    }
+                });
+            });
+            describe('exists()', () => {
+                it('should return true if the file exists.', async () => {
+                    const result = await existsFile.exists();
+                    expect(result).toBe(true);
+                });
+                it('should return false if the file exists.', async () => {
+                    const result = await doesNotExistFile.exists();
+                    expect(result).toBe(false);
+                });
+            });
+            describe('getMetadata()', () => {
+                itShouldFail('if the file does not exist.', async () => {
+                    await expectFail(() => doesNotExistFile.getMetadata());
+                });
+                it('should return the metadata.', async () => {
+                    const result = await existsFile.getMetadata();
+                    expect(result.bucket).toBe(existsFile.storagePath.bucketId);
+                    expect(result.fullPath).toBe(existsFilePath);
+                    expect(typeof result.size).toBe('number');
+                    expect(result.size).toBeGreaterThan(0);
+                    expect(result.contentType).toBe(existsFileContentType);
+                    expect(result).toBeDefined();
+                });
+            });
+            describe('setMetadata()', () => {
+                itShouldFail('if the file does not exist.', async () => {
+                    await expectFail(() => doesNotExistFile.setMetadata({}));
+                });
+                it('should replace the content type field.', async () => {
+                    const currentMetadata = await existsFile.getMetadata();
+                    expect(currentMetadata.contentType).toBe(existsFileContentType);
+                    const nextContentType = 'application/json';
+                    const result = await existsFile.setMetadata({
+                        contentType: nextContentType
+                    });
+                    expect(result.contentType).toBe(nextContentType);
+                    const updatedMetadata = await existsFile.getMetadata();
+                    expect(updatedMetadata.contentType).toBe(nextContentType);
+                });
+                it('should replace the metadata for only the provided fields.', async () => {
+                    const currentMetadata = await existsFile.getMetadata();
+                    expect(currentMetadata.contentType).toBe(existsFileContentType);
+                    const customMetadataA = {
+                        foo: 'bar'
+                    };
+                    const result = await existsFile.setMetadata({
+                        contentType: undefined, // should not change
+                        customMetadata: customMetadataA
+                    });
+                    expect(result.contentType).toBe(existsFileContentType);
+                    expect(result.customMetadata).toEqual(customMetadataA);
+                    const updatedMetadata = await existsFile.getMetadata();
+                    expect(updatedMetadata.contentType).toBe(existsFileContentType);
+                    expect(updatedMetadata.customMetadata).toEqual(customMetadataA);
+                    // update again. All custom metadata is replaced
+                    const customMetadataB = {
+                        foo: 'baz'
+                    };
+                    const result2 = await existsFile.setMetadata({
+                        customMetadata: customMetadataB
+                    });
+                    expect(result2.contentType).toBe(existsFileContentType);
+                    expect(result2.customMetadata).toEqual(customMetadataB);
+                    const updatedMetadata2 = await existsFile.getMetadata();
+                    expect(updatedMetadata2.contentType).toBe(existsFileContentType);
+                    expect(updatedMetadata2.customMetadata).toEqual(customMetadataB);
+                });
+            });
+            describe('getBytes()', () => {
+                itShouldFail('if the file does not exist.', async () => {
+                    await expectFail(() => doesNotExistFile.getBytes());
+                });
+                it('should download the file.', async () => {
+                    const result = await existsFile.getBytes();
+                    expect(result).toBeDefined();
+                    const decoded = Buffer.from(result).toString('utf-8');
+                    expect(decoded).toBe(existsFileContent);
+                });
+                describe('with maxDownloadSizeBytes configuration', () => {
+                    it('should download up to the maxDownloadSizeBytes number of bytes', async () => {
+                        const charactersToTake = 5;
+                        const result = await existsFile.getBytes(charactersToTake); // each normal utf-8 character is 1 byte
+                        expect(result).toBeDefined();
+                        const decoded = Buffer.from(result).toString('utf-8');
+                        expect(decoded).toBe(existsFileContent.substring(0, charactersToTake));
+                    });
+                });
+            });
+            describe('getStream()', () => {
+                it('should download the file.', async () => {
+                    if (existsFile.getStream != null) {
+                        // only test if the driver/file has getStream available
+                        const stream = existsFile.getStream();
+                        expect(stream).toBeDefined();
+                        const buffer = await readableStreamToBuffer(stream);
+                        const decoded = buffer.toString('utf-8');
+                        expect(decoded).toBe(existsFileContent);
+                    }
+                });
+            });
+            describe('getDownloadUrl()', () => {
+                itShouldFail('if the file does not exist.', async () => {
+                    const doesNotExistFileExists = await doesNotExistFile.exists();
+                    expect(doesNotExistFileExists).toBe(false);
+                    await expectFail(() => doesNotExistFile.getDownloadUrl());
+                });
+                it('should return the download url.', async () => {
+                    const result = await existsFile.getDownloadUrl();
+                    expect(result).toBeDefined();
+                    expect(typeof result).toBe('string');
+                });
+            });
+            // Cannot be tested, will throw "Could not load the default credentials. Browse to https://cloud.google.com/docs/authentication/getting-started for more information."
+            describe('getSignedUrl()', () => {
+                it('should return the signed read url.', async () => {
+                    if (existsFile.getSignedUrl) {
+                        const result = await existsFile.getSignedUrl({});
+                        expect(result).toBeDefined();
+                        expect(typeof result).toBe('string');
+                    }
+                });
+            });
+            describe('makePublic()', () => {
+                beforeEach(async () => {
+                    await existsFile.delete();
+                    await existsFile.upload(existsFileContent, { stringFormat: 'raw', contentType: existsFileContentType }); // re-upload for each test
+                });
+                it('should make the file public.', async () => {
+                    if (existsFile.makePublic && existsFile.isPublic && existsFile.getAcls) {
+                        // TODO: firestore emulator files seem to always be public and ACLs do not change?
+                        // let isPublic = await existsFile.isPublic();
+                        // expect(isPublic).toBe(false);
+                        // TODO: Not implemented in the emulator properly either
+                        // const acls = await existsFile.getAcls();
+                        // console.log({ acls });
+                        await existsFile.makePublic(true);
+                        // TODO: doesn't really test it properly since true is always returned by the emulator...
+                        const isPublic = await existsFile.isPublic();
+                        expect(isPublic).toBe(true);
+                        // TODO: Not implemented in the emulator
+                        // await existsFile.makePublic(false);
+                        // isPublic = await existsFile.isPublic();
+                        // expect(isPublic).toBe(false);
+                    }
+                });
+            });
+            // TODO: getAcls() and related functions cannot be tested in the emulator currently
+            describe('delete()', () => {
+                itShouldFail('if the file does not exist.', async () => {
+                    await expectFail(() => doesNotExistFile.delete());
+                });
+                it('should delete the file at the path.', async () => {
+                    await existsFile.delete();
+                    const result = await existsFile.exists();
+                    expect(result).toBe(false);
+                });
+                describe('ignoreNotFound=true', () => {
+                    it('should not throw an error if the file does not exist.', async () => {
+                        await doesNotExistFile.delete({ ignoreNotFound: true });
+                    });
+                });
+            });
+        });
+        describe('folder()', () => {
+            const doesNotExistFolderPath = '/doesnotexist/';
+            let doesNotExistFolder;
+            const existsFolderPath = '/test/two/';
+            let existsFolder;
+            const existsFileName = 'exists.txt';
+            const existsFilePath = existsFolderPath + existsFileName;
+            const existsFileContent = 'Hello! \ud83d\ude0a';
+            let existsFile;
+            beforeEach(async () => {
+                doesNotExistFolder = f.storageContext.folder(doesNotExistFolderPath);
+                existsFolder = f.storageContext.folder(existsFolderPath);
+                existsFile = f.storageContext.file(existsFilePath);
+                await existsFile.upload(existsFileContent, { stringFormat: 'raw', contentType: 'text/plain' });
+            });
+            describe('exists()', () => {
+                it('should return false if there are no items in the folder.', async () => {
+                    const exists = await doesNotExistFolder.exists();
+                    expect(exists).toBe(false);
+                });
+                it('should return true if there are items in the folder.', async () => {
+                    const exists = await existsFolder.exists();
+                    expect(exists).toBe(true);
+                });
+            });
+            describe('list()', () => {
+                const existsBFileName = 'a.txt';
+                const existsBFilePath = existsFolderPath + existsBFileName;
+                const existsCFolderPath = existsFolderPath + 'c/';
+                const existsCFilePath = existsCFolderPath + 'c.txt';
+                const otherFolderPath = '/other/';
+                const otherFolderFilePath = otherFolderPath + 'other.txt';
+                beforeEach(async () => {
+                    await f.storageContext.file(existsBFilePath).upload(existsFileContent, { stringFormat: 'raw', contentType: 'text/plain' });
+                    await f.storageContext.file(existsCFilePath).upload(existsFileContent, { stringFormat: 'raw', contentType: 'text/plain' });
+                    await f.storageContext.file(otherFolderFilePath).upload(existsFileContent, { stringFormat: 'raw', contentType: 'text/plain' });
+                });
+                describe('options', () => {
+                    describe('listAll', () => {
+                        describe('=false/unset', () => {
+                            it('should list all the direct files and folders that exist on the test path.', async () => {
+                                const result = await existsFolder.list();
+                                expect(result).toBeDefined();
+                                const files = result.files();
+                                expect(files.length).toBe(2);
+                                const fileNames = new Set(files.map((x) => x.name));
+                                expect(fileNames).toContain(existsFileName);
+                                expect(fileNames).toContain(existsBFileName);
+                                const folders = result.folders();
+                                expect(folders.length).toBe(1);
+                                const folderNames = new Set(folders.map((x) => x.name));
+                                expect(folderNames).toContain('c');
+                            });
+                            it('should list all the direct folders that exist at the root.', async () => {
+                                const rootFolder = await f.storageContext.folder('/');
+                                const result = await rootFolder.list();
+                                expect(result).toBeDefined();
+                                const files = result.files();
+                                expect(files.length).toBe(0); // files are under /test/ and /other/
+                                const folders = result.folders();
+                                expect(folders.length).toBe(2);
+                                const names = new Set(folders.map((x) => x.name));
+                                expect(names).toContain('test');
+                                expect(names).toContain('other');
+                            });
+                        });
+                        describe('=true', () => {
+                            it('should list all files and folders that exist on the test path.', async () => {
+                                const result = await existsFolder.list({ includeNestedResults: true });
+                                expect(result).toBeDefined();
+                                const files = result.files();
+                                expect(files.length).toBe(3);
+                                const filePaths = new Set(files.map((x) => `${SLASH_PATH_SEPARATOR}${x.storagePath.pathString}`));
+                                expect(filePaths).toContain(existsFilePath);
+                                expect(filePaths).toContain(existsBFilePath);
+                                expect(filePaths).toContain(existsCFilePath);
+                                expect(filePaths).not.toContain(otherFolderFilePath);
+                                // folders are not counted/returned
+                                const folders = result.folders();
+                                expect(folders.length).toBe(0);
+                            });
+                            it('should list all the folders that exist at the root.', async () => {
+                                const rootFolder = await f.storageContext.folder('/');
+                                const result = await rootFolder.list({ includeNestedResults: true });
+                                expect(result).toBeDefined();
+                                const files = result.files();
+                                expect(files.length).toBe(4); // all created files
+                                const folders = result.folders();
+                                expect(folders.length).toBe(0);
+                            });
+                            describe('maxResults', () => {
+                                it('should limit the number of results returned.', async () => {
+                                    const rootFolder = await f.storageContext.folder('/');
+                                    const limit = 2;
+                                    const result = await rootFolder.list({ includeNestedResults: true, maxResults: limit });
+                                    expect(result).toBeDefined();
+                                    if (f.storageContext.drivers.storageAccessorDriver.type === 'server') {
+                                        // Currently only the server can properly limit the number of results returned.
+                                        // The client-side will limit the results somewhat, but if folders are returned then it will return the results of those folders as well.
+                                        const files = result.files();
+                                        expect(files.length).toBe(limit);
+                                        const nextPage = await result.next();
+                                        const nextPageFiles = nextPage.files();
+                                        expect(nextPageFiles.length).toBe(limit);
+                                    }
+                                    const folders = result.folders();
+                                    expect(folders.length).toBe(0);
+                                });
+                            });
+                        });
+                    });
+                });
+                describe('file()', () => {
+                    it('should return the file for the result.', async () => {
+                        const result = await existsFolder.list();
+                        expect(result).toBeDefined();
+                        const files = result.files();
+                        const fileResult = files.find((x) => x.name === existsFileName);
+                        const file = fileResult.file();
+                        const exists = await file.exists();
+                        expect(exists).toBe(true);
+                    });
+                });
+                describe('folder()', () => {
+                    it('should return the folder for the result.', async () => {
+                        const rootFolder = await f.storageContext.folder('/');
+                        const result = await rootFolder.list();
+                        expect(result).toBeDefined();
+                        const folders = result.folders();
+                        const folderResult = folders.find((x) => x.name === 'test');
+                        const folder = folderResult.folder();
+                        const exists = await folder.exists();
+                        expect(exists).toBe(true);
+                    });
+                });
+                describe('next()', () => {
+                    it('should return the next set of results.', async () => {
+                        const maxResults = 1;
+                        const rootFolder = await f.storageContext.folder(existsFolderPath);
+                        const result = await rootFolder.list({ maxResults });
+                        expect(result).toBeDefined();
+                        const files = result.files();
+                        expect(files.length).toBe(maxResults);
+                        const next = await result.next();
+                        expect(next).toBeDefined();
+                        const nextFiles = next.files();
+                        expect(nextFiles.length).toBe(maxResults);
+                        expect(nextFiles[0].storagePath.pathString).not.toBe(files[0].storagePath.pathString);
+                        expect(next.hasNext).toBe(false);
+                    });
+                    itShouldFail('if next() is called and hasNext was false.', async () => {
+                        const rootFolder = await f.storageContext.folder(existsFolderPath);
+                        const result = await rootFolder.list({});
+                        expect(result.hasNext).toBe(false);
+                        await expectFail(() => result.next());
+                    });
+                });
+                describe('maxResults', () => {
+                    it('should respect the max results.', async () => {
+                        const maxResults = 1;
+                        const rootFolder = await f.storageContext.folder(existsFolderPath);
+                        const result = await rootFolder.list({ maxResults });
+                        expect(result).toBeDefined();
+                        const files = result.files();
+                        expect(files.length).toBe(maxResults);
+                        const folders = result.folders();
+                        expect(folders.length).toBe(1);
+                        const names = new Set(folders.map((x) => x.name));
+                        expect(names).toContain('c');
+                    });
+                    it('prefixes/folders are unaffected by maxResults.', async () => {
+                        const maxResults = 1;
+                        const rootFolder = await f.storageContext.folder('/');
+                        const result = await rootFolder.list({ maxResults });
+                        expect(result).toBeDefined();
+                        const files = result.files();
+                        expect(files.length).toBe(0); // files are under /test/ and /other/
+                        const folders = result.folders();
+                        expect(folders.length).toBe(2);
+                        const names = new Set(folders.map((x) => x.name));
+                        expect(names).toContain('test');
+                        expect(names).toContain('other');
+                    });
+                });
+                describe('utilities', () => {
+                    describe('iterateStorageListFilesByEachFile()', () => {
+                        it('should iterate through all the files in the current folder one at a time', async () => {
+                            const visitedFiles = [];
+                            const result = await iterateStorageListFilesByEachFile({
+                                folder: existsFolder,
+                                readItemsFromPageResult: (x) => x.result.files(),
+                                iterateEachPageItem: async (file) => {
+                                    visitedFiles.push(file);
+                                }
+                            });
+                            const visitedFilePathStrings = visitedFiles.map((x) => `${SLASH_PATH_SEPARATOR}${x.storagePath.pathString}`);
+                            expect(visitedFilePathStrings).toContain(existsFilePath);
+                            expect(visitedFilePathStrings).toContain(existsBFilePath);
+                            expect(visitedFilePathStrings).not.toContain(existsCFilePath);
+                            expect(visitedFilePathStrings).not.toContain(otherFolderFilePath);
+                            expect(result).toBeDefined();
+                            expect(result.totalItemsLoaded).toBe(2);
+                            expect(result.totalItemsVisited).toBe(visitedFiles.length);
+                        });
+                        describe('includeNestedResults=true', () => {
+                            it('should iterate through all the files and nested files under the current folder one at a time', async () => {
+                                const visitedFiles = [];
+                                const result = await iterateStorageListFilesByEachFile({
+                                    folder: existsFolder,
+                                    includeNestedResults: true,
+                                    readItemsFromPageResult: (x) => x.result.files(),
+                                    iterateEachPageItem: async (file) => {
+                                        visitedFiles.push(file);
+                                    }
+                                });
+                                const visitedFilePathStrings = visitedFiles.map((x) => `${SLASH_PATH_SEPARATOR}${x.storagePath.pathString}`);
+                                expect(result).toBeDefined();
+                                expect(result.totalItemsLoaded).toBe(3);
+                                expect(result.totalItemsVisited).toBe(visitedFiles.length);
+                                expect(visitedFilePathStrings).toContain(existsFilePath);
+                                expect(visitedFilePathStrings).toContain(existsBFilePath);
+                                expect(visitedFilePathStrings).toContain(existsCFilePath);
+                                expect(visitedFilePathStrings).not.toContain(otherFolderFilePath);
+                            });
+                        });
+                    });
+                });
+            });
+        });
+    });
+}
+
+export { MOCK_FIREBASE_MODEL_SERVICE_FACTORIES, MOCK_SYSTEM_STATE_TYPE, MockItemCollectionFixture, MockItemCollectionFixtureInstance, MockItemCollections, MockItemDocument, MockItemPrivateDocument, MockItemSettingsItemEnum, MockItemStorageFixture, MockItemStorageFixtureInstance, MockItemSubItemDeepDocument, MockItemSubItemDocument, MockItemUserDocument, RulesUnitTestFirebaseTestingContextFixture, RulesUnitTestTestFirebaseInstance, TESTING_AUTHORIZED_FIREBASE_USER_ID, TestFirebaseContextFixture, TestFirebaseInstance, TestFirebaseStorageContextFixture, TestFirebaseStorageInstance, TestFirestoreContextFixture, TestFirestoreInstance, allChildMockItemSubItemDeepsWithinMockItem, authorizedFirebaseFactory, authorizedTestWithMockItemCollection, authorizedTestWithMockItemStorage, changeFirestoreLogLevelBeforeAndAfterTests, clearTestFirestoreContextCollections, describeFirebaseStorageAccessorDriverTests, describeFirestoreAccessorDriverTests, describeFirestoreDocumentAccessorTests, describeFirestoreIterationTests, describeFirestoreQueryDriverTests, firebaseRulesUnitTestBuilder, makeMockItemCollections, makeRulesTestFirebaseStorageContext, makeRulesTestFirestoreContext, makeTestingFirebaseStorageAccesorDriver, makeTestingFirebaseStorageDrivers, makeTestingFirestoreAccesorDriver, makeTestingFirestoreDrivers, mockFirebaseModelServices, mockItemCollectionReference, mockItemConverter, mockItemFirebaseModelServiceFactory, mockItemFirestoreCollection, mockItemIdentity, mockItemPrivateCollectionReference, mockItemPrivateCollectionReferenceFactory, mockItemPrivateConverter, mockItemPrivateFirebaseModelServiceFactory, mockItemPrivateFirestoreCollection, mockItemPrivateFirestoreCollectionGroup, mockItemPrivateIdentity, mockItemSettingsItemDencoder, mockItemSubItemCollectionReference, mockItemSubItemCollectionReferenceFactory, mockItemSubItemConverter, mockItemSubItemDeepCollectionReference, mockItemSubItemDeepCollectionReferenceFactory, mockItemSubItemDeepConverter, mockItemSubItemDeepFirebaseModelServiceFactory, mockItemSubItemDeepFirestoreCollection, mockItemSubItemDeepFirestoreCollectionGroup, mockItemSubItemDeepIdentity, mockItemSubItemFirebaseModelServiceFactory, mockItemSubItemFirestoreCollection, mockItemSubItemFirestoreCollectionGroup, mockItemSubItemIdentity, mockItemSystemDataConverter, mockItemSystemStateFirebaseModelServiceFactory, mockItemSystemStateStoredDataConverterMap, mockItemUserAccessorFactory, mockItemUserCollectionName, mockItemUserCollectionReference, mockItemUserCollectionReferenceFactory, mockItemUserConverter, mockItemUserFirebaseModelServiceFactory, mockItemUserFirestoreCollection, mockItemUserFirestoreCollectionGroup, mockItemUserIdentifier, mockItemUserIdentity, mockItemWithTestValue, mockItemWithValue, testWithMockItemCollectionFixture, testWithMockItemStorageFixture };