@dereekb/firebase-server 12.7.0 → 13.0.1

package/test/index.cjs.js

@@ -0,0 +1,1258 @@
+'use strict';
+
+var util = require('@dereekb/util');
+var test = require('@dereekb/util/test');
+var jsonwebtoken = require('jsonwebtoken');
+var firebase = require('@dereekb/firebase');
+var admin = require('firebase-admin');
+var functions = require('firebase-functions-test');
+var test$1 = require('@dereekb/firebase/test');
+var firebaseServer = require('@dereekb/firebase-server');
+var firestore = require('@google-cloud/firestore');
+var storage = require('@google-cloud/storage');
+var testing = require('@nestjs/testing');
+var nestjs = require('@dereekb/nestjs');
+var https = require('firebase-functions/v1/https');
+var makeError = require('make-error');
+
+class AuthorizedUserTestContextFixture extends test.AbstractChildTestContextFixture {
+    // MARK: AuthorizedUserTestContext (Forwarded)
+    get uid() {
+        return this.instance.uid;
+    }
+    loadUserRecord() {
+        return this.instance.loadUserRecord();
+    }
+    loadUserEmailAndPhone() {
+        return this.instance.loadUserEmailAndPhone();
+    }
+    loadIdToken() {
+        return this.instance.loadIdToken();
+    }
+    loadDecodedIdToken() {
+        return this.instance.loadDecodedIdToken();
+    }
+    makeContextOptions() {
+        return this.instance.makeContextOptions();
+    }
+    callWrappedFunction(fn, params, skipJsonConversion) {
+        return this.instance.callWrappedFunction(fn, params, skipJsonConversion);
+    }
+    callCloudFunction(fn, params, skipJsonConversion = false) {
+        return this.instance.callCloudFunction(fn, params, skipJsonConversion);
+    }
+}
+function convertParamsToParsedJsonObjectAndBack(object) {
+    const paramsAsJson = JSON.parse(JSON.stringify(object));
+    return paramsAsJson;
+}
+class AuthorizedUserTestContextInstance {
+    uid;
+    testContext;
+    constructor(uid, testContext) {
+        this.uid = uid;
+        this.testContext = testContext;
+    }
+    loadUserRecord() {
+        return this.testContext.auth.getUser(this.uid);
+    }
+    async loadUserEmailAndPhone() {
+        const record = await this.loadUserRecord();
+        return {
+            email: record.email,
+            phone: record.phoneNumber
+        };
+    }
+    loadIdToken() {
+        return this.loadUserRecord().then((record) => createEncodedTestFirestoreTokenForUserRecord(this.testContext.auth, record));
+    }
+    loadDecodedIdToken() {
+        return this.loadIdToken().then(decodeEncodedCreateCustomTokenResult);
+    }
+    makeContextOptions() {
+        return this.loadUserRecord().then((record) => createTestFunctionContextOptions(this.testContext.auth, record));
+    }
+    /**
+     * Calls a wrapped function with the input params and the context from makeContextOptions().
+     *
+     * @param fn
+     * @param params
+     * @param skipJsonConversion
+     */
+    callWrappedFunction(fn, params, skipJsonConversion) {
+        // Parse to JSON then back to simulate sending JSON to the server, and the server parsing it as a POJO.
+        const parsedParams = params == null || skipJsonConversion ? params : convertParamsToParsedJsonObjectAndBack(params);
+        return this.makeContextOptions().then((options) => fn(parsedParams, options));
+    }
+    callCloudFunction(fn, params, skipJsonConversion = false) {
+        if (params != null && params.scheduleTime) {
+            // Workaround for https://github.com/firebase/firebase-functions-test/issues/210
+            const scheduleTime = params.scheduleTime;
+            delete params.scheduleTime;
+            params.timestamp = scheduleTime;
+        }
+        return this.callWrappedFunction(fn, params, skipJsonConversion);
+    }
+    /**
+     * Calls a wrapped gen 2 auth blocking function with the input params and context options from makeContextOptions().
+     *
+     * @param fn
+     * @param userRecord
+     * @param eventType
+     * @param eventOverride
+     * @param skipJsonConversion
+     * @returns
+     */
+    callAuthBlockingFunction(fn, userRecord, eventType, eventOverride, skipJsonConversion = false) {
+        const timestamp = new Date().toISOString();
+        const event = {
+            ipAddress: '127.0.0.1',
+            userAgent: 'testing',
+            eventId: '0',
+            params: {},
+            resource: { service: 'dbx-test', name: 'fake-resource' },
+            timestamp,
+            ...eventOverride,
+            data: userRecord,
+            eventType
+        };
+        return this.callCloudFunction(fn, event, skipJsonConversion);
+    }
+    /**
+     * @deprecated gen 1
+     *
+     * @param fn
+     * @param params
+     * @param contextOptions
+     * @param skipJsonConversion
+     * @returns
+     */
+    callEventCloudFunction(fn, params, contextOptions, skipJsonConversion = false) {
+        const parsedParams = params == null || skipJsonConversion ? params : convertParamsToParsedJsonObjectAndBack(params);
+        return this.makeContextOptions().then((options) => fn(parsedParams, contextOptions ? { ...contextOptions, ...options } : options));
+    }
+}
+/**
+ * Convenience function for using authorizedUserContextFactory directly and passing buildTests.
+ */
+function authorizedUserContext(config, buildTests) {
+    authorizedUserContextFactory(config)({ f: config.f }, buildTests);
+}
+const AUTHORIZED_USER_RANDOM_EMAIL_FACTORY = util.randomEmailFactory();
+const AUTHORIZED_USER_RANDOM_PHONE_NUMBER_FACTORY = util.randomPhoneNumberFactory();
+/**
+ * Creates a new Jest Context that has a random user for authorization for use in firebase server tests.
+ */
+function authorizedUserContextFactory(config) {
+    const { uid: uidGetter, makeInstance = (uid, testInstance) => new AuthorizedUserTestContextInstance(uid, testInstance), makeFixture = (f) => new AuthorizedUserTestContextFixture(f), makeUserDetails = () => ({}), initUser } = config;
+    const makeUid = uidGetter ? util.asGetter(uidGetter) : testUidFactory;
+    return (params, buildTests) => {
+        const { f, user: inputUserGetterOrValue, addContactInfo: inputAddContactInfoGetterOrValue, template: inputTemplateGetterOrValue } = params;
+        const inputAddContactInfoGetter = util.asGetter(inputAddContactInfoGetterOrValue);
+        const inputUserGetter = util.asGetter(inputUserGetterOrValue);
+        const templateGetter = util.asGetter(inputTemplateGetterOrValue);
+        return test.useTestContextFixture({
+            fixture: makeFixture(f),
+            buildTests,
+            initInstance: async () => {
+                const inputAddContactInfo = await inputAddContactInfoGetter();
+                const inputUser = await inputUserGetter();
+                const inputTemplate = await templateGetter();
+                const uid = inputUser?.uid || makeUid();
+                const { details, claims, addContactInfo: userDetailsAddContactInfo } = { ...makeUserDetails(uid, params), ...inputTemplate };
+                const { phoneNumber: detailsPhoneNumber, email: detailsEmail } = details ?? {}; // keep details if provided
+                const addContactInfo = inputAddContactInfo || userDetailsAddContactInfo;
+                const auth = f.instance.auth;
+                let email;
+                let phoneNumber;
+                if (addContactInfo) {
+                    email = detailsEmail ?? AUTHORIZED_USER_RANDOM_EMAIL_FACTORY();
+                    phoneNumber = detailsPhoneNumber ?? AUTHORIZED_USER_RANDOM_PHONE_NUMBER_FACTORY();
+                }
+                else {
+                    email = detailsEmail;
+                    phoneNumber = detailsPhoneNumber ?? undefined;
+                }
+                const userRecord = await auth.createUser({
+                    uid,
+                    displayName: 'Test Person',
+                    ...details,
+                    email,
+                    phoneNumber,
+                    ...inputUser
+                });
+                if (claims) {
+                    await auth.setCustomUserClaims(uid, claims);
+                }
+                const instance = await makeInstance(uid, f.instance, params, userRecord);
+                if (initUser) {
+                    await initUser(instance, params);
+                }
+                return instance;
+            },
+            destroyInstance: async (instance) => {
+                const app = instance.testContext.app;
+                const uid = instance.uid;
+                await app.auth().deleteUser(uid);
+            }
+        });
+    };
+}
+/**
+ * Incrementing number factory for generating test UID values.
+ *
+ * Has the format 'test-uid-<number>'
+ */
+const testUidFactory = util.mapGetter(util.incrementingNumberFactory(), (i) => `${new Date().getTime()}0${i}`);
+/**
+ * Creates a CallableContextOptions with auth attached corresponding to the input UserRecord.
+ *
+ * @param auth
+ * @param userRecord
+ * @returns
+ */
+async function createTestFunctionContextOptions(auth, userRecord) {
+    const authData = await createTestFunctionContextAuthData(auth, userRecord);
+    const contextOptions = {
+        auth: authData
+    };
+    return contextOptions;
+}
+/**
+ * Creates AuthData from the input auth and user record.
+ *
+ * @param auth
+ * @param userRecord
+ * @returns
+ */
+async function createTestFunctionContextAuthData(auth, userRecord) {
+    const token = await createTestFirestoreTokenForUserRecord(auth, userRecord);
+    const authData = {
+        uid: token.uid,
+        token,
+        rawToken: ''
+    };
+    return authData;
+}
+/**
+ * Creates and decodes a firestore token used for testing.
+ *
+ * @param auth
+ * @param userRecord
+ * @returns
+ */
+function createTestFirestoreTokenForUserRecord(auth, userRecord) {
+    return createEncodedTestFirestoreTokenForUserRecord(auth, userRecord).then(decodeEncodedCreateCustomTokenResult);
+}
+/**
+ * Creates an encoded firestore token used for testing.
+ *
+ * @param auth
+ * @param userRecord
+ * @returns
+ */
+function createEncodedTestFirestoreTokenForUserRecord(auth, userRecord) {
+    // TODO: Consider replacing createCustomToken, as the custom claims are put into an object called claims in the JWT, instead of spread over. The decodeEncodedCreateCustomTokenResult() function handles this issue, but it may not be expected.
+    return auth.createCustomToken(userRecord.uid, testFirestoreClaimsFromUserRecord(userRecord));
+}
+function decodeEncodedCreateCustomTokenResult(token) {
+    const decoded = jsonwebtoken.decode(token);
+    const decodedToken = {
+        ...decoded,
+        ...decoded.claims,
+        auth_time: decoded.iat,
+        firebase: decoded.claims?.firebase ?? {}
+    };
+    delete decodedToken.claims; // remove the "claims" item if it exists.
+    return decodedToken;
+}
+function testFirestoreClaimsFromUserRecord(userRecord) {
+    // Copy claims to be similar to DecodedIdToken pieces.
+    const baseClaims = {
+        picture: userRecord.photoURL,
+        email: userRecord.email,
+        email_verified: userRecord.emailVerified ?? false,
+        firebase: {
+            sign_in_provider: '@dereekb/firebase-server/test',
+            identities: []
+        }
+    };
+    const customClaims = userRecord.customClaims;
+    const claims = {
+        ...customClaims,
+        ...baseClaims
+    };
+    return claims;
+}
+
+class ModelTestContextFixture extends test.AbstractChildTestContextFixture {
+    // MARK: ModelTestContext (Forwarded)
+    get documentId() {
+        return this.instance.documentId;
+    }
+    get documentKey() {
+        return this.instance.documentKey;
+    }
+    get documentFlatKey() {
+        return this.instance.documentFlatKey;
+    }
+    get documentTwoWayFlatKey() {
+        return this.instance.documentTwoWayFlatKey;
+    }
+    get documentRef() {
+        return this.instance.documentRef;
+    }
+    get document() {
+        return this.instance.document;
+    }
+}
+class ModelTestContextInstance {
+    collection;
+    ref;
+    testContext;
+    constructor(collection, ref, testContext) {
+        this.collection = collection;
+        this.ref = ref;
+        this.testContext = testContext;
+    }
+    get documentId() {
+        return this.ref.id;
+    }
+    get documentKey() {
+        return this.ref.path;
+    }
+    get documentFlatKey() {
+        return firebase.flatFirestoreModelKey(this.documentKey);
+    }
+    get documentTwoWayFlatKey() {
+        return firebase.twoWayFlatFirestoreModelKey(this.documentKey);
+    }
+    get documentRef() {
+        return this.ref;
+    }
+    get document() {
+        return this.collection.documentAccessor().loadDocument(this.ref);
+    }
+}
+/**
+ * Creates a new Test Context that has a random user for authorization for use in firebase server tests.
+ */
+function modelTestContextFactory(config) {
+    const { getCollection, collectionForDocument, makeRef = (collection) => {
+        const accessor = collection.documentAccessor();
+        if (accessor.newDocument == null) {
+            throw new Error('collection passed to makeRef() was not a full FirestoreCollection. Either supply a custom makeRef() function or a FirestoreCollection that has newDocument() available on the documentAccessor.');
+        }
+        return accessor.newDocument().documentRef;
+    }, makeInstance = (collection, ref, testInstance) => new ModelTestContextInstance(collection, ref, testInstance), makeFixture = (f) => new ModelTestContextFixture(f), initDocument, destroyInstance } = config;
+    return (params, buildTests) => {
+        const { f } = params;
+        return test.useTestContextFixture({
+            fixture: makeFixture(f),
+            buildTests,
+            initInstance: async () => {
+                const parentInstance = f.instance;
+                let ref;
+                let collection;
+                let init;
+                if (params.doc) {
+                    const doc = await util.getValueFromGetter(params.doc);
+                    if (!collectionForDocument) {
+                        throw new Error('collectionForDocument() is required when using ModelTestContextDocumentRefParams values as input.');
+                    }
+                    collection = collectionForDocument(parentInstance, doc);
+                    const expectedCollectionName = collection.documentAccessor().modelIdentity.collectionName;
+                    if (expectedCollectionName !== doc.modelIdentity.collectionName) {
+                        throw new Error(`Input doc is in a different collection (${doc.modelIdentity.collectionName}) than expected (${expectedCollectionName}).`);
+                    }
+                    ref = doc.documentRef;
+                    init = false;
+                }
+                else {
+                    collection = getCollection(parentInstance, params);
+                    ref = await makeRef(collection, params, parentInstance);
+                    init = true;
+                }
+                const instance = await makeInstance(collection, ref, parentInstance);
+                if (init && initDocument) {
+                    await initDocument(instance, params);
+                }
+                return instance;
+            },
+            destroyInstance
+        });
+    };
+}
+
+let adminEnvironmentInitialized = false;
+function isAdminEnvironmentInitialized() {
+    return adminEnvironmentInitialized;
+}
+function generateNewProjectId() {
+    const projectId = 'firebase-test-' + new Date().getTime();
+    return projectId;
+}
+function rollNewGCloudProjectEnvironmentVariable() {
+    const projectId = generateNewProjectId();
+    process.env.GCLOUD_TEST_PROJECT = projectId;
+    process.env.GCLOUD_PROJECT = projectId;
+    applyFirebaseGCloudTestProjectIdToFirebaseConfigEnv();
+    return projectId;
+}
+function getGCloudProjectId() {
+    return process.env.GCLOUD_PROJECT;
+}
+function getGCloudTestProjectId() {
+    return process.env.GCLOUD_TEST_PROJECT;
+}
+/**
+ * Applies the current GCLOUD_PROJECT to FIREBASE_CONFIG.
+ *
+ * This is done as some external testing libraries (firebase-functions-test) will overwrite but we want to enforce using our project id
+ * so that each component can also
+ */
+function applyFirebaseGCloudTestProjectIdToFirebaseConfigEnv() {
+    // firebase-functions-test overwrites this each time.
+    // https://github.com/firebase/firebase-functions-test/blob/acb068f4c086f3355b2960b9e9e5895716c7f8cc/src/lifecycle.ts#L37
+    const testProjectId = getGCloudTestProjectId();
+    // console.log('Test project: ', testProjectId);
+    if (!testProjectId) {
+        throw new Error('No test project id was available in the environment. Did you call initFirebaseAdminTestEnvironment() first?');
+    }
+    const config = JSON.parse(process.env.FIREBASE_CONFIG ?? '{}');
+    config.projectId = testProjectId;
+    process.env.FIREBASE_CONFIG = JSON.stringify(config);
+    process.env.GCLOUD_PROJECT = testProjectId; // re-apply to GCLOUD_PROJECT too
+    return testProjectId;
+}
+/**
+ * Should be called before calling/using adminFirebaseTestBuilder(). This should only be called once.
+ */
+function initFirebaseAdminTestEnvironment(config) {
+    function crashForEmulator(emulator) {
+        throw new Error(`Emulator for ${emulator} was not set null or to a host. Crashing to prevent contamination.`);
+    }
+    function configureEmulator(emulator, envKey) {
+        const emulatorConfig = config.emulators[emulator];
+        if (emulatorConfig) {
+            process.env[envKey] = emulatorConfig;
+        }
+        else if (config.emulators.firestore !== null) {
+            crashForEmulator(emulator);
+        }
+    }
+    rollNewGCloudProjectEnvironmentVariable();
+    configureEmulator('auth', 'FIREBASE_AUTH_EMULATOR_HOST');
+    configureEmulator('firestore', 'FIRESTORE_EMULATOR_HOST');
+    configureEmulator('storage', 'FIREBASE_STORAGE_EMULATOR_HOST');
+    applyFirebaseGCloudTestProjectIdToFirebaseConfigEnv();
+    adminEnvironmentInitialized = true;
+}
+
+function makeGoogleFirestoreContext(drivers, firestore) {
+    const context = firebase.firestoreContextFactory(drivers)(firestore);
+    context.drivers = drivers;
+    return context;
+}
+class GoogleCloudTestFirestoreInstance extends test$1.TestFirestoreInstance {
+    constructor(drivers, firestore) {
+        super(makeGoogleFirestoreContext(drivers, firestore));
+    }
+}
+class GoogleCloudTestFirestoreContextFixture extends test$1.TestFirestoreContextFixture {
+}
+let COUNTER$1 = 0;
+/**
+ * A TestContextBuilderFunction for building firestore test context factories using @google-cloud/firestore. This means SERVER TESTING ONLY. For client testing, look at @dereekb/firestore.
+ *
+ * This is used to build a @google-cloud/firestore Firestore instance for testing and point it to the emulators.
+ *
+ * If you need all of Firebase (firebase-admin library), look at adminFirebaseAdminTestBuilder() instead.
+ */
+const googleCloudTestFirestoreBuilder = test.testContextBuilder({
+    buildConfig: (input) => {
+        const config = {
+            host: input?.host ?? 'localhost',
+            port: input?.port ?? 0
+        };
+        return config;
+    },
+    buildFixture: () => new GoogleCloudTestFirestoreContextFixture(),
+    setupInstance: async (config) => {
+        const random = Math.floor(Math.random() * 10000);
+        const drivers = test$1.makeTestingFirestoreDrivers(firebaseServer.googleCloudFirestoreDrivers());
+        const projectId = `test-${COUNTER$1++}-${Date.now()}-${random}`.substring(0, 30);
+        const firestore$1 = new firestore.Firestore({
+            projectId,
+            host: config.host,
+            port: config.port,
+            maxIdleChannels: 0
+        });
+        return new GoogleCloudTestFirestoreInstance(drivers, firestore$1);
+    },
+    teardownInstance: async (instance, config) => {
+        await instance.firestore.terminate();
+    }
+});
+
+function makeGoogleFirebaseStorageContext(drivers, firebaseStorage, defaultBucketId) {
+    const context = firebase.firebaseStorageContextFactory(drivers)(firebaseStorage, { defaultBucketId });
+    context.drivers = drivers;
+    return context;
+}
+class GoogleCloudTestFirebaseStorageInstance extends test$1.TestFirebaseStorageInstance {
+    constructor(drivers, firebaseStorage, defaultBucketId) {
+        super(makeGoogleFirebaseStorageContext(drivers, firebaseStorage, defaultBucketId));
+    }
+}
+class GoogleCloudTestFirebaseStorageContextFixture extends test$1.TestFirebaseStorageContextFixture {
+}
+let COUNTER = 0;
+/**
+ * A TestContextBuilderFunction for building firebase storage test context factories using @google-cloud/storage. This means SERVER TESTING ONLY. For client testing, look at @dereekb/firestore.
+ *
+ * This is used to build a @google-cloud/storage FirebaseStorage instance for testing and point it to the emulators.
+ *
+ * If you need all of Firebase (firebase-admin library), look at adminFirebaseAdminTestBuilder() instead.
+ */
+const googleCloudTestFirebaseStorageBuilder = test.testContextBuilder({
+    buildConfig: (input) => {
+        const config = {
+            host: input?.host ?? 'localhost',
+            port: input?.port ?? 0
+        };
+        if (!config.port) {
+            throw new Error('Port for host is required.');
+        }
+        return config;
+    },
+    buildFixture: () => new GoogleCloudTestFirebaseStorageContextFixture(),
+    setupInstance: async (config) => {
+        const drivers = test$1.makeTestingFirebaseStorageDrivers(firebaseServer.googleCloudFirebaseStorageDrivers());
+        const projectId = `firebase-storage-server-test-${new Date().getTime()}-${COUNTER++}`;
+        const firebaseStorage = new storage.Storage({
+            projectId,
+            // ensure http:// is provided so the library doesn't default to/try https://
+            apiEndpoint: `http://${config.host}:${config.port}`
+        });
+        const defaultBucketId = projectId;
+        return new GoogleCloudTestFirebaseStorageInstance(drivers, firebaseStorage, defaultBucketId);
+    },
+    teardownInstance: async (instance, config) => {
+        // nothing to teardown
+    }
+});
+
+class FirebaseAdminTestContextFixture extends test.AbstractTestContextFixture {
+    // MARK: FirebaseAdminTestContext (Forwarded)
+    get app() {
+        return this.instance.app;
+    }
+    get auth() {
+        return this.instance.auth;
+    }
+    get firestore() {
+        return this.instance.firestore;
+    }
+    get firestoreInstance() {
+        return this.instance.firestoreInstance;
+    }
+    get firestoreContext() {
+        return this.instance.firestoreContext;
+    }
+    get storage() {
+        return this.instance.storage;
+    }
+    get storageInstance() {
+        return this.instance.storageInstance;
+    }
+    get storageContext() {
+        return this.instance.storageContext;
+    }
+    get fnWrapper() {
+        return this.instance.fnWrapper;
+    }
+}
+// MARK: FirebaseAdminTestBuilder
+class FirebaseAdminTestContextInstance {
+    app;
+    getTestFirestoreInstance = util.cachedGetter(() => {
+        const drivers = test$1.makeTestingFirestoreDrivers(firebaseServer.googleCloudFirestoreDrivers());
+        return new GoogleCloudTestFirestoreInstance(drivers, this.firestore);
+    });
+    getTestFirebaseStorageInstance = util.cachedGetter(() => {
+        const drivers = test$1.makeTestingFirebaseStorageDrivers(firebaseServer.googleCloudFirebaseStorageDrivers());
+        const defaultBucketId = this.app.options.storageBucket;
+        return new GoogleCloudTestFirebaseStorageInstance(drivers, this.storage, defaultBucketId);
+    });
+    constructor(app) {
+        this.app = app;
+    }
+    get auth() {
+        return this.app.auth();
+    }
+    get firestore() {
+        return this.app.firestore();
+    }
+    get firestoreInstance() {
+        return this.getTestFirestoreInstance();
+    }
+    get firestoreContext() {
+        return this.firestoreInstance.firestoreContext;
+    }
+    get storage() {
+        return firebaseServer.googleCloudStorageFromFirebaseAdminStorage(this.app.storage());
+    }
+    get storageInstance() {
+        return this.getTestFirebaseStorageInstance();
+    }
+    get storageContext() {
+        return this.storageInstance.storageContext;
+    }
+    get fnWrapper() {
+        throw new Error('wrapCloudFunction is unsupported by this type.');
+    }
+}
+class AbstractFirebaseAdminTestContextInstanceChild {
+    parent;
+    constructor(parent) {
+        this.parent = parent;
+    }
+    // MARK: FirebaseAdminTestContext (Forwarded)
+    get app() {
+        return this.parent.app;
+    }
+    get auth() {
+        return this.parent.auth;
+    }
+    get firestore() {
+        return this.parent.firestore;
+    }
+    get firestoreInstance() {
+        return this.parent.firestoreInstance;
+    }
+    get firestoreContext() {
+        return this.parent.firestoreContext;
+    }
+    get storage() {
+        return this.parent.storage;
+    }
+    get storageInstance() {
+        return this.parent.storageInstance;
+    }
+    get storageContext() {
+        return this.parent.storageContext;
+    }
+    get fnWrapper() {
+        return this.parent.fnWrapper;
+    }
+}
+/**
+ * A TestContextBuilderFunction for building firebase test context factories using firebase-admin.
+ *
+ * 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 firebaseAdminTestBuilder = test.testContextBuilder({
+    buildConfig: (input) => {
+        const config = {
+            ...input
+        };
+        return config;
+    },
+    buildFixture: () => new FirebaseAdminTestContextFixture(),
+    setupInstance: async (config) => {
+        if (!isAdminEnvironmentInitialized()) {
+            throw new Error('Call initFirebaseAdminTestEnvironment() from @dereekb/firebase-server was not called before using adminFirebaseTestBuilder().');
+        }
+        const projectId = generateNewProjectId();
+        const storageBucket = 'b-' + projectId;
+        const app = admin.initializeApp({ projectId, storageBucket });
+        return new FirebaseAdminTestContextInstance(app);
+    },
+    teardownInstance: async (instance, config) => {
+        await instance.app.delete(); // clean up the instance
+    }
+});
+const firebaseAdminTestContextFactory = firebaseAdminTestBuilder({});
+// MARK: Firestore Context
+/**
+ * Convenience function to build a TestFirestoreContextFactory from a FirebaseAdminTestContextFactory.
+ *
+ * This is useful for composing child tests that will benefit from the firestore testing context, but want the full app available.
+ *
+ * @param factory
+ * @returns
+ */
+function firebaseAdminFirestoreContextFixture(factory) {
+    return (buildTests) => {
+        factory((f) => firebaseAdminFirestoreContextWithFixture(f, buildTests));
+    };
+}
+function firebaseAdminFirestoreContextWithFixture(f, buildTests) {
+    test.useTestContextFixture({
+        fixture: new test$1.TestFirestoreContextFixture(),
+        /**
+         * Build tests by passing the fixture to the testing functions.
+         *
+         * This will inject all tests and sub testing lifecycle items.
+         */
+        buildTests,
+        initInstance: () => f.instance.getTestFirestoreInstance()
+    });
+}
+
+function firebaseAdminCloudFunctionWrapper(instance) {
+    const wrapV1CloudFunction = (x) => {
+        return instance.wrap(x);
+    };
+    const wrapV2CallableRequest = (x) => {
+        const wrappedCloudFunction = instance.wrap(x);
+        // context is marked optional here to better match the gen 1 callable function signature
+        return async (data, context) => {
+            const request = {
+                ...context,
+                data,
+                // NOTE: These will typically not be used/available as they are express.js properties that are not available or useful to the handlers
+                rawRequest: context?.rawRequest ?? {},
+                acceptsStreaming: false
+            };
+            const result = (await wrappedCloudFunction(request));
+            return result;
+        };
+    };
+    const wrapV2CloudFunction = (x) => {
+        return instance.wrap(x);
+    };
+    const wrapBlockingFunction = ((blockingFunction) => {
+        return instance.wrap(blockingFunction);
+    });
+    const wrapCloudFunction = (x) => {
+        return instance.wrap(x);
+    };
+    const wrapper = {
+        wrapV1CloudFunction,
+        wrapV2CloudFunction,
+        wrapV2CallableRequest,
+        wrapCallableRequest: wrapV2CallableRequest,
+        wrapBlockingFunction,
+        wrapCloudFunction
+    };
+    return wrapper;
+}
+function wrapCloudFunctionV1ForTests(wrapper, getter) {
+    return () => wrapper.wrapV1CloudFunction(getter());
+}
+function wrapCallableRequestForTests(wrapper, getter) {
+    return () => wrapper.wrapCallableRequest(getter());
+}
+
+// MARK: FirebaseAdminFunctionTestBuilder
+let functionsInitialized = false;
+/**
+ * firebase-functions-test uses a singleton internally, so we must track the reference to properly tear it down too.
+ */
+let firebaseFunctionsTestInstance;
+function setupFirebaseAdminFunctionTestSingleton(reroll = false) {
+    if (!isAdminEnvironmentInitialized()) {
+        throw new Error('initFirebaseAdminTestEnvironment() was not called.');
+    }
+    if (firebaseFunctionsTestInstance) {
+        firebaseFunctionsTestInstance.cleanup(); // destroy the old instance if it is up.
+    }
+    firebaseFunctionsTestInstance = functions();
+    if (reroll) {
+        rollNewGCloudProjectEnvironmentVariable();
+    }
+    else {
+        applyFirebaseGCloudTestProjectIdToFirebaseConfigEnv();
+    }
+    functionsInitialized = true;
+    return firebaseFunctionsTestInstance;
+}
+function rerollFirebaseAdminFunctionTestSingleton() {
+    return setupFirebaseAdminFunctionTestSingleton(true);
+}
+class FirebaseAdminFunctionTestContextFixture extends test.AbstractTestContextFixture {
+    // MARK: FirebaseAdminTestContext (Forwarded)
+    get app() {
+        return this.instance.app;
+    }
+    get auth() {
+        return this.instance.auth;
+    }
+    get firestore() {
+        return this.instance.firestore;
+    }
+    get firestoreInstance() {
+        return this.instance.firestoreInstance;
+    }
+    get firestoreContext() {
+        return this.instance.firestoreContext;
+    }
+    get storage() {
+        return this.instance.storage;
+    }
+    get storageInstance() {
+        return this.instance.storageInstance;
+    }
+    get storageContext() {
+        return this.instance.storageContext;
+    }
+    get fnWrapper() {
+        return this.instance.fnWrapper;
+    }
+}
+class FirebaseAdminFunctionTestContextInstance extends FirebaseAdminTestContextInstance {
+    instance;
+    _fnWrapper = util.cachedGetter(() => firebaseAdminCloudFunctionWrapper(this.instance));
+    constructor(instance, app) {
+        super(app);
+        this.instance = instance;
+    }
+    get fnWrapper() {
+        return this._fnWrapper();
+    }
+}
+exports.DEFAULT_FIREBASE_ADMIN_FUNCTION_TEST_USE_FUNCTION_SINGLETON_CONTEXT = false;
+function setDefaultFirebaseAdminFunctionTestUseFunctionSingleton(use) {
+    exports.DEFAULT_FIREBASE_ADMIN_FUNCTION_TEST_USE_FUNCTION_SINGLETON_CONTEXT = use;
+}
+/**
+ * A TestContextBuilderFunction for building firebase test context factories using firebase-admin.
+ *
+ * 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 firebaseAdminFunctionTestBuilder = test.testContextBuilder({
+    buildConfig: (input) => {
+        const config = {
+            ...input,
+            useFunctionSingletonContext: input?.useFunctionSingletonContext ?? exports.DEFAULT_FIREBASE_ADMIN_FUNCTION_TEST_USE_FUNCTION_SINGLETON_CONTEXT
+        };
+        return config;
+    },
+    buildFixture: () => new FirebaseAdminFunctionTestContextFixture(),
+    setupInstance: async (config) => {
+        if (!isAdminEnvironmentInitialized()) {
+            throw new Error('initFirebaseAdminTestEnvironment() (in @dereekb/firebase-server package) was not called before using adminFirebaseTestBuilder().');
+        }
+        if (config.useFunctionSingletonContext) {
+            if (!functionsInitialized) {
+                throw new Error('Call setupFirebaseAdminFunctionTestSingleton() (in @dereekb/firebase-server package) if using functions in a singleton context (useFunctionSingletonContext = true/undefined).');
+            }
+        }
+        else if (config.useFunctionSingletonContext === false) {
+            firebaseFunctionsTestInstance = rerollFirebaseAdminFunctionTestSingleton();
+        }
+        const projectId = getGCloudTestProjectId();
+        const storageBucket = 'b-' + projectId;
+        const app = admin.initializeApp({ projectId, storageBucket });
+        return new FirebaseAdminFunctionTestContextInstance(firebaseFunctionsTestInstance, app);
+    },
+    teardownInstance: async (instance, config) => {
+        if (config.useFunctionSingletonContext === false) {
+            try {
+                await instance.app.delete(); // will be called in cleanup
+                firebaseFunctionsTestInstance.cleanup();
+            }
+            catch (e) {
+                // do nothing
+            }
+            firebaseFunctionsTestInstance = undefined;
+        }
+    }
+});
+const firebaseAdminFunctionTestContextFactory = firebaseAdminFunctionTestBuilder({});
+
+class FirebaseAdminNestTestContextFixture extends test.AbstractChildTestContextFixture {
+    // MARK: Forwarded
+    get nest() {
+        return this.instance.nest;
+    }
+    get nestAppPromiseGetter() {
+        return this.instance.nestAppPromiseGetter;
+    }
+    get(typeOrToken, options) {
+        return this.instance.get(typeOrToken, options);
+    }
+}
+class FirebaseAdminNestTestContextInstance extends AbstractFirebaseAdminTestContextInstanceChild {
+    nest;
+    nestAppPromiseGetter = () => Promise.resolve(this.nest);
+    constructor(parent, nest) {
+        super(parent);
+        this.nest = nest;
+    }
+    get(typeOrToken, options) {
+        return options ? this.nest.get(typeOrToken, options) : this.nest.get(typeOrToken);
+    }
+}
+function firebaseAdminNestContextFixture(config, factory) {
+    return (buildTests) => {
+        factory((f) => firebaseAdminNestContextWithFixture(config, f, buildTests));
+    };
+}
+class FirebaseAdminNestRootModule {
+}
+function firebaseAdminNestContextWithFixture(config, f, buildTests) {
+    const { nestModules, makeProviders = () => [], forceStorageBucket = false, defaultStorageBucket: inputDefaultStorageBucket, envConfig, injectFirebaseServerAppTokenProvider, injectServerEnvServiceProvider, makeFixture = (parent) => new FirebaseAdminNestTestContextFixture(parent), makeInstance = (instance, nest) => new FirebaseAdminNestTestContextInstance(instance, nest), initInstance } = config;
+    test.useTestContextFixture({
+        fixture: makeFixture(f),
+        /**
+         * Build tests by passing the fixture to the testing functions.
+         *
+         * This will inject all tests and sub Jest lifecycle items.
+         */
+        buildTests,
+        initInstance: async () => {
+            const imports = util.asArray(nestModules);
+            const providers = makeProviders(f.instance) ?? [];
+            const defaultStorageBucket = inputDefaultStorageBucket ?? f.instance.app.options.storageBucket;
+            // Inject the serverEnvTokenProvider and optionally the FirebaseServerEnvService
+            if (injectServerEnvServiceProvider !== false || envConfig != null) {
+                providers.push(nestjs.serverEnvTokenProvider(envConfig || { production: false }));
+                if (injectServerEnvServiceProvider !== false) {
+                    providers.push({
+                        provide: firebaseServer.FirebaseServerEnvService,
+                        useClass: firebaseServer.DefaultFirebaseServerEnvService
+                    }, {
+                        provide: nestjs.ServerEnvironmentService,
+                        useExisting: firebaseServer.FirebaseServerEnvService
+                    });
+                }
+            }
+            // Inject the firebaseServerAppTokenProvider
+            if (injectFirebaseServerAppTokenProvider) {
+                providers.push(firebaseServer.firebaseServerAppTokenProvider(util.asGetter(f.instance.app)));
+            }
+            if (defaultStorageBucket) {
+                providers.push(firebaseServer.firebaseServerStorageDefaultBucketIdTokenProvider({
+                    defaultBucketId: defaultStorageBucket,
+                    forceBucket: forceStorageBucket
+                }));
+            }
+            const rootModule = {
+                module: FirebaseAdminNestRootModule,
+                providers,
+                exports: providers,
+                global: true
+            };
+            const builder = testing.Test.createTestingModule({
+                imports: [rootModule, ...imports]
+            });
+            const nest = await builder.compile();
+            const instance = makeInstance(f.instance, nest);
+            if (initInstance) {
+                await initInstance(instance);
+            }
+            return instance;
+        },
+        destroyInstance: async (instance) => {
+            await instance.nest.close();
+        }
+    });
+}
+function firebaseAdminNestContextFactory(config) {
+    return firebaseAdminNestContextFixture(config, firebaseAdminTestContextFactory);
+}
+
+function wrapCloudFunctionForNestTestsGetter(wrapper, fn) {
+    return wrapCloudFunctionV1ForTests(wrapper.fnWrapper, () => fn(wrapper.nestAppPromiseGetter));
+}
+function wrapCallableRequestForNestTestsGetter(wrapper, fn) {
+    return wrapCallableRequestForTests(wrapper.fnWrapper, () => fn(wrapper.nestAppPromiseGetter));
+}
+class FirebaseAdminFunctionNestTestContextFixture extends FirebaseAdminNestTestContextFixture {
+    // MARK: FirebaseAdminTestContext (Forwarded)
+    wrapCloudFunctionForNestTests(fn) {
+        return this.wrapCloudFunctionForNestTestsGetter(fn)();
+    }
+    wrapCloudFunctionForNestTestsGetter(fn) {
+        return wrapCloudFunctionForNestTestsGetter(this, fn);
+    }
+    wrapCallableRequestForNestTests(fn) {
+        return this.wrapCallableRequestForNestTestsGetter(fn)();
+    }
+    wrapCallableRequestForNestTestsGetter(fn) {
+        return wrapCallableRequestForNestTestsGetter(this, fn);
+    }
+    // MARK: FirebaseAdminCloudFunctionWrapperSource
+    get fnWrapper() {
+        return this.parent.instance.fnWrapper;
+    }
+}
+class FirebaseAdminFunctionNestTestContextInstance extends FirebaseAdminNestTestContextInstance {
+    // MARK: FirebaseAdminTestContext (Forwarded)
+    get fnWrapper() {
+        return this.parent.fnWrapper;
+    }
+}
+function firebaseAdminFunctionNestContextFixture(config, factory) {
+    return (buildTests) => {
+        factory((f) => firebaseAdminFunctionNestContextWithFixture(config, f, buildTests));
+    };
+}
+class FirebaseAdminFunctionNestRootModule {
+}
+function firebaseAdminFunctionNestContextWithFixture(config, f, buildTests) {
+    const mergedConfig = {
+        makeFixture: (parent) => new FirebaseAdminFunctionNestTestContextFixture(parent),
+        makeInstance: (instance, nest) => new FirebaseAdminFunctionNestTestContextInstance(instance, nest),
+        ...config
+    };
+    return firebaseAdminNestContextWithFixture(mergedConfig, f, buildTests);
+}
+function firebaseAdminFunctionNestContextFactory(config) {
+    return firebaseAdminFunctionNestContextFixture(config, firebaseAdminFunctionTestContextFactory);
+}
+
+const CallableRequestTestMultipleFixtureSuffix = 'WrappedFn';
+function isCallableRequestTestSingleConfig(config) {
+    const isSingle = Boolean(config.fn);
+    return isSingle;
+}
+function callableRequestTest(config, buildTests) {
+    if (isCallableRequestTestSingleConfig(config)) {
+        const { f, fn } = config;
+        test.useTestFunctionFixture({
+            fn: () => {
+                const x = wrapCallableRequestForNestTestsGetter(f, fn)();
+                return x;
+            }
+        }, buildTests);
+    }
+    else {
+        const { f, fns: inputFns } = config;
+        const mappedFns = util.mapObjectMap(inputFns, (fn) => () => wrapCallableRequestForNestTestsGetter(f, fn)());
+        const fns = {};
+        Object.keys(mappedFns).forEach((key) => {
+            fns[`${key}${CallableRequestTestMultipleFixtureSuffix}`] = mappedFns[key];
+        });
+        test.useTestFunctionMapFixture({
+            fns
+        }, buildTests);
+    }
+}
+function describeCallableRequestTest(label, config, buildTests) {
+    describe(label, () => {
+        callableRequestTest(config, buildTests);
+    });
+}
+
+function isCloudFunctionTestSingleConfig(config) {
+    const isSingle = Boolean(config.fn);
+    return isSingle;
+}
+function cloudFunctionTest(config, buildTests) {
+    if (isCloudFunctionTestSingleConfig(config)) {
+        const { f, fn } = config;
+        test.useTestFunctionFixture({
+            fn: () => {
+                const x = wrapCloudFunctionForNestTestsGetter(f, fn)();
+                return x;
+            }
+        }, buildTests);
+    }
+    else {
+        const { f, fns: inputFns } = config;
+        const mappedFns = util.mapObjectMap(inputFns, (fn) => () => wrapCloudFunctionForNestTestsGetter(f, fn)());
+        const fns = {};
+        Object.keys(mappedFns).forEach((key) => {
+            fns[`${key}CloudFn`] = mappedFns[key];
+        });
+        test.useTestFunctionMapFixture({
+            fns
+        }, buildTests);
+    }
+}
+function describeCloudFunctionTest(label, config, buildTests) {
+    describe(label, () => {
+        cloudFunctionTest(config, buildTests);
+    });
+}
+
+function initFirebaseServerAdminTestEnvironment() {
+    initFirebaseAdminTestEnvironment({
+        emulators: {
+            auth: '0.0.0.0:9903',
+            firestore: '0.0.0.0:9904',
+            storage: '0.0.0.0:9906'
+        }
+    });
+}
+function describeFirestoreTest(s) {
+    let collection;
+    beforeEach(() => {
+        collection = test$1.mockItemFirestoreCollection(s.firestoreContext);
+    });
+    describe('firestore', () => {
+        it('should interact with the firestore.', async () => {
+            const document = collection.documentAccessor().newDocument();
+            const setData = {
+                value: 'a',
+                test: true
+            };
+            await document.accessor.set(setData);
+            const exists = await document.accessor.exists();
+            expect(exists).toBe(true);
+            const snapshot = await document.accessor.get();
+            const data = snapshot.data();
+            expect(data).toBeDefined();
+        });
+    });
+}
+
+/**
+ * Error thrown when the error type was different than the expected type.
+ */
+class ExpectedHttpErrorWithSpecificServerErrorCode extends makeError.BaseError {
+    httpError;
+    expectedErrorCode;
+    constructor(httpError, expectedErrorCode) {
+        const { code } = httpError.details;
+        super(`Expected HttpError with an error code of "${expectedErrorCode}", but recieved "${code}" instead.`);
+        this.httpError = httpError;
+        this.expectedErrorCode = expectedErrorCode;
+    }
+}
+/**
+ * Creates a ExpectFailAssertionFunction that asserts the encountered error is of the expected type using the instanceof keyword.
+ *
+ * Throws a ExpectedErrorOfSpecificTypeError if the input is not a HttpsError.
+ * Throws a ExpectedHttpErrorWithSpecificServerErrorCode if the input's server error data has a different error code.
+ *
+ * @param expectedType
+ * @returns
+ */
+function expectFailAssertHttpErrorServerErrorCode(expectedCode) {
+    return (error) => {
+        if (error instanceof https.HttpsError) {
+            const { code } = error.details;
+            if (code !== expectedCode) {
+                throw new ExpectedHttpErrorWithSpecificServerErrorCode(error, expectedCode);
+            }
+        }
+        else {
+            throw new test.ExpectedErrorOfSpecificTypeError(error, https.HttpsError);
+        }
+        return true;
+    };
+}
+// MARK: Compat
+/**
+ * @deprecated Use ExpectedHttpErrorWithSpecificServerErrorCode from shared instead. This is kept for backwards compatibility.
+ */
+class JestExpectedHttpErrorWithSpecificServerErrorCode extends ExpectedHttpErrorWithSpecificServerErrorCode {
+}
+/**
+ * @deprecated Use expectFailAssertHttpErrorServerErrorCode from shared instead. This is kept for backwards compatibility.
+ */
+const jestExpectFailAssertHttpErrorServerErrorCode = expectFailAssertHttpErrorServerErrorCode;
+
+/**
+ * Default firestore admin factory.
+ *
+ * Host of localhost, port 9904
+ */
+const adminFirestoreFactory = googleCloudTestFirestoreBuilder({
+    host: 'localhost',
+    port: 9904
+});
+/**
+ * Convenience mock instance for tests within an authorized context.
+ *
+ * Uses @google-cloud/firestore
+ */
+const dbxComponentsAdminTestWithMockItemCollection = test$1.testWithMockItemCollectionFixture()(adminFirestoreFactory);
+
+/**
+ * Default firestore admin factory.
+ *
+ * Host of localhost, port 9906
+ */
+const adminFirebaseStorageFactory = googleCloudTestFirebaseStorageBuilder({
+    host: '0.0.0.0',
+    port: 9906
+});
+/**
+ * Convenience mock instance for tests within an authorized context.
+ *
+ * Uses @google-cloud/firestore
+ */
+const dbxComponentsAdminTestWithMockItemStorage = test$1.testWithMockItemStorageFixture()(adminFirebaseStorageFactory);
+
+exports.AUTHORIZED_USER_RANDOM_EMAIL_FACTORY = AUTHORIZED_USER_RANDOM_EMAIL_FACTORY;
+exports.AUTHORIZED_USER_RANDOM_PHONE_NUMBER_FACTORY = AUTHORIZED_USER_RANDOM_PHONE_NUMBER_FACTORY;
+exports.AbstractFirebaseAdminTestContextInstanceChild = AbstractFirebaseAdminTestContextInstanceChild;
+exports.AuthorizedUserTestContextFixture = AuthorizedUserTestContextFixture;
+exports.AuthorizedUserTestContextInstance = AuthorizedUserTestContextInstance;
+exports.CallableRequestTestMultipleFixtureSuffix = CallableRequestTestMultipleFixtureSuffix;
+exports.ExpectedHttpErrorWithSpecificServerErrorCode = ExpectedHttpErrorWithSpecificServerErrorCode;
+exports.FirebaseAdminFunctionNestRootModule = FirebaseAdminFunctionNestRootModule;
+exports.FirebaseAdminFunctionNestTestContextFixture = FirebaseAdminFunctionNestTestContextFixture;
+exports.FirebaseAdminFunctionNestTestContextInstance = FirebaseAdminFunctionNestTestContextInstance;
+exports.FirebaseAdminFunctionTestContextFixture = FirebaseAdminFunctionTestContextFixture;
+exports.FirebaseAdminFunctionTestContextInstance = FirebaseAdminFunctionTestContextInstance;
+exports.FirebaseAdminNestRootModule = FirebaseAdminNestRootModule;
+exports.FirebaseAdminNestTestContextFixture = FirebaseAdminNestTestContextFixture;
+exports.FirebaseAdminNestTestContextInstance = FirebaseAdminNestTestContextInstance;
+exports.FirebaseAdminTestContextFixture = FirebaseAdminTestContextFixture;
+exports.FirebaseAdminTestContextInstance = FirebaseAdminTestContextInstance;
+exports.GoogleCloudTestFirebaseStorageContextFixture = GoogleCloudTestFirebaseStorageContextFixture;
+exports.GoogleCloudTestFirebaseStorageInstance = GoogleCloudTestFirebaseStorageInstance;
+exports.GoogleCloudTestFirestoreContextFixture = GoogleCloudTestFirestoreContextFixture;
+exports.GoogleCloudTestFirestoreInstance = GoogleCloudTestFirestoreInstance;
+exports.JestExpectedHttpErrorWithSpecificServerErrorCode = JestExpectedHttpErrorWithSpecificServerErrorCode;
+exports.ModelTestContextFixture = ModelTestContextFixture;
+exports.ModelTestContextInstance = ModelTestContextInstance;
+exports.adminFirebaseStorageFactory = adminFirebaseStorageFactory;
+exports.adminFirestoreFactory = adminFirestoreFactory;
+exports.applyFirebaseGCloudTestProjectIdToFirebaseConfigEnv = applyFirebaseGCloudTestProjectIdToFirebaseConfigEnv;
+exports.authorizedUserContext = authorizedUserContext;
+exports.authorizedUserContextFactory = authorizedUserContextFactory;
+exports.callableRequestTest = callableRequestTest;
+exports.cloudFunctionTest = cloudFunctionTest;
+exports.createEncodedTestFirestoreTokenForUserRecord = createEncodedTestFirestoreTokenForUserRecord;
+exports.createTestFirestoreTokenForUserRecord = createTestFirestoreTokenForUserRecord;
+exports.createTestFunctionContextAuthData = createTestFunctionContextAuthData;
+exports.createTestFunctionContextOptions = createTestFunctionContextOptions;
+exports.dbxComponentsAdminTestWithMockItemCollection = dbxComponentsAdminTestWithMockItemCollection;
+exports.dbxComponentsAdminTestWithMockItemStorage = dbxComponentsAdminTestWithMockItemStorage;
+exports.decodeEncodedCreateCustomTokenResult = decodeEncodedCreateCustomTokenResult;
+exports.describeCallableRequestTest = describeCallableRequestTest;
+exports.describeCloudFunctionTest = describeCloudFunctionTest;
+exports.describeFirestoreTest = describeFirestoreTest;
+exports.expectFailAssertHttpErrorServerErrorCode = expectFailAssertHttpErrorServerErrorCode;
+exports.firebaseAdminFirestoreContextFixture = firebaseAdminFirestoreContextFixture;
+exports.firebaseAdminFirestoreContextWithFixture = firebaseAdminFirestoreContextWithFixture;
+exports.firebaseAdminFunctionNestContextFactory = firebaseAdminFunctionNestContextFactory;
+exports.firebaseAdminFunctionNestContextFixture = firebaseAdminFunctionNestContextFixture;
+exports.firebaseAdminFunctionNestContextWithFixture = firebaseAdminFunctionNestContextWithFixture;
+exports.firebaseAdminFunctionTestBuilder = firebaseAdminFunctionTestBuilder;
+exports.firebaseAdminFunctionTestContextFactory = firebaseAdminFunctionTestContextFactory;
+exports.firebaseAdminNestContextFactory = firebaseAdminNestContextFactory;
+exports.firebaseAdminNestContextFixture = firebaseAdminNestContextFixture;
+exports.firebaseAdminNestContextWithFixture = firebaseAdminNestContextWithFixture;
+exports.firebaseAdminTestBuilder = firebaseAdminTestBuilder;
+exports.firebaseAdminTestContextFactory = firebaseAdminTestContextFactory;
+exports.generateNewProjectId = generateNewProjectId;
+exports.getGCloudProjectId = getGCloudProjectId;
+exports.getGCloudTestProjectId = getGCloudTestProjectId;
+exports.googleCloudTestFirebaseStorageBuilder = googleCloudTestFirebaseStorageBuilder;
+exports.googleCloudTestFirestoreBuilder = googleCloudTestFirestoreBuilder;
+exports.initFirebaseAdminTestEnvironment = initFirebaseAdminTestEnvironment;
+exports.initFirebaseServerAdminTestEnvironment = initFirebaseServerAdminTestEnvironment;
+exports.isAdminEnvironmentInitialized = isAdminEnvironmentInitialized;
+exports.isCallableRequestTestSingleConfig = isCallableRequestTestSingleConfig;
+exports.isCloudFunctionTestSingleConfig = isCloudFunctionTestSingleConfig;
+exports.jestExpectFailAssertHttpErrorServerErrorCode = jestExpectFailAssertHttpErrorServerErrorCode;
+exports.makeGoogleFirebaseStorageContext = makeGoogleFirebaseStorageContext;
+exports.makeGoogleFirestoreContext = makeGoogleFirestoreContext;
+exports.modelTestContextFactory = modelTestContextFactory;
+exports.rerollFirebaseAdminFunctionTestSingleton = rerollFirebaseAdminFunctionTestSingleton;
+exports.rollNewGCloudProjectEnvironmentVariable = rollNewGCloudProjectEnvironmentVariable;
+exports.setDefaultFirebaseAdminFunctionTestUseFunctionSingleton = setDefaultFirebaseAdminFunctionTestUseFunctionSingleton;
+exports.setupFirebaseAdminFunctionTestSingleton = setupFirebaseAdminFunctionTestSingleton;
+exports.testFirestoreClaimsFromUserRecord = testFirestoreClaimsFromUserRecord;
+exports.testUidFactory = testUidFactory;
+exports.wrapCallableRequestForNestTestsGetter = wrapCallableRequestForNestTestsGetter;
+exports.wrapCloudFunctionForNestTestsGetter = wrapCloudFunctionForNestTestsGetter;