@firebase/rules-unit-testing 1.3.15-canary.cdada6c68 → 1.3.16-2022028193537

package/dist/index.cjs.js

@@ -2,16 +2,39 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var fetch = require('node-fetch');
-var firebase = require('firebase/compat/app');
-require('firebase/firestore/compat');
-require('firebase/database/compat');
-require('firebase/storage/compat');
+var firebase = require('firebase');
+require('firebase/database');
+require('firebase/firestore');
+require('firebase/storage');
+var request = require('request');
+var logger = require('@firebase/logger');
+var component = require('@firebase/component');
+var util = require('@firebase/util');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
-var fetch__default = /*#__PURE__*/_interopDefaultLegacy(fetch);
+function _interopNamespace(e) {
+    if (e && e.__esModule) return e;
+    var n = Object.create(null);
+    if (e) {
+        Object.keys(e).forEach(function (k) {
+            if (k !== 'default') {
+                var d = Object.getOwnPropertyDescriptor(e, k);
+                Object.defineProperty(n, k, d.get ? d : {
+                    enumerable: true,
+                    get: function () {
+                        return e[k];
+                    }
+                });
+            }
+        });
+    }
+    n['default'] = e;
+    return Object.freeze(n);
+}
+
 var firebase__default = /*#__PURE__*/_interopDefaultLegacy(firebase);
