@dereekb/firebase 12.6.21 → 13.0.0

package/test/index.cjs.js

@@ -0,0 +1,4043 @@
+'use strict';
+
+require('core-js/modules/es.iterator.constructor.js');
+require('core-js/modules/es.iterator.for-each.js');
+require('core-js/modules/es.iterator.map.js');
+require('core-js/modules/es.map.get-or-insert.js');
+require('core-js/modules/es.map.get-or-insert-computed.js');
+var util = require('@dereekb/util');
+var test = require('@dereekb/util/test');
+var rulesUnitTesting = require('@firebase/rules-unit-testing');
+var firebase = require('@dereekb/firebase');
+var firestore = require('firebase/firestore');
+require('core-js/modules/es.set.difference.v2.js');
+require('core-js/modules/es.set.symmetric-difference.v2.js');
+require('core-js/modules/es.set.union.v2.js');
+var rxjs$1 = require('rxjs');
+var rxjs = require('@dereekb/rxjs');
+require('core-js/modules/es.iterator.filter.js');
+var dateFns = require('date-fns');
+var date = require('@dereekb/date');
+require('core-js/modules/es.iterator.find.js');
+require('core-js/modules/es.typed-array.with.js');
+require('core-js/modules/es.uint8-array.set-from-base64.js');
+require('core-js/modules/es.uint8-array.set-from-hex.js');
+require('core-js/modules/es.uint8-array.to-base64.js');
+require('core-js/modules/es.uint8-array.to-hex.js');
+var stream = require('stream');
+var fs = require('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 util.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 ? util.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 {
+  constructor(firestoreContext, storageContext) {
+    this.firestoreContext = void 0;
+    this.storageContext = void 0;
+    this.firestoreContext = firestoreContext;
+    this.storageContext = storageContext;
+  }
+  get firestore() {
+    return this.firestoreContext.firestore;
+  }
+  get storage() {
+    return this.storageContext.storage;
+  }
+}
+class TestFirebaseContextFixture extends test.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 = {
+    ...firebase.firestoreContextFactory(drivers)(rulesTestContext.firestore()),
+    drivers,
+    rulesTestContext,
+    rulesTestEnvironment
+  };
+  return context;
+}
+function makeRulesTestFirebaseStorageContext(drivers, rulesTestEnvironment, rulesTestContext) {
+  const context = {
+    ...firebase.firebaseStorageContextFactory(drivers)(rulesTestContext.storage()),
+    drivers,
+    rulesTestContext,
+    rulesTestEnvironment
+  };
+  return context;
+}
+class RulesUnitTestTestFirebaseInstance {
+  constructor(drivers, rulesTestEnvironment, rulesTestContext) {
+    this.drivers = void 0;
+    this.rulesTestEnvironment = void 0;
+    this.rulesTestContext = void 0;
+    this._firestoreContext = util.cachedGetter(() => makeRulesTestFirestoreContext(this.drivers, this.rulesTestEnvironment, this.rulesTestContext));
+    this._storageContext = util.cachedGetter(() => makeRulesTestFirebaseStorageContext(this.drivers, this.rulesTestEnvironment, this.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 = test.testContextBuilder({
+  buildConfig: input => {
+    const config = {
+      testEnvironment: input?.testEnvironment ?? {},
+      rulesContext: input?.rulesContext
+    };
+    return config;
+  },
+  buildFixture: () => new RulesUnitTestFirebaseTestingContextFixture(),
+  setupInstance: async config => {
+    const drivers = {
+      ...makeTestingFirestoreDrivers(firebase.firebaseFirestoreClientDrivers()),
+      ...makeTestingFirebaseStorageDrivers(firebase.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 rulesUnitTesting.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(() => firestore.setLogLevel('error'));
+  afterAll(() => firestore.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 = firebase.firestoreModelIdentity('mockItem', 'mi');
+class MockItemDocument extends firebase.AbstractFirestoreDocument {
+  get modelIdentity() {
+    return mockItemIdentity;
+  }
+}
+/**
+ * Used to build a FirestoreDataConverter. Fields are configured via configuration. See the SnapshotConverterFunctions for more info.
+ */
+const mockItemConverter = firebase.snapshotConverterFunctions({
+  fields: {
+    value: firebase.optionalFirestoreString(),
+    tags: firebase.optionalFirestoreArray(),
+    date: firebase.optionalFirestoreDate(),
+    number: firebase.optionalFirestoreNumber(),
+    test: firebase.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 = firebase.firestoreModelIdentity(mockItemIdentity, 'mockItemPrivate', 'mip');
+exports.MockItemSettingsItemEnum = void 0;
+(function (MockItemSettingsItemEnum) {
+  MockItemSettingsItemEnum[MockItemSettingsItemEnum["NORTH"] = 0] = "NORTH";
+  MockItemSettingsItemEnum[MockItemSettingsItemEnum["SOUTH"] = 1] = "SOUTH";
+  MockItemSettingsItemEnum[MockItemSettingsItemEnum["EAST"] = 2] = "EAST";
+  MockItemSettingsItemEnum[MockItemSettingsItemEnum["WEST"] = 3] = "WEST";
+})(exports.MockItemSettingsItemEnum || (exports.MockItemSettingsItemEnum = {}));
+const mockItemSettingsItemDencoder = util.bitwiseObjectDencoder({
+  maxIndex: 4,
+  toSetFunction: x => {
+    const set = new Set();
+    if (x.north) {
+      set.add(exports.MockItemSettingsItemEnum.NORTH);
+    }
+    if (x.south) {
+      set.add(exports.MockItemSettingsItemEnum.SOUTH);
+    }
+    if (x.east) {
+      set.add(exports.MockItemSettingsItemEnum.EAST);
+    }
+    if (x.west) {
+      set.add(exports.MockItemSettingsItemEnum.WEST);
+    }
+    return set;
+  },
+  fromSetFunction: x => {
+    const object = {};
+    if (x.has(exports.MockItemSettingsItemEnum.NORTH)) {
+      object.north = true;
+    }
+    if (x.has(exports.MockItemSettingsItemEnum.SOUTH)) {
+      object.south = true;
+    }
+    if (x.has(exports.MockItemSettingsItemEnum.EAST)) {
+      object.east = true;
+    }
+    if (x.has(exports.MockItemSettingsItemEnum.WEST)) {
+      object.west = true;
+    }
+    return object;
+  }
+});
+/**
+ * FirestoreDocument for MockItem
+ */
+class MockItemPrivateDocument extends firebase.AbstractFirestoreDocument {
+  get modelIdentity() {
+    return mockItemPrivateIdentity;
+  }
+}
+/**
+ * Used to build a FirestoreDataConverter. Fields are configured via configuration. See the SnapshotConverterFunctions for more info.
+ */
+const mockItemPrivateConverter = firebase.snapshotConverterFunctions({
+  fieldConversions: util.modelFieldConversions({
+    num: firebase.firestoreNumber({
+      default: 0,
+      defaultBeforeSave: 0
+    }),
+    comments: firebase.optionalFirestoreString(),
+    values: firebase.firestoreUniqueStringArray(),
+    settings: firebase.firestoreBitwiseObjectMap({
+      dencoder: mockItemSettingsItemDencoder
+    }),
+    createdAt: firebase.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 = firebase.firestoreModelIdentity(mockItemIdentity, 'mockItemUser', 'miu');
+/**
+ * FirestoreDocument for MockItem
+ */
+class MockItemUserDocument extends firebase.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 = firebase.snapshotConverterFunctions({
+  fieldConversions: util.modelFieldConversions({
+    uid: firebase.firestoreUID(),
+    name: firebase.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 = firebase.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 = firebase.firestoreModelIdentity(mockItemIdentity, 'mockItemSub', 'misi');
+/**
+ * FirestoreDocument for MockItem
+ */
+class MockItemSubItemDocument extends firebase.AbstractFirestoreDocumentWithParent {
+  get modelIdentity() {
+    return mockItemSubItemIdentity;
+  }
+}
+/**
+ * Used to build a FirestoreDataConverter. Fields are configured via configuration. See the SnapshotConverterFunctions for more info.
+ */
+const mockItemSubItemConverter = firebase.snapshotConverterFunctions({
+  fields: {
+    value: firebase.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 = firebase.firestoreModelIdentity(mockItemSubItemIdentity, 'mockItemSubItemDeep', 'misid');
+/**
+ * FirestoreDocument for MockSubItem
+ */
+class MockItemSubItemDeepDocument extends firebase.AbstractFirestoreDocumentWithParent {
+  get modelIdentity() {
+    return mockItemSubItemDeepIdentity;
+  }
+}
+/**
+ * Used to build a FirestoreDataConverter. Fields are configured via configuration. See the SnapshotConverterFunctions for more info.
+ */
+const mockItemSubItemDeepConverter = firebase.snapshotConverterFunctions({
+  fields: {
+    value: firebase.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 = firebase.firestoreSubObject({
+  objectField: {
+    fields: {
+      lat: firebase.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: firebase.systemStateFirestoreCollection(firestoreContext, mockItemSystemStateStoredDataConverterMap)
+  };
+}
+// MARK: Models
+const mockItemFirebaseModelServiceFactory = firebase.firebaseModelServiceFactory({
+  roleMapForModel: function (output, context, model) {
+    const roles = context.rolesToReturn ?? {
+      read: true
+    };
+    return roles;
+  },
+  getFirestoreCollection: c => c.app.mockItemCollection
+});
+const mockItemPrivateFirebaseModelServiceFactory = firebase.firebaseModelServiceFactory({
+  roleMapForModel: function (output, context, model) {
+    const roles = context.rolesToReturn ?? {
+      read: true
+    };
+    return roles;
+  },
+  getFirestoreCollection: c => c.app.mockItemPrivateCollectionGroup
+});
+const mockItemUserFirebaseModelServiceFactory = firebase.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 = firebase.firebaseModelServiceFactory({
+  roleMapForModel: function (output, context, model) {
+    const roles = context.rolesToReturn ?? {
+      read: true
+    };
+    return roles;
+  },
+  getFirestoreCollection: c => c.app.mockItemSubItemCollectionGroup
+});
+const mockItemSubItemDeepFirebaseModelServiceFactory = firebase.firebaseModelServiceFactory({
+  roleMapForModel: function (output, context, model) {
+    const roles = context.rolesToReturn ?? {
+      read: true
+    };
+    return roles;
+  },
+  getFirestoreCollection: c => c.app.mockItemSubItemDeepCollectionGroup
+});
+const mockItemSystemStateFirebaseModelServiceFactory = firebase.firebaseModelServiceFactory({
+  roleMapForModel: function (output, context, model) {
+    return firebase.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 = firebase.firebaseModelsService(MOCK_FIREBASE_MODEL_SERVICE_FACTORIES);
+
+// MARK: Test Item Testing Fixture
+class MockItemCollectionFixtureInstance {
+  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 = void 0;
+    this.collections = void 0;
+    this.fixture = fixture;
+    this.collections = makeMockItemCollections(fixture.parent.firestoreContext);
+  }
+}
+/**
+ * Used to expose a CollectionReference to MockItem for simple tests.
+ */
+class MockItemCollectionFixture extends test.AbstractWrappedFixtureWithInstance {}
+function testWithMockItemCollectionFixture(config) {
+  return test.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 {
+  constructor(fixture) {
+    this.fixture = void 0;
+    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 test.AbstractWrappedFixtureWithInstance {
+  get storage() {
+    return this.instance.storage;
+  }
+  get storageContext() {
+    return this.instance.storageContext;
+  }
+}
+function testWithMockItemStorageFixture(config) {
+  return test.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 {
+  constructor(firestoreContext) {
+    this.firestoreContext = void 0;
+    this.firestoreContext = firestoreContext;
+  }
+  get firestore() {
+    return this.firestoreContext.firestore;
+  }
+}
+class TestFirestoreContextFixture extends test.AbstractTestContextFixture {
+  get firestore() {
+    return this.instance.firestore;
+  }
+  get firestoreContext() {
+    return this.instance.firestoreContext;
+  }
+}
+
+function mockItemWithValue(value) {
+  return firebase.where('value', '==', value);
+}
+function mockItemWithTestValue(test) {
+  return firebase.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 firebase.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 firebase.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 rxjs.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()', () => {
+            test.itShouldFail('if the item does not exist', async () => {
+              const exists = await itemPrivateDataDocument.accessor.exists();
+              expect(exists).toBe(false);
+              await test.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);
+        });
+        test.itShouldFail('if the path is invalid (points to collection)', () => {
+          test.expectFail(() => {
+            mockItemFirestoreDocumentAccessor.loadDocumentForKey('path');
+          });
+        });
+        test.itShouldFail('if the path points to a different type/collection', () => {
+          test.expectFail(() => {
+            mockItemFirestoreDocumentAccessor.loadDocumentForKey('path/id');
+          });
+        });
+        test.itShouldFail('if the path is empty.', () => {
+          test.expectFail(() => {
+            mockItemFirestoreDocumentAccessor.loadDocumentForKey('');
+          });
+        });
+        test.itShouldFail('if the path is undefined.', () => {
+          test.expectFail(() => {
+            mockItemFirestoreDocumentAccessor.loadDocumentForKey(undefined);
+          });
+        });
+        test.itShouldFail('if the path is null.', () => {
+          test.expectFail(() => {
+            mockItemFirestoreDocumentAccessor.loadDocumentForKey(null);
+          });
+        });
+      });
+      describe('loadDocumentForId()', () => {
+        it('should return a document with the given id.', () => {
+          const document = mockItemFirestoreDocumentAccessor.loadDocumentForId('id');
+          expect(document).toBeDefined();
+        });
+        test.itShouldFail('if the id is empty.', () => {
+          test.expectFail(() => {
+            mockItemFirestoreDocumentAccessor.loadDocumentForId('');
+          });
+        });
+        test.itShouldFail('if the id is undefined.', () => {
+          test.expectFail(() => {
+            mockItemFirestoreDocumentAccessor.loadDocumentForId(undefined);
+          });
+        });
+      });
+    });
+  });
+}
+function describeFirestoreDocumentAccessorTests(init) {
+  let c;
+  let sub;
+  let firestoreDocument;
+  let accessor;
+  beforeEach(() => {
+    sub = new rxjs.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 firebase.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 firebase.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 firebase.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 firebase.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);
+      });
+      test.itShouldFail('if the document exists.', async () => {
+        const snapshot = await firestoreDocument.snapshot();
+        const exists = await firestoreDocument.exists();
+        expect(exists).toBe(true);
+        await test.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);
+      });
+      test.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 test.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();
+          });
+        });
+        test.itShouldFail('if stream$ is called after an update has occured in the transaction', async () => {
+          await test.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 rxjs$1.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.', test.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 rxjs$1.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 rxjs$1.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);
+      });
+      test.itShouldFail('if the document exists.', async () => {
+        const snapshot = await accessor.get();
+        const exists = await accessor.exists();
+        expect(exists).toBe(true);
+        await test.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);
+      });
+      test.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 test.expectFail(() => accessor.update(c.dataForUpdate()));
+      });
+      test.itShouldFail('if the input is an empty object.', async () => {
+        await test.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 = dateFns.addDays(dateFns.startOfDay(new Date()), 1);
+    const EVEN_TAG = 'even';
+    const ODD_TAG = 'odd';
+    beforeEach(async () => {
+      items = await firebase.makeDocuments(f.instance.firestoreCollection.documentAccessor(), {
+        count: testDocumentCount,
+        init: i => {
+          return {
+            value: `${i}`,
+            number: i,
+            date: dateFns.addHours(startDate, i),
+            tags: [`${i}`, `${util.isEvenNumber(i) ? EVEN_TAG : ODD_TAG}`],
+            test: true
+          };
+        }
+      });
+    });
+    describe('firestoreIdBatchVerifierFactory()', () => {
+      const mockItemIdBatchVerifier = firebase.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(firebase.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 = util.arrayFactory(util.mapGetter(util.randomNumberFactory(10000000), x => `test-id-${x}`));
+        const random = util.randomFromArrayFactory(takenIds);
+        const factory = util.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(util.unique(result).length).toBe(idsToMake);
+        expect(util.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 => firebase.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 firebase.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 firebase.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 firebase.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 firebase.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 firebase.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 firebase.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 firebase.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 firebase.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 firebase.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 firebase.iterateFirestoreDocumentSnapshotBatches({
+                  batchSize,
+                  // use specific batch size
+                  limitPerCheckpoint: 1,
+                  maxParallelCheckpoints,
+                  // do four checkpoints in parallel
+                  iterateSnapshotBatch: async (x, batchIndex) => {
+                    currentRunningTasks += 1;
+                    await util.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 firebase.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 firebase.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(firebase.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 => firebase.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 => firebase.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(firebase.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', () => {
+                test.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 test.expectFail(() => querySubItems(firebase.whereDocumentId('==', targetId)).getDocs());
+                });
+              });
+            });
+            describe('streamDocs()', () => {
+              let sub;
+              beforeEach(() => {
+                sub = new rxjs.SubscriptionObject();
+              });
+              afterEach(() => {
+                sub.destroy();
+              });
+              it('should emit when the query results update (an item is added).', test.callbackTest(done => {
+                const itemsToAdd = 1;
+                let addCompleted = false;
+                let addSeen = false;
+                function tryComplete() {
+                  if (addSeen && addCompleted) {
+                    done();
+                  }
+                }
+                sub.subscription = querySubItems().streamDocs().pipe(rxjs$1.filter(x => x.docs.length > allSubItems.length)).subscribe(results => {
+                  addSeen = true;
+                  expect(results.docs.length).toBe(allSubItems.length + itemsToAdd);
+                  tryComplete();
+                });
+                // add one item
+                firebase.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).', test.callbackTest(done => {
+                const itemsToRemove = 1;
+                let deleteCompleted = false;
+                let deleteSeen = false;
+                function tryComplete() {
+                  if (deleteSeen && deleteCompleted) {
+                    done();
+                  }
+                }
+                sub.subscription = querySubItems().streamDocs().pipe(rxjs$1.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(firebase.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(firebase.where('tags', 'array-contains', EVEN_TAG)).filter(firebase.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(firebase.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(firebase.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 rxjs.SubscriptionObject();
+        });
+        afterEach(() => {
+          sub.destroy();
+        });
+        it('should emit when the query results update (an item is added).', test.callbackTest(done => {
+          const itemsToAdd = 1;
+          let addCompleted = false;
+          let addSeen = false;
+          function tryComplete() {
+            if (addSeen && addCompleted) {
+              done();
+            }
+          }
+          sub.subscription = queryDocument().streamDocs().pipe(rxjs$1.filter(documents => documents.length > items.length)).subscribe(documents => {
+            addSeen = true;
+            expect(documents.length).toBe(items.length + itemsToAdd);
+            tryComplete();
+          });
+          // add one item
+          util.waitForMs(10).then(() => firebase.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).', test.callbackTest(done => {
+          const itemsToRemove = 1;
+          let deleteCompleted = false;
+          let deleteSeen = false;
+          function tryComplete() {
+            if (deleteSeen && deleteCompleted) {
+              done();
+            }
+          }
+          sub.subscription = queryDocument().streamDocs().pipe(rxjs$1.skip(1)).subscribe(documents => {
+            deleteSeen = true;
+            expect(documents.length).toBe(items.length - itemsToRemove);
+            tryComplete();
+          });
+          util.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 rxjs.SubscriptionObject();
+        });
+        afterEach(() => {
+          sub.destroy();
+        });
+        it('should emit when the query results update (an item is added).', test.callbackTest(done => {
+          const itemsToAdd = 1;
+          let addCompleted = false;
+          let addSeen = false;
+          function tryComplete() {
+            if (addSeen && addCompleted) {
+              done();
+            }
+          }
+          sub.subscription = queryDocument().streamDocSnapshotDataPairs().pipe(rxjs$1.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
+          util.waitForMs(10).then(() => firebase.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).', test.callbackTest(done => {
+          const itemsToRemove = 1;
+          let deleteCompleted = false;
+          let deleteSeen = false;
+          function tryComplete() {
+            if (deleteSeen && deleteCompleted) {
+              done();
+            }
+          }
+          sub.subscription = queryDocument().streamDocs().pipe(rxjs$1.skip(1)).subscribe(documents => {
+            deleteSeen = true;
+            expect(documents.length).toBe(items.length - itemsToRemove);
+            tryComplete();
+          });
+          util.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 rxjs.SubscriptionObject();
+        });
+        afterEach(() => {
+          sub.destroy();
+        });
+        it('should emit when the query results update (an item is added).', test.callbackTest(done => {
+          const itemsToAdd = 1;
+          let addCompleted = false;
+          let addSeen = false;
+          function tryComplete() {
+            if (addSeen && addCompleted) {
+              done();
+            }
+          }
+          sub.subscription = query().streamDocs().pipe(rxjs$1.filter(x => x.docs.length > items.length)).subscribe(results => {
+            addSeen = true;
+            expect(results.docs.length).toBe(items.length + itemsToAdd);
+            tryComplete();
+          });
+          // add one item
+          util.waitForMs(10).then(() => firebase.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).', test.callbackTest(done => {
+          const itemsToRemove = 1;
+          let deleteCompleted = false;
+          let deleteSeen = false;
+          function tryComplete() {
+            if (deleteSeen && deleteCompleted) {
+              done();
+            }
+          }
+          sub.subscription = query().streamDocs().pipe(rxjs$1.skip(1)).subscribe(results => {
+            deleteSeen = true;
+            expect(results.docs.length).toBe(items.length - itemsToRemove);
+            tryComplete();
+          });
+          util.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(firebase.limit(limitCount)).getDocs();
+            expect(result.docs.length).toBe(limitCount);
+          });
+          it('should limit the streamed results.', test.callbackTest(done => {
+            const limitCount = 2;
+            const resultObs = query(firebase.limit(limitCount)).streamDocs();
+            rxjs$1.from(resultObs).pipe(rxjs$1.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(firebase.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(firebase.orderBy('value'), firebase.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(firebase.orderBy('value', 'asc'), firebase.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');
+          });
+          test.itShouldFail('if orderby is not provided.', async () => {
+            const limitCount = 2;
+            const unlimited = await query().getDocs();
+            expect(unlimited.docs.length).toBe(testDocumentCount);
+            await test.expectFail(() => query(firebase.limitToLast(limitCount)).getDocs());
+          });
+          it('should stream results.', test.callbackTest(done => {
+            const limitCount = 2;
+            const resultObs = query(firebase.orderBy('value'), firebase.limitToLast(limitCount)).streamDocs();
+            rxjs$1.from(resultObs).pipe(rxjs$1.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(firebase.orderBy('value'), firebase.limitToLast(limitCount)).countDocs();
+            expect(result).toBe(limitCount);
+          });
+        });
+        describe('orderBy', () => {
+          it('should return values sorted in ascending order.', async () => {
+            const results = await query(firebase.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(firebase.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(firebase.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(firebase.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(firebase.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(firebase.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(firebase.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(firebase.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(firebase.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(firebase.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(firebase.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(firebase.where('tags', 'array-contains', targetValue)).getDocs();
+                expect(result.docs.length).toBe(1);
+                expect(result.docs[0].data().value).toBe('0');
+              });
+              test.itShouldFail('if an array is passed to where with array-contains', async () => {
+                const targetValues = ['0', 'even'];
+                await test.expectFail(() => query(firebase.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(firebase.where('tags', 'array-contains-any', targetValues)).getDocs();
+                expect(result.docs.length).toBe(Math.floor(testDocumentCount / 2) + 1);
+                result.docs.forEach(x => {
+                  expect(util.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(firebase.where('tags', 'array-contains-any', targetValues)).getDocs();
+                expect(result.docs.length).toBe(Math.floor(testDocumentCount / 2) + 1);
+                result.docs.forEach(x => {
+                  expect(util.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 firebase.makeDocuments(f.instance.firestoreCollection.documentAccessor(), {
+                  count: testDocumentCount,
+                  init: i => {
+                    const isEven = util.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(firebase.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(firebase.whereStringHasRootIdentityModelKey('value', mockItemIdentity)).countDocs();
+                  expect(result).toBe(expectedNumberOfEvenValues);
+                });
+              });
+              describe('whereStringValueHasPrefix()', () => {
+                it('should return only models with searched prefix', async () => {
+                  const result = await query(firebase.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 = dateFns.addHours(startDate, startHoursLater);
+                  const result = await query(firebase.whereDateIsAfterWithSort('date', start)).getDocs();
+                  expect(result.docs.length).toBe(startHoursLater);
+                  // ascending order by default
+                  expect(result.docs[0].data().date?.toISOString()).toBe(dateFns.addHours(start, 1).toISOString());
+                  expect(result.docs[1].data().date?.toISOString()).toBe(dateFns.addHours(start, 2).toISOString());
+                });
+                it('should return models with dates after the input in descending order.', async () => {
+                  const startHoursLater = 2;
+                  const start = dateFns.addHours(startDate, startHoursLater);
+                  const result = await query(firebase.whereDateIsAfterWithSort('date', start, 'desc')).getDocs();
+                  expect(result.docs.length).toBe(startHoursLater);
+                  // check descending order
+                  expect(result.docs[0].data().date?.toISOString()).toBe(dateFns.addHours(start, 2).toISOString());
+                  expect(result.docs[1].data().date?.toISOString()).toBe(dateFns.addHours(start, 1).toISOString());
+                });
+              });
+              describe('whereDateIsBeforeWithSort()', () => {
+                it('should return models with dates before the input.', async () => {
+                  const startHoursLater = 2;
+                  const endDate = dateFns.addHours(startDate, startHoursLater);
+                  const result = await query(firebase.whereDateIsBeforeWithSort('date', endDate)).getDocs();
+                  expect(result.docs.length).toBe(startHoursLater);
+                  // descending order by default
+                  expect(result.docs[0].data().date?.toISOString()).toBe(dateFns.addHours(endDate, -1).toISOString());
+                  expect(result.docs[1].data().date?.toISOString()).toBe(dateFns.addHours(endDate, -2).toISOString());
+                });
+                it('should return models with dates before the input in ascending order.', async () => {
+                  const startHoursLater = 2;
+                  const endDate = dateFns.addHours(startDate, startHoursLater);
+                  const result = await query(firebase.whereDateIsBeforeWithSort('date', endDate, 'asc')).getDocs();
+                  expect(result.docs.length).toBe(startHoursLater);
+                  // check ascending order
+                  expect(result.docs[0].data().date?.toISOString()).toBe(dateFns.addHours(endDate, -2).toISOString());
+                  expect(result.docs[1].data().date?.toISOString()).toBe(dateFns.addHours(endDate, -1).toISOString());
+                });
+              });
+              describe('whereDateIsOnOrAfterWithSort()', () => {
+                it('should return models with dates after the input.', async () => {
+                  const startHoursLater = 2;
+                  const start = dateFns.addHours(startDate, startHoursLater);
+                  const result = await query(firebase.whereDateIsOnOrAfterWithSort('date', start)).getDocs();
+                  expect(result.docs.length).toBe(3);
+                  // ascending order by default
+                  expect(result.docs[0].data().date?.toISOString()).toBe(dateFns.addHours(start, 0).toISOString());
+                  expect(result.docs[1].data().date?.toISOString()).toBe(dateFns.addHours(start, 1).toISOString());
+                  expect(result.docs[2].data().date?.toISOString()).toBe(dateFns.addHours(start, 2).toISOString());
+                });
+                it('should return models with dates after the input in descending order.', async () => {
+                  const startHoursLater = 2;
+                  const start = dateFns.addHours(startDate, startHoursLater);
+                  const result = await query(firebase.whereDateIsOnOrAfterWithSort('date', start, 'desc')).getDocs();
+                  expect(result.docs.length).toBe(3);
+                  // check descending order
+                  expect(result.docs[0].data().date?.toISOString()).toBe(dateFns.addHours(start, 2).toISOString());
+                  expect(result.docs[1].data().date?.toISOString()).toBe(dateFns.addHours(start, 1).toISOString());
+                  expect(result.docs[2].data().date?.toISOString()).toBe(dateFns.addHours(start, 0).toISOString());
+                });
+              });
+              describe('whereDateIsOnOrBeforeWithSort()', () => {
+                it('should return models with dates before the input.', async () => {
+                  const startHoursLater = 2;
+                  const endDate = dateFns.addHours(startDate, startHoursLater);
+                  const result = await query(firebase.whereDateIsOnOrBeforeWithSort('date', endDate)).getDocs();
+                  expect(result.docs.length).toBe(3);
+                  // descending order by default
+                  expect(result.docs[0].data().date?.toISOString()).toBe(dateFns.addHours(endDate, 0).toISOString());
+                  expect(result.docs[1].data().date?.toISOString()).toBe(dateFns.addHours(endDate, -1).toISOString());
+                  expect(result.docs[2].data().date?.toISOString()).toBe(dateFns.addHours(endDate, -2).toISOString());
+                });
+                it('should return models with dates before the input in ascending order.', async () => {
+                  const startHoursLater = 2;
+                  const endDate = dateFns.addHours(startDate, startHoursLater);
+                  const result = await query(firebase.whereDateIsOnOrBeforeWithSort('date', endDate, 'asc')).getDocs();
+                  expect(result.docs.length).toBe(3);
+                  // check ascending order
+                  expect(result.docs[0].data().date?.toISOString()).toBe(dateFns.addHours(endDate, -2).toISOString());
+                  expect(result.docs[1].data().date?.toISOString()).toBe(dateFns.addHours(endDate, -1).toISOString());
+                  expect(result.docs[2].data().date?.toISOString()).toBe(dateFns.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 = dateFns.addHours(startDate, startHoursLater);
+                  const result = await query(firebase.whereDateIsInRange('date', {
+                    date: start,
+                    distance: totalHoursInRange - 1,
+                    type: date.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(dateFns.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 = dateFns.addHours(startDate, startHoursLater);
+                  const end = dateFns.addHours(start, hoursRange);
+                  const result = await query(firebase.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(dateFns.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 = dateFns.addHours(startDate, startHoursLater);
+                    const end = dateFns.addHours(start, hoursRange);
+                    const result = await query([
+                    // filter by dates first
+                    ...firebase.whereDateIsBetween('date', {
+                      start,
+                      end
+                    }),
+                    // only allow even items
+                    firebase.where('tags', 'array-contains-any', targetTag)]).getDocs();
+                    expect(result.docs.length).toBe(1);
+                    const onlyResultData = result.docs[0].data();
+                    expect(onlyResultData.date?.toISOString()).toBe(dateFns.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(firebase.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(firebase.limit(limitCount));
+            const first = await firstQuery.getDocs();
+            expect(first.docs.length).toBe(limitCount);
+            const second = await firstQuery.filter(firebase.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(firebase.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(firebase.orderByDocumentId(), firebase.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(firebase.orderBy('value'), firebase.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(firebase.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(firebase.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(firebase.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(firebase.limit(limitCount));
+            const first = await firstQuery.getDocs();
+            expect(first.docs.length).toBe(limitCount);
+            const second = await firstQuery.filter(firebase.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(firebase.orderBy('value'), firebase.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(firebase.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(firebase.limit(limitCount));
+            const first = await firstQuery.getDocs();
+            expect(first.docs.length).toBe(limitCount);
+            const second = await firstQuery.filter(firebase.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 firebase.makeDocuments(f.instance.firestoreCollection.documentAccessor(), {
+        count: testDocumentCount,
+        init: i => {
+          return {
+            value: `${i}`,
+            test: true
+          };
+        }
+      });
+      sub = new rxjs.SubscriptionObject();
+    });
+    afterEach(() => {
+      sub.destroy();
+    });
+    describe('filter', () => {
+      describe('limit', () => {
+        it('should use the input limit for page size.', test.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', test.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.', test.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.', test.callbackTest(done => {
+          sub.subscription = iteration.currentState$.pipe(rxjs$1.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.', test.callbackTest(done => {
+          iteration.nextPage().then(() => {
+            const nextPageResult = rxjs$1.from(iteration.nextPage());
+            sub.subscription = nextPageResult.pipe(rxjs$1.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 rxjs.SubscriptionObject();
+        });
+        afterEach(() => {
+          accumulatorSub.destroy();
+        });
+        describe('firebaseQuerySnapshotAccumulator()', () => {
+          let accumulator;
+          beforeEach(() => {
+            accumulator = firebase.firebaseQuerySnapshotAccumulator(iteration);
+          });
+          it('should accumulate values from the query.', () => {
+            // todo
+          });
+          describe('flattenAccumulatorResultItemArray()', () => {
+            it(`should aggregate the array of results into a single array.`, test.callbackTest(done => {
+              const pagesToLoad = 2;
+              // load up to page 2
+              rxjs.iteratorNextPageUntilPage(iteration, pagesToLoad).then(page => {
+                expect(page).toBe(pagesToLoad - 1);
+                const obs = rxjs.flattenAccumulatorResultItemArray(accumulator);
+                accumulatorSub.subscription = obs.pipe(rxjs$1.first()).subscribe(values => {
+                  expect(values.length).toBe(pagesToLoad * limit);
+                  expect(util.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.', test.callbackTest(done => {
+              const obs = rxjs.accumulatorCurrentPageListLoadingState(accumulator);
+              accumulatorSub.subscription = obs.pipe(rxjs$1.filter(x => !x.loading)).subscribe(state => {
+                const value = state.value;
+                expect(rxjs.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 = firebase.firebaseQueryItemAccumulator(iteration);
+          });
+          describe('flattenAccumulatorResultItemArray()', () => {
+            it(`should aggregate the array of results into a single array.`, test.callbackTest(done => {
+              const pagesToLoad = 2;
+              // load up to page 2
+              rxjs.iteratorNextPageUntilPage(iteration, pagesToLoad).then(page => {
+                expect(page).toBe(pagesToLoad - 1);
+                const obs = rxjs.flattenAccumulatorResultItemArray(itemAccumulator);
+                accumulatorSub.subscription = obs.pipe(rxjs$1.first()).subscribe(values => {
+                  expect(values.length).toBe(pagesToLoad * limit);
+                  expect(util.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.`, test.callbackTest(done => {
+              const pagesToLoad = 2;
+              // load up to page 2
+              rxjs.iteratorNextPageUntilPage(iteration, pagesToLoad).then(page => {
+                expect(page).toBe(pagesToLoad - 1);
+                const obs = rxjs.flattenAccumulatorResultItemArray(itemAccumulator);
+                accumulatorSub.subscription = obs.pipe(rxjs$1.first()).subscribe(values => {
+                  expect(values.length).toBe(pagesToLoad * limit);
+                  expect(util.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.', test.callbackTest(done => {
+              const obs = rxjs.accumulatorFlattenPageListLoadingState(itemAccumulator);
+              accumulatorSub.subscription = obs.pipe(rxjs$1.filter(x => !x.loading)).subscribe(state => {
+                const value = state.value;
+                expect(rxjs.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.', test.callbackTest(done => {
+              const obs = rxjs.accumulatorCurrentPageListLoadingState(itemAccumulator);
+              accumulatorSub.subscription = obs.pipe(rxjs$1.filter(x => !x.loading)).subscribe(state => {
+                const value = state.value;
+                expect(rxjs.isLoadingStateFinishedLoading(state)).toBe(true);
+                expect(value).toBeDefined();
+                expect(Array.isArray(value)).toBe(true);
+                expect(Array.isArray(value[0])).toBe(true);
+                done();
+              });
+            }));
+          });
+        });
+      });
+    });
+  });
+}
+
+class TestFirebaseStorageInstance {
+  constructor(storageContext) {
+    this.storageContext = void 0;
+    this.storageContext = storageContext;
+  }
+  get storage() {
+    return this.storageContext.storage;
+  }
+}
+class TestFirebaseStorageContextFixture extends test.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', () => {
+            test.itShouldFail('if stringFormat is not defined in the options', async () => {
+              const contentType = 'text/plain';
+              const data = existsFileContent;
+              await test.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 util.useCallback(cb => stream.write(data, 'utf-8', cb));
+              await util.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 = stream.Readable.from(myText, {
+                encoding: 'utf-8'
+              });
+              await firebase.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 = fs.createReadStream(testFilePath, {});
+              await firebase.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()', () => {
+        test.itShouldFail('if the file does not exist.', async () => {
+          await test.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()', () => {
+        test.itShouldFail('if the file does not exist.', async () => {
+          await test.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()', () => {
+        test.itShouldFail('if the file does not exist.', async () => {
+          await test.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 util.readableStreamToBuffer(stream);
+            const decoded = buffer.toString('utf-8');
+            expect(decoded).toBe(existsFileContent);
+          }
+        });
+      });
+      describe('getDownloadUrl()', () => {
+        test.itShouldFail('if the file does not exist.', async () => {
+          const doesNotExistFileExists = await doesNotExistFile.exists();
+          expect(doesNotExistFileExists).toBe(false);
+          await test.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()', () => {
+        test.itShouldFail('if the file does not exist.', async () => {
+          await test.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 => `${util.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);
+          });
+          test.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 test.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 firebase.iterateStorageListFilesByEachFile({
+                folder: existsFolder,
+                readItemsFromPageResult: x => x.result.files(),
+                iterateEachPageItem: async file => {
+                  visitedFiles.push(file);
+                }
+              });
+              const visitedFilePathStrings = visitedFiles.map(x => `${util.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 firebase.iterateStorageListFilesByEachFile({
+                  folder: existsFolder,
+                  includeNestedResults: true,
+                  readItemsFromPageResult: x => x.result.files(),
+                  iterateEachPageItem: async file => {
+                    visitedFiles.push(file);
+                  }
+                });
+                const visitedFilePathStrings = visitedFiles.map(x => `${util.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);
+              });
+            });
+          });
+        });
+      });
+    });
+  });
+}
+
+exports.MOCK_FIREBASE_MODEL_SERVICE_FACTORIES = MOCK_FIREBASE_MODEL_SERVICE_FACTORIES;
+exports.MOCK_SYSTEM_STATE_TYPE = MOCK_SYSTEM_STATE_TYPE;
+exports.MockItemCollectionFixture = MockItemCollectionFixture;
+exports.MockItemCollectionFixtureInstance = MockItemCollectionFixtureInstance;
+exports.MockItemCollections = MockItemCollections;
+exports.MockItemDocument = MockItemDocument;
+exports.MockItemPrivateDocument = MockItemPrivateDocument;
+exports.MockItemStorageFixture = MockItemStorageFixture;
+exports.MockItemStorageFixtureInstance = MockItemStorageFixtureInstance;
+exports.MockItemSubItemDeepDocument = MockItemSubItemDeepDocument;
+exports.MockItemSubItemDocument = MockItemSubItemDocument;
+exports.MockItemUserDocument = MockItemUserDocument;
+exports.RulesUnitTestFirebaseTestingContextFixture = RulesUnitTestFirebaseTestingContextFixture;
+exports.RulesUnitTestTestFirebaseInstance = RulesUnitTestTestFirebaseInstance;
+exports.TESTING_AUTHORIZED_FIREBASE_USER_ID = TESTING_AUTHORIZED_FIREBASE_USER_ID;
+exports.TestFirebaseContextFixture = TestFirebaseContextFixture;
+exports.TestFirebaseInstance = TestFirebaseInstance;
+exports.TestFirebaseStorageContextFixture = TestFirebaseStorageContextFixture;
+exports.TestFirebaseStorageInstance = TestFirebaseStorageInstance;
+exports.TestFirestoreContextFixture = TestFirestoreContextFixture;
+exports.TestFirestoreInstance = TestFirestoreInstance;
+exports.allChildMockItemSubItemDeepsWithinMockItem = allChildMockItemSubItemDeepsWithinMockItem;
+exports.authorizedFirebaseFactory = authorizedFirebaseFactory;
+exports.authorizedTestWithMockItemCollection = authorizedTestWithMockItemCollection;
+exports.authorizedTestWithMockItemStorage = authorizedTestWithMockItemStorage;
+exports.changeFirestoreLogLevelBeforeAndAfterTests = changeFirestoreLogLevelBeforeAndAfterTests;
+exports.clearTestFirestoreContextCollections = clearTestFirestoreContextCollections;
+exports.describeFirebaseStorageAccessorDriverTests = describeFirebaseStorageAccessorDriverTests;
+exports.describeFirestoreAccessorDriverTests = describeFirestoreAccessorDriverTests;
+exports.describeFirestoreDocumentAccessorTests = describeFirestoreDocumentAccessorTests;
+exports.describeFirestoreIterationTests = describeFirestoreIterationTests;
+exports.describeFirestoreQueryDriverTests = describeFirestoreQueryDriverTests;
+exports.firebaseRulesUnitTestBuilder = firebaseRulesUnitTestBuilder;
+exports.makeMockItemCollections = makeMockItemCollections;
+exports.makeRulesTestFirebaseStorageContext = makeRulesTestFirebaseStorageContext;
+exports.makeRulesTestFirestoreContext = makeRulesTestFirestoreContext;
+exports.makeTestingFirebaseStorageAccesorDriver = makeTestingFirebaseStorageAccesorDriver;
+exports.makeTestingFirebaseStorageDrivers = makeTestingFirebaseStorageDrivers;
+exports.makeTestingFirestoreAccesorDriver = makeTestingFirestoreAccesorDriver;
+exports.makeTestingFirestoreDrivers = makeTestingFirestoreDrivers;
+exports.mockFirebaseModelServices = mockFirebaseModelServices;
+exports.mockItemCollectionReference = mockItemCollectionReference;
+exports.mockItemConverter = mockItemConverter;
+exports.mockItemFirebaseModelServiceFactory = mockItemFirebaseModelServiceFactory;
+exports.mockItemFirestoreCollection = mockItemFirestoreCollection;
+exports.mockItemIdentity = mockItemIdentity;
+exports.mockItemPrivateCollectionReference = mockItemPrivateCollectionReference;
+exports.mockItemPrivateCollectionReferenceFactory = mockItemPrivateCollectionReferenceFactory;
+exports.mockItemPrivateConverter = mockItemPrivateConverter;
+exports.mockItemPrivateFirebaseModelServiceFactory = mockItemPrivateFirebaseModelServiceFactory;
+exports.mockItemPrivateFirestoreCollection = mockItemPrivateFirestoreCollection;
+exports.mockItemPrivateFirestoreCollectionGroup = mockItemPrivateFirestoreCollectionGroup;
+exports.mockItemPrivateIdentity = mockItemPrivateIdentity;
+exports.mockItemSettingsItemDencoder = mockItemSettingsItemDencoder;
+exports.mockItemSubItemCollectionReference = mockItemSubItemCollectionReference;
+exports.mockItemSubItemCollectionReferenceFactory = mockItemSubItemCollectionReferenceFactory;
+exports.mockItemSubItemConverter = mockItemSubItemConverter;
+exports.mockItemSubItemDeepCollectionReference = mockItemSubItemDeepCollectionReference;
+exports.mockItemSubItemDeepCollectionReferenceFactory = mockItemSubItemDeepCollectionReferenceFactory;
+exports.mockItemSubItemDeepConverter = mockItemSubItemDeepConverter;
+exports.mockItemSubItemDeepFirebaseModelServiceFactory = mockItemSubItemDeepFirebaseModelServiceFactory;
+exports.mockItemSubItemDeepFirestoreCollection = mockItemSubItemDeepFirestoreCollection;
+exports.mockItemSubItemDeepFirestoreCollectionGroup = mockItemSubItemDeepFirestoreCollectionGroup;
+exports.mockItemSubItemDeepIdentity = mockItemSubItemDeepIdentity;
+exports.mockItemSubItemFirebaseModelServiceFactory = mockItemSubItemFirebaseModelServiceFactory;
+exports.mockItemSubItemFirestoreCollection = mockItemSubItemFirestoreCollection;
+exports.mockItemSubItemFirestoreCollectionGroup = mockItemSubItemFirestoreCollectionGroup;
+exports.mockItemSubItemIdentity = mockItemSubItemIdentity;
+exports.mockItemSystemDataConverter = mockItemSystemDataConverter;
+exports.mockItemSystemStateFirebaseModelServiceFactory = mockItemSystemStateFirebaseModelServiceFactory;
+exports.mockItemSystemStateStoredDataConverterMap = mockItemSystemStateStoredDataConverterMap;
+exports.mockItemUserAccessorFactory = mockItemUserAccessorFactory;
+exports.mockItemUserCollectionName = mockItemUserCollectionName;
+exports.mockItemUserCollectionReference = mockItemUserCollectionReference;
+exports.mockItemUserCollectionReferenceFactory = mockItemUserCollectionReferenceFactory;
+exports.mockItemUserConverter = mockItemUserConverter;
+exports.mockItemUserFirebaseModelServiceFactory = mockItemUserFirebaseModelServiceFactory;
+exports.mockItemUserFirestoreCollection = mockItemUserFirestoreCollection;
+exports.mockItemUserFirestoreCollectionGroup = mockItemUserFirestoreCollectionGroup;
+exports.mockItemUserIdentifier = mockItemUserIdentifier;
+exports.mockItemUserIdentity = mockItemUserIdentity;
+exports.mockItemWithTestValue = mockItemWithTestValue;
+exports.mockItemWithValue = mockItemWithValue;
+exports.testWithMockItemCollectionFixture = testWithMockItemCollectionFixture;
+exports.testWithMockItemStorageFixture = testWithMockItemStorageFixture;