+var request__namespace = /*#__PURE__*/_interopNamespace(request);
 
 /*! *****************************************************************************
 Copyright (c) Microsoft Corporation.
@@ -79,7 +102,7 @@ function __generator(thisArg, body) {
 
 /**
  * @license
- * Copyright 2021 Google LLC
+ * Copyright 2018 Google LLC
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -93,643 +116,461 @@ function __generator(thisArg, body) {
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-/**
- * Return a connectable hostname, replacing wildcard 0.0.0.0 or :: with loopback
- * addresses 127.0.0.1 / ::1 correspondingly. See below for why this is needed:
- * https://github.com/firebase/firebase-tools-ui/issues/286
- *
- * This assumes emulators are running on the same device as fallbackHost (e.g.
- * hub), which should hold if both are started from the same CLI command.
- * @private
- */
-function fixHostname(host, fallbackHost) {
-    host = host.replace('[', '').replace(']', ''); // Remove IPv6 brackets
-    if (host === '0.0.0.0') {
-        host = fallbackHost || '127.0.0.1';
+var firestore = firebase__default['default'].firestore, database = firebase__default['default'].database; firebase__default['default'].storage;
+/** If this environment variable is set, use it for the database emulator's address. */
+var DATABASE_ADDRESS_ENV = 'FIREBASE_DATABASE_EMULATOR_HOST';
+/** The default address for the local database emulator. */
+var DATABASE_ADDRESS_DEFAULT = 'localhost:9000';
+/** If this environment variable is set, use it for the Firestore emulator. */
+var FIRESTORE_ADDRESS_ENV = 'FIRESTORE_EMULATOR_HOST';
+/** The default address for the local Firestore emulator. */
+var FIRESTORE_ADDRESS_DEFAULT = 'localhost:8080';
+/** If this environment variable is set, use it for the Storage emulator. */
+var FIREBASE_STORAGE_ADDRESS_ENV = 'FIREBASE_STORAGE_EMULATOR_HOST';
+var CLOUD_STORAGE_ADDRESS_ENV = 'STORAGE_EMULATOR_HOST';
+/** The default address for the local Firestore emulator. */
+var STORAGE_ADDRESS_DEFAULT = 'localhost:9199';
+/** Environment variable to locate the Emulator Hub */
+var HUB_HOST_ENV = 'FIREBASE_EMULATOR_HUB';
+/** The default address for the Emulator Hub */
+var HUB_HOST_DEFAULT = 'localhost:4400';
+/** The actual address for the database emulator */
+var _databaseHost = undefined;
+/** The actual address for the Firestore emulator */
+var _firestoreHost = undefined;
+/** The actual address for the Storage emulator */
+var _storageHost = undefined;
+/** The actual address for the Emulator Hub */
+var _hubHost = undefined;
+function trimmedBase64Encode(val) {
+    // Use base64url encoding and remove padding in the end (dot characters).
+    return util.base64Encode(val).replace(/\./g, "");
+}
+function createUnsecuredJwt(token, projectId) {
+    // Unsecured JWTs use "none" as the algorithm.
+    var header = {
+        alg: 'none',
+        kid: 'fakekid',
+        type: 'JWT'
+    };
+    var project = projectId || 'fake-project';
+    var iat = token.iat || 0;
+    var uid = token.sub || token.uid || token.user_id;
+    if (!uid) {
+        throw new Error("Auth must contain 'sub', 'uid', or 'user_id' field!");
     }
-    else if (host === '::') {
-        host = fallbackHost || '::1';
+    var payload = __assign({ 
+        // Set all required fields to decent defaults
+        iss: "https://securetoken.google.com/" + project, aud: project, iat: iat, exp: iat + 3600, auth_time: iat, sub: uid, user_id: uid, firebase: {
+            sign_in_provider: 'custom',
+            identities: {}
+        } }, token);
+    // Remove the uid option since it's not actually part of the token spec.
+    if (payload.uid) {
+        delete payload.uid;
     }
-    return host;
+    // Unsecured JWTs use the empty string as a signature.
+    var signature = '';
+    return [
+        trimmedBase64Encode(JSON.stringify(header)),
+        trimmedBase64Encode(JSON.stringify(payload)),
+        signature
+    ].join('.');
 }
-/**
- * Create a URL with host, port, and path. Handles IPv6 bracketing correctly.
- * @private
- */
-function makeUrl(hostAndPort, path) {
-    if (typeof hostAndPort === 'object') {
-        var host = hostAndPort.host, port = hostAndPort.port;
-        if (host.includes(':')) {
-            hostAndPort = "[" + host + "]:" + port;
-        }
-        else {
-            hostAndPort = host + ":" + port;
-        }
+function apps() {
+    return firebase__default['default'].apps;
+}
+/** Construct an App authenticated with options.auth. */
+function initializeTestApp(options) {
+    var jwt = options.auth
+        ? createUnsecuredJwt(options.auth, options.projectId)
+        : undefined;
+    return initializeApp(jwt, options.databaseName, options.projectId, options.storageBucket);
+}
+/** Construct an App authenticated as an admin user. */
+function initializeAdminApp(options) {
+    var admin = require('firebase-admin');
+    var app = admin.initializeApp(getAppOptions(options.databaseName, options.projectId, options.storageBucket), getRandomAppName());
+    if (options.projectId) {
+        app.firestore().settings({
+            host: getFirestoreHost(),
+            ssl: false
+        });
     }
-    var url = new URL("http://" + hostAndPort + "/");
-    url.pathname = path;
-    return url;
-}
-
+    return app;
+}
 /**
- * @license
- * Copyright 2021 Google LLC
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
+ * Set the host and port configuration for applicable emulators. This will override any values
+ * found in environment variables. Must be called before initializeAdminApp or initializeTestApp.
  *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
+ * @param options options object.
  */
+function useEmulators(options) {
+    if (!(options.database || options.firestore || options.storage || options.hub)) {
+        throw new Error("Argument to useEmulators must contain at least one of 'database', 'firestore', 'storage', or 'hub'.");
+    }
+    if (options.database) {
+        _databaseHost = getAddress(options.database.host, options.database.port);
+    }
+    if (options.firestore) {
+        _firestoreHost = getAddress(options.firestore.host, options.firestore.port);
+    }
+    if (options.storage) {
+        _storageHost = getAddress(options.storage.host, options.storage.port);
+    }
+    if (options.hub) {
+        _hubHost = getAddress(options.hub.host, options.hub.port);
+    }
+}
 /**
- * Use the Firebase Emulator hub to discover other running emulators.
+ * Use the Firebase Emulator hub to discover other running emulators. Call useEmulators() with
+ * the result to configure the library to use the discovered emulators.
  *
- * @param hub the host and port where the Emulator Hub is running
- * @private
+ * @param hubHost the host where the Emulator Hub is running (ex: 'localhost')
+ * @param hubPort the port where the Emulator Hub is running (ex: 4400)
  */
-function discoverEmulators(hub, fetch) {
-    if (fetch === void 0) { fetch = fetch__default['default']; }
+function discoverEmulators(hubHost, hubPort) {
     return __awaiter(this, void 0, void 0, function () {
-        var res, emulators, data;
+        var hubAddress, res, options, data;
         return __generator(this, function (_a) {
             switch (_a.label) {
-                case 0: return [4 /*yield*/, fetch(makeUrl(hub, '/emulators'))];
+                case 0:
+                    if ((hubHost && !hubPort) || (!hubHost && hubPort)) {
+                        throw new Error("Invalid configuration hubHost=" + hubHost + " and hubPort=" + hubPort + ". If either parameter is supplied, both must be defined.");
+                    }
+                    hubAddress = hubHost && hubPort ? getAddress(hubHost, hubPort) : getHubHost();
+                    return [4 /*yield*/, requestPromise(request__namespace.get, {
+                            method: 'GET',
+                            uri: "http://" + hubAddress + "/emulators"
+                        })];
                 case 1:
                     res = _a.sent();
-                    if (!res.ok) {
-                        throw new Error("HTTP Error " + res.status + " when attempting to reach Emulator Hub at " + res.url + ", are you sure it is running?");
+                    if (res.statusCode !== 200) {
+                        throw new Error("HTTP Error " + res.statusCode + " when attempting to reach Emulator Hub at " + hubAddress + ", are you sure it is running?");
                     }
-                    emulators = {};
-                    return [4 /*yield*/, res.json()];
-                case 2:
-                    data = _a.sent();
+                    options = {};
+                    data = JSON.parse(res.body);
                     if (data.database) {
-                        emulators.database = {
+                        options.database = {
                             host: data.database.host,
                             port: data.database.port
                         };
                     }
                     if (data.firestore) {
-                        emulators.firestore = {
+                        options.firestore = {
                             host: data.firestore.host,
                             port: data.firestore.port
                         };
                     }
                     if (data.storage) {
-                        emulators.storage = {
+                        options.storage = {
                             host: data.storage.host,
                             port: data.storage.port
                         };
                     }
                     if (data.hub) {
-                        emulators.hub = {
+                        options.hub = {
                             host: data.hub.host,
                             port: data.hub.port
                         };
                     }
-                    return [2 /*return*/, emulators];
+                    return [2 /*return*/, options];
             }
         });
     });
 }
-/**
- * @private
- */
-function getEmulatorHostAndPort(emulator, conf, discovered) {
-    var _a, _b;
-    if (conf && ('host' in conf || 'port' in conf)) {
-        var host = conf.host, port = conf.port;
-        if (host || port) {
-            if (!host || !port) {
-                throw new Error("Invalid configuration " + emulator + ".host=" + host + " and " + emulator + ".port=" + port + ". " +
-                    'If either parameter is supplied, both must be defined.');
-            }
-            if (discovered && !discovered[emulator]) {
-                console.warn("Warning: config for the " + emulator + " emulator is specified, but the Emulator hub " +
-                    'reports it as not running. This may lead to errors such as connection refused.');
-            }
-            return {
-                host: fixHostname(conf.host, (_a = discovered === null || discovered === void 0 ? void 0 : discovered.hub) === null || _a === void 0 ? void 0 : _a.host),
-                port: conf.port
-            };
-        }
+function getAddress(host, port) {
+    if (host.includes('::')) {
+        return "[" + host + "]:" + port;
     }
-    var envVar = EMULATOR_HOST_ENV_VARS[emulator];
-    var fallback = (discovered === null || discovered === void 0 ? void 0 : discovered[emulator]) || emulatorFromEnvVar(envVar);
-    if (fallback) {
-        if (discovered && !discovered[emulator]) {
-            console.warn("Warning: the environment variable " + envVar + " is set, but the Emulator hub reports the " +
-                (emulator + " emulator as not running. This may lead to errors such as connection refused."));
-        }
-        return {
-            host: fixHostname(fallback.host, (_b = discovered === null || discovered === void 0 ? void 0 : discovered.hub) === null || _b === void 0 ? void 0 : _b.host),
-            port: fallback.port
-        };
+    else {
+        return host + ":" + port;
     }
 }
-// Visible for testing.
-var EMULATOR_HOST_ENV_VARS = {
-    'database': 'FIREBASE_DATABASE_EMULATOR_HOST',
-    'firestore': 'FIRESTORE_EMULATOR_HOST',
-    'hub': 'FIREBASE_EMULATOR_HUB',
-    'storage': 'FIREBASE_STORAGE_EMULATOR_HOST'
-};
-function emulatorFromEnvVar(envVar) {
-    var hostAndPort = process.env[envVar];
-    if (!hostAndPort) {
-        return undefined;
-    }
-    var parsed;
-    try {
-        parsed = new URL("http://" + hostAndPort);
-    }
-    catch (_a) {
-        throw new Error("Invalid format in environment variable " + envVar + "=" + hostAndPort + " (expected host:port)");
-    }
-    var host = parsed.hostname;
-    var port = Number(parsed.port || '80');
-    if (!Number.isInteger(port)) {
-        throw new Error("Invalid port in environment variable " + envVar + "=" + hostAndPort);
-    }
-    return { host: host, port: port };
-}
-
-/**
- * @license
- * Copyright 2021 Google LLC
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-/**
- * An implementation of {@code RulesTestEnvironment}. This is private to hide the constructor,
- * which should never be directly called by the developer.
- * @private
- */
-var RulesTestEnvironmentImpl = /** @class */ (function () {
-    function RulesTestEnvironmentImpl(projectId, emulators) {
-        this.projectId = projectId;
-        this.emulators = emulators;
-        this.contexts = new Set();
-        this.destroyed = false;
-    }
-    RulesTestEnvironmentImpl.prototype.authenticatedContext = function (user_id, tokenOptions) {
-        this.checkNotDestroyed();
-        return this.createContext(__assign(__assign({}, tokenOptions), { sub: user_id, user_id: user_id }));
-    };
-    RulesTestEnvironmentImpl.prototype.unauthenticatedContext = function () {
-        this.checkNotDestroyed();
-        return this.createContext(/* authToken = */ undefined);
-    };
-    RulesTestEnvironmentImpl.prototype.withSecurityRulesDisabled = function (callback) {
-        return __awaiter(this, void 0, void 0, function () {
-            var context;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        this.checkNotDestroyed();
-                        context = this.createContext('owner');
-                        _a.label = 1;
-                    case 1:
-                        _a.trys.push([1, , 3, 4]);
-                        return [4 /*yield*/, callback(context)];
-                    case 2:
-                        _a.sent();
-                        return [3 /*break*/, 4];
-                    case 3:
-                        // We eagarly clean up this context to actively prevent misuse outside of the callback, e.g.
-                        // storing the context in a variable.
-                        context.cleanup();
-                        this.contexts.delete(context);
-                        return [7 /*endfinally*/];
-                    case 4: return [2 /*return*/];
-                }
-            });
-        });
-    };
-    RulesTestEnvironmentImpl.prototype.createContext = function (authToken) {
-        var context = new RulesTestContextImpl(this.projectId, this.emulators, authToken);
-        this.contexts.add(context);
-        return context;
-    };
-    RulesTestEnvironmentImpl.prototype.clearDatabase = function () {
-        this.checkNotDestroyed();
-        return this.withSecurityRulesDisabled(function (context) {
-            return context.database().ref('/').set(null);
-        });
-    };
-    RulesTestEnvironmentImpl.prototype.clearFirestore = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            var resp, _a;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        this.checkNotDestroyed();
-                        assertEmulatorRunning(this.emulators, 'firestore');
-                        return [4 /*yield*/, fetch__default['default'](makeUrl(this.emulators.firestore, "/emulator/v1/projects/" + this.projectId + "/databases/(default)/documents"), {
-                                method: 'DELETE'
-                            })];
-                    case 1:
-                        resp = _b.sent();
-                        if (!!resp.ok) return [3 /*break*/, 3];
-                        _a = Error.bind;
-                        return [4 /*yield*/, resp.text()];
-                    case 2: throw new (_a.apply(Error, [void 0, _b.sent()]))();
-                    case 3: return [2 /*return*/];
-                }
-            });
-        });
-    };
-    RulesTestEnvironmentImpl.prototype.clearStorage = function () {
-        var _this = this;
-        this.checkNotDestroyed();
-        return this.withSecurityRulesDisabled(function (context) { return __awaiter(_this, void 0, void 0, function () {
-            var items;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, context.storage().ref().listAll()];
-                    case 1:
-                        items = (_a.sent()).items;
-                        return [4 /*yield*/, Promise.all(items.map(function (item) {
-                                return item.delete();
-                            }))];
-                    case 2:
-                        _a.sent();
-                        return [2 /*return*/];
-                }
-            });
-        }); });
-    };
-    RulesTestEnvironmentImpl.prototype.cleanup = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                this.destroyed = true;
-                this.contexts.forEach(function (context) {
-                    context.envDestroyed = true;
-                    context.cleanup();
-                });
-                this.contexts.clear();
-                return [2 /*return*/];
-            });
-        });
-    };
-    RulesTestEnvironmentImpl.prototype.checkNotDestroyed = function () {
-        if (this.destroyed) {
-            throw new Error('This RulesTestEnvironment has already been cleaned up. ' +
-                '(This may indicate a leak or missing `await` in your test cases. If you do intend to ' +
-                'perform more tests, please call cleanup() later or create another RulesTestEnvironment.)');
+function getDatabaseHost() {
+    if (!_databaseHost) {
+        var fromEnv = process.env[DATABASE_ADDRESS_ENV];
+        if (fromEnv) {
+            _databaseHost = fromEnv;
+        }
+        else {
+            console.warn("Warning: " + DATABASE_ADDRESS_ENV + " not set, using default value " + DATABASE_ADDRESS_DEFAULT);
+            _databaseHost = DATABASE_ADDRESS_DEFAULT;
         }
-    };
-    return RulesTestEnvironmentImpl;
-}());
-/**
- * An implementation of {@code RulesTestContext}. This is private to hide the constructor,
- * which should never be directly called by the developer.
- * @private
- */
-var RulesTestContextImpl = /** @class */ (function () {
-    function RulesTestContextImpl(projectId, emulators, authToken) {
-        this.projectId = projectId;
-        this.emulators = emulators;
-        this.authToken = authToken;
-        this.destroyed = false;
-        this.envDestroyed = false;
     }
-    RulesTestContextImpl.prototype.cleanup = function () {
-        var _a;
-        this.destroyed = true;
-        (_a = this.app) === null || _a === void 0 ? void 0 : _a.delete();
-        this.app = undefined;
-    };
-    RulesTestContextImpl.prototype.firestore = function (settings) {
-        assertEmulatorRunning(this.emulators, 'firestore');
-        var firestore = this.getApp().firestore();
-        if (settings) {
-            firestore.settings(settings);
+    return _databaseHost;
+}
+function getFirestoreHost() {
+    if (!_firestoreHost) {
+        var fromEnv = process.env[FIRESTORE_ADDRESS_ENV];
+        if (fromEnv) {
+            _firestoreHost = fromEnv;
         }
-        firestore.useEmulator(this.emulators.firestore.host, this.emulators.firestore.port, { mockUserToken: this.authToken });
-        return firestore;
-    };
-    RulesTestContextImpl.prototype.database = function (databaseURL) {
-        assertEmulatorRunning(this.emulators, 'database');
-        var database = this.getApp().database(databaseURL);
-        database.useEmulator(this.emulators.database.host, this.emulators.database.port, { mockUserToken: this.authToken });
-        return database;
-    };
-    RulesTestContextImpl.prototype.storage = function (bucketUrl) {
-        if (bucketUrl === void 0) { bucketUrl = "gs://" + this.projectId; }
-        assertEmulatorRunning(this.emulators, 'storage');
-        var storage = this.getApp().storage(bucketUrl);
-        storage.useEmulator(this.emulators.storage.host, this.emulators.storage.port, { mockUserToken: this.authToken });
-        return storage;
-    };
-    RulesTestContextImpl.prototype.getApp = function () {
-        if (this.envDestroyed) {
-            throw new Error('This RulesTestContext is no longer valid because its RulesTestEnvironment has been ' +
-                'cleaned up. (This may indicate a leak or missing `await` in your test cases.)');
+        else {
+            console.warn("Warning: " + FIRESTORE_ADDRESS_ENV + " not set, using default value " + FIRESTORE_ADDRESS_DEFAULT);
+            _firestoreHost = FIRESTORE_ADDRESS_DEFAULT;
         }
-        if (this.destroyed) {
-            throw new Error('This RulesTestContext is no longer valid. When using withSecurityRulesDisabled, ' +
-                'make sure to perform all operations on the context within the callback function and ' +
-                'return a Promise that resolves when the operations are done.');
+    }
+    return _firestoreHost;
+}
+function getStorageHost() {
+    if (!_storageHost) {
+        var fromEnv = process.env[FIREBASE_STORAGE_ADDRESS_ENV] ||
+            process.env[CLOUD_STORAGE_ADDRESS_ENV];
+        if (fromEnv) {
+            // The STORAGE_EMULATOR_HOST env var is an older Cloud Standard which includes http:// while
+            // the FIREBASE_STORAGE_EMULATOR_HOST is a newer variable supported beginning in the Admin
+            // SDK v9.7.0 which does not have the protocol.
+            _storageHost = fromEnv.replace('http://', '');
         }
-        if (!this.app) {
-            this.app = firebase__default['default'].initializeApp({ projectId: this.projectId }, "_Firebase_RulesUnitTesting_" + Date.now() + "_" + Math.random());
+        else {
+            console.warn("Warning: " + FIREBASE_STORAGE_ADDRESS_ENV + " not set, using default value " + STORAGE_ADDRESS_DEFAULT);
+            _storageHost = STORAGE_ADDRESS_DEFAULT;
         }
-        return this.app;
-    };
-    return RulesTestContextImpl;
-}());
-function assertEmulatorRunning(emulators, emulator) {
-    if (!emulators[emulator]) {
-        if (emulators.hub) {
-            throw new Error("The " + emulator + " emulator is not running (according to Emulator hub). To force " +
-                'connecting anyway, please specify its host and port in initializeTestEnvironment({...}).');
+    }
+    return _storageHost;
+}
+function getHubHost() {
+    if (!_hubHost) {
+        var fromEnv = process.env[HUB_HOST_ENV];
+        if (fromEnv) {
+            _hubHost = fromEnv;
         }
         else {
-            throw new Error("The host and port of the " + emulator + " emulator must be specified. (You may wrap the test " +
-                "script with `firebase emulators:exec './your-test-script'` to enable automatic " +
-                ("discovery, or specify manually via initializeTestEnvironment({" + emulator + ": {host, port}})."));
+            console.warn("Warning: " + HUB_HOST_ENV + " not set, using default value " + HUB_HOST_DEFAULT);
+            _hubHost = HUB_HOST_DEFAULT;
         }
     }
-}
-
-/**
- * @license
- * Copyright 2021 Google LLC
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-/**
- * @private
- */
-function loadDatabaseRules(hostAndPort, databaseName, rules) {
+    return _hubHost;
+}
+function parseHost(host) {
+    var withProtocol = host.startsWith('http') ? host : "http://" + host;
+    var u = new URL(withProtocol);
+    return {
+        hostname: u.hostname,
+        port: Number.parseInt(u.port, 10)
+    };
+}
+function getRandomAppName() {
+    return 'app-' + new Date().getTime() + '-' + Math.random();
+}
+function getDatabaseUrl(databaseName) {
+    return "http://" + getDatabaseHost() + "?ns=" + databaseName;
+}
+function getAppOptions(databaseName, projectId, storageBucket) {
+    var appOptions = {};
+    if (databaseName) {
+        appOptions['databaseURL'] = getDatabaseUrl(databaseName);
+    }
+    if (projectId) {
+        appOptions['projectId'] = projectId;
+    }
+    if (storageBucket) {
+        appOptions['storageBucket'] = storageBucket;
+    }
+    return appOptions;
+}
+function initializeApp(accessToken, databaseName, projectId, storageBucket) {
+    var _this = this;
+    var appOptions = getAppOptions(databaseName, projectId, storageBucket);
+    var app = firebase__default['default'].initializeApp(appOptions, getRandomAppName());
+    if (accessToken) {
+        var mockAuthComponent = new component.Component('auth-internal', function () {
+            return ({
+                getToken: function () { return __awaiter(_this, void 0, void 0, function () { return __generator(this, function (_a) {
+                    return [2 /*return*/, ({ accessToken: accessToken })];
+                }); }); },
+                getUid: function () { return null; },
+                addAuthTokenListener: function (listener) {
+                    // Call listener once immediately with predefined accessToken.
+                    listener(accessToken);
+                },
+                removeAuthTokenListener: function () { }
+            });
+        }, "PRIVATE" /* PRIVATE */);
+        app._addOrOverwriteComponent(mockAuthComponent);
+    }
+    if (databaseName) {
+        var _a = parseHost(getDatabaseHost()), hostname = _a.hostname, port = _a.port;
+        app.database().useEmulator(hostname, port);
+        // Toggle network connectivity to force a reauthentication attempt.
+        // This mitigates a minor race condition where the client can send the
+        // first database request before authenticating.
+        app.database().goOffline();
+        app.database().goOnline();
+    }
+    if (projectId) {
+        var _b = parseHost(getFirestoreHost()), hostname = _b.hostname, port = _b.port;
+        app.firestore().useEmulator(hostname, port);
+    }
+    if (storageBucket) {
+        var _c = parseHost(getStorageHost()), hostname = _c.hostname, port = _c.port;
+        app.storage().useEmulator(hostname, port);
+    }
+    /**
+    Mute warnings for the previously-created database and whatever other
+    objects were just created.
+   */
+    logger.setLogLevel(logger.LogLevel.ERROR);
+    return app;
+}
+function loadDatabaseRules(options) {
     return __awaiter(this, void 0, void 0, function () {
-        var url, resp, _a;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
+        var resp;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
                 case 0:
-                    url = makeUrl(hostAndPort, '/.settings/rules.json');
-                    url.searchParams.append('ns', databaseName);
-                    return [4 /*yield*/, fetch__default['default'](url, {
+                    if (!options.databaseName) {
+                        throw Error('databaseName not specified');
+                    }
+                    if (!options.rules) {
+                        throw Error('must provide rules to loadDatabaseRules');
+                    }
+                    return [4 /*yield*/, requestPromise(request__namespace.put, {
                             method: 'PUT',
+                            uri: "http://" + getDatabaseHost() + "/.settings/rules.json?ns=" + options.databaseName,
                             headers: { Authorization: 'Bearer owner' },
-                            body: rules
+                            body: options.rules
                         })];
                 case 1:
-                    resp = _b.sent();
-                    if (!!resp.ok) return [3 /*break*/, 3];
-                    _a = Error.bind;
-                    return [4 /*yield*/, resp.text()];
-                case 2: throw new (_a.apply(Error, [void 0, _b.sent()]))();
-                case 3: return [2 /*return*/];
+                    resp = _a.sent();
+                    if (resp.statusCode !== 200) {
+                        throw new Error(JSON.parse(resp.body.error));
+                    }
+                    return [2 /*return*/];
             }
         });
     });
 }
-/**
- * @private
- */
-function loadFirestoreRules(hostAndPort, projectId, rules) {
+function loadFirestoreRules(options) {
     return __awaiter(this, void 0, void 0, function () {
-        var resp, _a;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
-                case 0: return [4 /*yield*/, fetch__default['default'](makeUrl(hostAndPort, "/emulator/v1/projects/" + projectId + ":securityRules"), {
-                        method: 'PUT',
-                        body: JSON.stringify({
-                            rules: {
-                                files: [{ content: rules }]
-                            }
-                        })
-                    })];
+        var resp;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    if (!options.projectId) {
+                        throw new Error('projectId not specified');
+                    }
+                    if (!options.rules) {
+                        throw new Error('must provide rules to loadFirestoreRules');
+                    }
+                    return [4 /*yield*/, requestPromise(request__namespace.put, {
+                            method: 'PUT',
+                            uri: "http://" + getFirestoreHost() + "/emulator/v1/projects/" + options.projectId + ":securityRules",
+                            body: JSON.stringify({
+                                rules: {
+                                    files: [{ content: options.rules }]
+                                }
+                            })
+                        })];
                 case 1:
-                    resp = _b.sent();
-                    if (!!resp.ok) return [3 /*break*/, 3];
-                    _a = Error.bind;
-                    return [4 /*yield*/, resp.text()];
-                case 2: throw new (_a.apply(Error, [void 0, _b.sent()]))();
-                case 3: return [2 /*return*/];
+                    resp = _a.sent();
+                    if (resp.statusCode !== 200) {
+                        throw new Error(JSON.parse(resp.body.error));
+                    }
+                    return [2 /*return*/];
             }
         });
     });
 }
-/**
- * @private
- */
-function loadStorageRules(hostAndPort, rules) {
+function loadStorageRules(options) {
     return __awaiter(this, void 0, void 0, function () {
-        var resp, _a;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
-                case 0: return [4 /*yield*/, fetch__default['default'](makeUrl(hostAndPort, '/internal/setRules'), {
-                        method: 'PUT',
-                        headers: {
-                            'Content-Type': 'application/json'
-                        },
-                        body: JSON.stringify({
-                            rules: {
-                                files: [{ name: 'storage.rules', content: rules }]
-                            }
-                        })
-                    })];
+        var resp;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    if (!options.rules) {
+                        throw new Error('must provide rules to loadStorageRules');
+                    }
+                    return [4 /*yield*/, requestPromise(request__namespace.put, {
+                            method: 'PUT',
+                            uri: "http://" + getStorageHost() + "/internal/setRules",
+                            headers: {
+                                'Content-Type': 'application/json'
+                            },
+                            body: JSON.stringify({
+                                rules: {
+                                    files: [{ name: 'storage.rules', content: options.rules }]
+                                }
+                            })
+                        })];
                 case 1:
-                    resp = _b.sent();
-                    if (!!resp.ok) return [3 /*break*/, 3];
-                    _a = Error.bind;
-                    return [4 /*yield*/, resp.text()];
-                case 2: throw new (_a.apply(Error, [void 0, _b.sent()]))();
-                case 3: return [2 /*return*/];
+                    resp = _a.sent();
+                    if (resp.statusCode !== 200) {
+                        throw new Error(resp.body);
+                    }
+                    return [2 /*return*/];
             }
         });
     });
-}
-
-/**
- * @license
- * Copyright 2021 Google LLC
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-/**
- * Initializes a test environment for rules unit testing. Call this function first for test setup.
- *
- * Requires emulators to be running. This function tries to discover those emulators via environment
- * variables or through the Firebase Emulator hub if hosts and ports are unspecified. It is strongly
- * recommended to specify security rules for emulators used for testing. See minimal example below.
- *
- * @param config the configuration for emulators. most fields are optional if they can be discovered
- * @returns a promise that resolves with an environment ready for testing, or rejects on error.
- * @public
- * @example
- * ```javascript
- * const testEnv = await initializeTestEnvironment({
- *   firestore: {
- *     rules: fs.readFileSync("/path/to/firestore.rules", "utf8"), // Load rules from file
- *     // host and port can be omitted if they can be discovered from the hub.
- *   },
- *   // ...
- * });
- * ```
- */
-function initializeTestEnvironment(config) {
-    var _a, _b, _c;
+}
+function clearFirestoreData(options) {
     return __awaiter(this, void 0, void 0, function () {
-        var projectId, hub, discovered, _d, _e, emulators, _i, SUPPORTED_EMULATORS_1, emulator, hostAndPort;
-        return __generator(this, function (_f) {
-            switch (_f.label) {
+        var resp;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
                 case 0:
-                    projectId = config.projectId || process.env.GCLOUD_PROJECT;
-                    if (!projectId) {
-                        throw new Error('Missing projectId option or env var GCLOUD_PROJECT! Please specify the projectId either ' +
-                            'way.\n(A demo-* projectId is strongly recommended for unit tests, such as "demo-test".)');
+                    if (!options.projectId) {
+                        throw new Error('projectId not specified');
                     }
-                    hub = getEmulatorHostAndPort('hub', config.hub);
-                    if (!hub) return [3 /*break*/, 2];
-                    _e = [{}];
-                    return [4 /*yield*/, discoverEmulators(hub)];
+                    return [4 /*yield*/, requestPromise(request__namespace.delete, {
+                            method: 'DELETE',
+                            uri: "http://" + getFirestoreHost() + "/emulator/v1/projects/" + options.projectId + "/databases/(default)/documents",
+                            body: JSON.stringify({
+                                database: "projects/" + options.projectId + "/databases/(default)"
+                            })
+                        })];
                 case 1:
-                    _d = __assign.apply(void 0, [__assign.apply(void 0, _e.concat([(_f.sent())])), { hub: hub }]);
-                    return [3 /*break*/, 3];
-                case 2:
-                    _d = undefined;
-                    _f.label = 3;
-                case 3:
-                    discovered = _d;
-                    emulators = {};
-                    if (hub) {
-                        emulators.hub = hub;
-                    }
-                    for (_i = 0, SUPPORTED_EMULATORS_1 = SUPPORTED_EMULATORS; _i < SUPPORTED_EMULATORS_1.length; _i++) {
-                        emulator = SUPPORTED_EMULATORS_1[_i];
-                        hostAndPort = getEmulatorHostAndPort(emulator, config[emulator], discovered);
-                        if (hostAndPort) {
-                            emulators[emulator] = hostAndPort;
-                        }
+                    resp = _a.sent();
+                    if (resp.statusCode !== 200) {
+                        throw new Error(JSON.parse(resp.body.error));
                     }
-                    if (!((_a = config.database) === null || _a === void 0 ? void 0 : _a.rules)) return [3 /*break*/, 5];
-                    assertEmulatorRunning(emulators, 'database');
-                    return [4 /*yield*/, loadDatabaseRules(emulators.database, projectId, config.database.rules)];
-                case 4:
-                    _f.sent();
-                    _f.label = 5;
-                case 5:
-                    if (!((_b = config.firestore) === null || _b === void 0 ? void 0 : _b.rules)) return [3 /*break*/, 7];
-                    assertEmulatorRunning(emulators, 'firestore');
-                    return [4 /*yield*/, loadFirestoreRules(emulators.firestore, projectId, config.firestore.rules)];
-                case 6:
-                    _f.sent();
-                    _f.label = 7;
-                case 7:
-                    if (!((_c = config.storage) === null || _c === void 0 ? void 0 : _c.rules)) return [3 /*break*/, 9];
-                    assertEmulatorRunning(emulators, 'storage');
-                    return [4 /*yield*/, loadStorageRules(emulators.storage, config.storage.rules)];
-                case 8:
-                    _f.sent();
-                    _f.label = 9;
-                case 9: return [2 /*return*/, new RulesTestEnvironmentImpl(projectId, emulators)];
+                    return [2 /*return*/];
             }
         });
     });
 }
-var SUPPORTED_EMULATORS = ['database', 'firestore', 'storage'];
-
 /**
- * @license
- * Copyright 2021 Google LLC
+ * Run a setup function with background Cloud Functions triggers disabled. This can be used to
+ * import data into the Realtime Database or Cloud Firestore emulator without triggering locally
+ * emulated Cloud Functions.
  *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
+ * This method only works with Firebase CLI version 8.13.0 or higher.
  *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
+ * @param fn an function which returns a promise.
  */
-function withFunctionTriggersDisabled(fnOrHub, maybeFn) {
+function withFunctionTriggersDisabled(fn) {
     return __awaiter(this, void 0, void 0, function () {
-        var hub, disableRes, result, enableRes;
+        var hubHost, disableRes, result, enableRes;
         return __generator(this, function (_a) {
             switch (_a.label) {
                 case 0:
-                    if (typeof fnOrHub === 'function') {
-                        maybeFn = fnOrHub;
-                        hub = getEmulatorHostAndPort('hub');
-                    }
-                    else {
-                        hub = getEmulatorHostAndPort('hub', fnOrHub);
-                        if (!maybeFn) {
-                            throw new Error('The callback function must be specified!');
-                        }
-                    }
-                    if (!hub) {
-                        throw new Error('Please specify the Emulator Hub host and port via arguments or set the environment ' +
-                            ("varible " + EMULATOR_HOST_ENV_VARS.hub + "!"));
-                    }
-                    hub.host = fixHostname(hub.host);
-                    makeUrl(hub, '/functions/disableBackgroundTriggers');
-                    return [4 /*yield*/, fetch__default['default'](makeUrl(hub, '/functions/disableBackgroundTriggers'), {
-                            method: 'PUT'
+                    hubHost = getHubHost();
+                    return [4 /*yield*/, requestPromise(request__namespace.put, {
+                            method: 'PUT',
+                            uri: "http://" + hubHost + "/functions/disableBackgroundTriggers"
                         })];
                 case 1:
                     disableRes = _a.sent();
-                    if (!disableRes.ok) {
-                        throw new Error("HTTP Error " + disableRes.status + " when disabling functions triggers, are you using firebase-tools 8.13.0 or higher?");
+                    if (disableRes.statusCode !== 200) {
+                        throw new Error("HTTP Error " + disableRes.statusCode + " when disabling functions triggers, are you using firebase-tools 8.13.0 or higher?");
                     }
                     result = undefined;
                     _a.label = 2;
                 case 2:
                     _a.trys.push([2, , 4, 6]);
-                    return [4 /*yield*/, maybeFn()];
+                    return [4 /*yield*/, fn()];
                 case 3:
                     result = _a.sent();
                     return [3 /*break*/, 6];
-                case 4: return [4 /*yield*/, fetch__default['default'](makeUrl(hub, '/functions/enableBackgroundTriggers'), {
-                        method: 'PUT'
+                case 4: return [4 /*yield*/, requestPromise(request__namespace.put, {
+                        method: 'PUT',
+                        uri: "http://" + hubHost + "/functions/enableBackgroundTriggers"
                     })];
                 case 5:
                     enableRes = _a.sent();
-                    if (!enableRes.ok) {
-                        throw new Error("HTTP Error " + enableRes.status + " when enabling functions triggers, are you using firebase-tools 8.13.0 or higher?");
+                    if (enableRes.statusCode !== 200) {
+                        throw new Error("HTTP Error " + enableRes.statusCode + " when enabling functions triggers, are you using firebase-tools 8.13.0 or higher?");
                     }
                     return [7 /*endfinally*/];
                 case 6: 
@@ -739,29 +580,12 @@ function withFunctionTriggersDisabled(fnOrHub, maybeFn) {
         });
     });
 }
-/**
- * Assert the promise to be rejected with a "permission denied" error.
- *
- * Useful to assert a certain request to be denied by Security Rules. See example below.
- * This function recognizes permission-denied errors from Database, Firestore, and Storage JS SDKs.
- *
- * @param pr the promise to be asserted
- * @returns a Promise that is fulfilled if pr is rejected with "permission denied". If pr is
- *          rejected with any other error or resolved, the returned promise rejects.
- * @public
- * @example
- * ```javascript
- * const unauthed = testEnv.unauthenticatedContext();
- * await assertFails(get(doc(unauthed.firestore(), '/private/doc'), { ... });
- * ```
- */
 function assertFails(pr) {
-    return pr.then(function () {
+    return pr.then(function (v) {
         return Promise.reject(new Error('Expected request to fail, but it succeeded.'));
     }, function (err) {
-        var _a, _b;
-        var errCode = ((_a = err === null || err === void 0 ? void 0 : err.code) === null || _a === void 0 ? void 0 : _a.toLowerCase()) || '';
-        var errMessage = ((_b = err === null || err === void 0 ? void 0 : err.message) === null || _b === void 0 ? void 0 : _b.toLowerCase()) || '';
+        var errCode = (err && err.code && err.code.toLowerCase()) || '';
+        var errMessage = (err && err.message && err.message.toLowerCase()) || '';
         var isPermissionDenied = errCode === 'permission-denied' ||
             errCode === 'permission_denied' ||
             errMessage.indexOf('permission_denied') >= 0 ||
@@ -774,25 +598,37 @@ function assertFails(pr) {
         return err;
     });
 }
-/**
- * Assert the promise to be rejected with a "permission denied" error.
- *
- * This is a no-op function returning the passed promise as-is, but can be used for documentational
- * purposes in test code to emphasize that a certain request should succeed (e.g. allowed by rules).
- *
- * @public
- * @example
- * ```javascript
- * const alice = testEnv.authenticatedContext('alice');
- * await assertSucceeds(get(doc(alice.firestore(), '/doc/readable/by/alice'), { ... });
- * ```
- */
 function assertSucceeds(pr) {
     return pr;
+}
+function requestPromise(method, options) {
+    return new Promise(function (resolve, reject) {
+        var callback = function (err, resp, body) {
+            if (err) {
+                reject(err);
+            }
+            else {
+                resolve({ statusCode: resp.statusCode, body: body });
+            }
+        };
+        // Unfortunately request's default method is not very test-friendly so having
+        // the caler pass in the method here makes this whole thing compatible with sinon
+        method(options, callback);
+    });
 }
 
+exports.apps = apps;
 exports.assertFails = assertFails;
 exports.assertSucceeds = assertSucceeds;
-exports.initializeTestEnvironment = initializeTestEnvironment;
+exports.clearFirestoreData = clearFirestoreData;
+exports.database = database;
+exports.discoverEmulators = discoverEmulators;
+exports.firestore = firestore;
+exports.initializeAdminApp = initializeAdminApp;
+exports.initializeTestApp = initializeTestApp;
+exports.loadDatabaseRules = loadDatabaseRules;
+exports.loadFirestoreRules = loadFirestoreRules;
+exports.loadStorageRules = loadStorageRules;
+exports.useEmulators = useEmulators;
 exports.withFunctionTriggersDisabled = withFunctionTriggersDisabled;
 //# sourceMappingURL=index.cjs.js.map