@firebase/rules-unit-testing 3.0.4 → 4.0.0

package/dist/index.cjs.js

@@ -5,78 +5,12 @@ Object.defineProperty(exports, '__esModule', { value: true });
 require('firebase/compat/database');
 require('firebase/compat/firestore');
 require('firebase/compat/storage');
-var fetch = require('node-fetch');
 var firebase = require('firebase/compat/app');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
-var fetch__default = /*#__PURE__*/_interopDefaultLegacy(fetch);
 var firebase__default = /*#__PURE__*/_interopDefaultLegacy(firebase);
 
-/******************************************************************************
-Copyright (c) Microsoft Corporation.
-
-Permission to use, copy, modify, and/or distribute this software for any
-purpose with or without fee is hereby granted.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-PERFORMANCE OF THIS SOFTWARE.
-***************************************************************************** */
-
-var __assign = function() {
-    __assign = Object.assign || function __assign(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
-
-function __awaiter(thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-}
-
-function __generator(thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (_) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-}
-
 /**
  * @license
  * Copyright 2021 Google LLC
@@ -118,15 +52,15 @@ function fixHostname(host, fallbackHost) {
  */
 function makeUrl(hostAndPort, path) {
     if (typeof hostAndPort === 'object') {
-        var host = hostAndPort.host, port = hostAndPort.port;
+        const { host, port } = hostAndPort;
         if (host.includes(':')) {
-            hostAndPort = "[".concat(host, "]:").concat(port);
+            hostAndPort = `[${host}]:${port}`;
         }
         else {
-            hostAndPort = "".concat(host, ":").concat(port);
+            hostAndPort = `${host}:${port}`;
         }
     }
-    var url = new URL("http://".concat(hostAndPort, "/"));
+    const url = new URL(`http://${hostAndPort}/`);
     url.pathname = path;
     return url;
 }
@@ -153,50 +87,38 @@ function makeUrl(hostAndPort, path) {
  * @param hub the host and port where the Emulator Hub is running
  * @private
  */
-function discoverEmulators(hub, fetch) {
-    if (fetch === void 0) { fetch = fetch__default["default"]; }
-    return __awaiter(this, void 0, void 0, function () {
-        var res, emulators, data;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0: return [4 /*yield*/, fetch(makeUrl(hub, '/emulators'))];
-                case 1:
-                    res = _a.sent();
-                    if (!res.ok) {
-                        throw new Error("HTTP Error ".concat(res.status, " when attempting to reach Emulator Hub at ").concat(res.url, ", are you sure it is running?"));
-                    }
-                    emulators = {};
-                    return [4 /*yield*/, res.json()];
-                case 2:
-                    data = _a.sent();
-                    if (data.database) {
-                        emulators.database = {
-                            host: data.database.host,
-                            port: data.database.port
-                        };
-                    }
-                    if (data.firestore) {
-                        emulators.firestore = {
-                            host: data.firestore.host,
-                            port: data.firestore.port
-                        };
-                    }
-                    if (data.storage) {
-                        emulators.storage = {
-                            host: data.storage.host,
-                            port: data.storage.port
-                        };
-                    }
-                    if (data.hub) {
-                        emulators.hub = {
-                            host: data.hub.host,
-                            port: data.hub.port
-                        };
-                    }
-                    return [2 /*return*/, emulators];
-            }
-        });
-    });
+async function discoverEmulators(hub, fetchImpl = fetch) {
+    const res = await fetchImpl(makeUrl(hub, '/emulators'));
+    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?`);
+    }
+    const emulators = {};
+    const data = await res.json();
+    if (data.database) {
+        emulators.database = {
+            host: data.database.host,
+            port: data.database.port
+        };
+    }
+    if (data.firestore) {
+        emulators.firestore = {
+            host: data.firestore.host,
+            port: data.firestore.port
+        };
+    }
+    if (data.storage) {
+        emulators.storage = {
+            host: data.storage.host,
+            port: data.storage.port
+        };
+    }
+    if (data.hub) {
+        emulators.hub = {
+            host: data.hub.host,
+            port: data.hub.port
+        };
+    }
+    return emulators;
 }
 /**
  * @private
@@ -204,14 +126,14 @@ function discoverEmulators(hub, fetch) {
 function getEmulatorHostAndPort(emulator, conf, discovered) {
     var _a, _b;
     if (conf && ('host' in conf || 'port' in conf)) {
-        var host = conf.host, port = conf.port;
+        const { host, port } = conf;
         if (host || port) {
             if (!host || !port) {
-                throw new Error("Invalid configuration ".concat(emulator, ".host=").concat(host, " and ").concat(emulator, ".port=").concat(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 ".concat(emulator, " emulator is specified, but the Emulator hub ") +
+                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 {
@@ -220,12 +142,12 @@ function getEmulatorHostAndPort(emulator, conf, discovered) {
             };
         }
     }
-    var envVar = EMULATOR_HOST_ENV_VARS[emulator];
-    var fallback = (discovered === null || discovered === void 0 ? void 0 : discovered[emulator]) || emulatorFromEnvVar(envVar);
+    const envVar = EMULATOR_HOST_ENV_VARS[emulator];
+    const fallback = (discovered === null || discovered === void 0 ? void 0 : discovered[emulator]) || emulatorFromEnvVar(envVar);
     if (fallback) {
         if (discovered && !discovered[emulator]) {
-            console.warn("Warning: the environment variable ".concat(envVar, " is set, but the Emulator hub reports the ") +
-                "".concat(emulator, " emulator as not running. This may lead to errors such as connection refused."));
+            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),
@@ -234,30 +156,30 @@ function getEmulatorHostAndPort(emulator, conf, discovered) {
     }
 }
 // Visible for testing.
-var EMULATOR_HOST_ENV_VARS = {
+const 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];
+    const hostAndPort = process.env[envVar];
     if (!hostAndPort) {
         return undefined;
     }
-    var parsed;
+    let parsed;
     try {
-        parsed = new URL("http://".concat(hostAndPort));
+        parsed = new URL(`http://${hostAndPort}`);
     }
     catch (_a) {
-        throw new Error("Invalid format in environment variable ".concat(envVar, "=").concat(hostAndPort, " (expected host:port)"));
+        throw new Error(`Invalid format in environment variable ${envVar}=${hostAndPort} (expected host:port)`);
     }
-    var host = parsed.hostname;
-    var port = Number(parsed.port || '80');
+    let host = parsed.hostname;
+    const port = Number(parsed.port || '80');
     if (!Number.isInteger(port)) {
-        throw new Error("Invalid port in environment variable ".concat(envVar, "=").concat(hostAndPort));
+        throw new Error(`Invalid port in environment variable ${envVar}=${hostAndPort}`);
     }
-    return { host: host, port: port };
+    return { host, port };
 }
 
 /**
@@ -281,172 +203,135 @@ function emulatorFromEnvVar(envVar) {
  * which should never be directly called by the developer.
  * @private
  */
-var RulesTestEnvironmentImpl = /** @class */ (function () {
-    function RulesTestEnvironmentImpl(projectId, emulators) {
+class RulesTestEnvironmentImpl {
+    constructor(projectId, emulators) {
         this.projectId = projectId;
         this.emulators = emulators;
         this.contexts = new Set();
         this.destroyed = false;
     }
-    RulesTestEnvironmentImpl.prototype.authenticatedContext = function (user_id, tokenOptions) {
+    authenticatedContext(user_id, tokenOptions) {
         this.checkNotDestroyed();
-        return this.createContext(__assign(__assign({}, tokenOptions), { sub: user_id, user_id: user_id }));
-    };
-    RulesTestEnvironmentImpl.prototype.unauthenticatedContext = function () {
+        return this.createContext(Object.assign(Object.assign({}, tokenOptions), { sub: user_id, user_id: user_id }));
+    }
+    unauthenticatedContext() {
         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);
+    }
+    async withSecurityRulesDisabled(callback) {
+        this.checkNotDestroyed();
+        // The "owner" token is recognized by the emulators as a special value that bypasses Security
+        // Rules. This should only ever be used in withSecurityRulesDisabled.
+        // If you're reading this and thinking about doing this in your own app / tests / scripts, think
+        // twice. Instead, just use withSecurityRulesDisabled for unit testing OR connect your Firebase
+        // Admin SDKs to the emulators for integration testing via environment variables.
+        // See: https://firebase.google.com/docs/emulator-suite/connect_firestore#admin_sdks
+        const context = this.createContext('owner');
+        try {
+            await callback(context);
+        }
+        finally {
+            // We eagerly 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);
+        }
+    }
+    createContext(authToken) {
+        const context = new RulesTestContextImpl(this.projectId, this.emulators, authToken);
         this.contexts.add(context);
         return context;
-    };
-    RulesTestEnvironmentImpl.prototype.clearDatabase = function () {
+    }
+    clearDatabase() {
         this.checkNotDestroyed();
-        return this.withSecurityRulesDisabled(function (context) {
+        return this.withSecurityRulesDisabled(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/".concat(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*/];
-                }
-            });
+    }
+    async clearFirestore() {
+        this.checkNotDestroyed();
+        assertEmulatorRunning(this.emulators, 'firestore');
+        const resp = await fetch(makeUrl(this.emulators.firestore, `/emulator/v1/projects/${this.projectId}/databases/(default)/documents`), {
+            method: 'DELETE'
         });
-    };
-    RulesTestEnvironmentImpl.prototype.clearStorage = function () {
-        var _this = this;
+        if (!resp.ok) {
+            throw new Error(await resp.text());
+        }
+    }
+    clearStorage() {
         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*/];
-            });
+        return this.withSecurityRulesDisabled(async (context) => {
+            const { items } = await context.storage().ref().listAll();
+            await Promise.all(items.map((item) => {
+                return item.delete();
+            }));
         });
-    };
-    RulesTestEnvironmentImpl.prototype.checkNotDestroyed = function () {
+    }
+    async cleanup() {
+        this.destroyed = true;
+        this.contexts.forEach(context => {
+            context.envDestroyed = true;
+            context.cleanup();
+        });
+        this.contexts.clear();
+    }
+    checkNotDestroyed() {
         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.)');
         }
-    };
-    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) {
+class RulesTestContextImpl {
+    constructor(projectId, emulators, authToken) {
         this.projectId = projectId;
         this.emulators = emulators;
         this.authToken = authToken;
         this.destroyed = false;
         this.envDestroyed = false;
     }
-    RulesTestContextImpl.prototype.cleanup = function () {
+    cleanup() {
         var _a;
         this.destroyed = true;
         (_a = this.app) === null || _a === void 0 ? void 0 : _a.delete();
         this.app = undefined;
-    };
-    RulesTestContextImpl.prototype.firestore = function (settings) {
+    }
+    firestore(settings) {
         assertEmulatorRunning(this.emulators, 'firestore');
-        var firestore = this.getApp().firestore();
+        const firestore = this.getApp().firestore();
         if (settings) {
             firestore.settings(settings);
         }
         firestore.useEmulator(this.emulators.firestore.host, this.emulators.firestore.port, { mockUserToken: this.authToken });
         return firestore;
-    };
-    RulesTestContextImpl.prototype.database = function (databaseURL) {
+    }
+    database(databaseURL) {
         assertEmulatorRunning(this.emulators, 'database');
         if (!databaseURL) {
-            var url = makeUrl(this.emulators.database, '');
+            const url = makeUrl(this.emulators.database, '');
             // Make sure to set the namespace equal to projectId -- otherwise the RTDB SDK will by default
             // use `${projectId}-default-rtdb`, which is treated as a different DB by the RTDB emulator
             // (and thus WON'T apply any rules set for the `projectId` DB during initialization).
             url.searchParams.append('ns', this.projectId);
             databaseURL = url.toString();
         }
-        var database = this.getApp().database(databaseURL);
+        const 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://".concat(this.projectId); }
+    }
+    storage(bucketUrl = `gs://${this.projectId}`) {
         assertEmulatorRunning(this.emulators, 'storage');
-        var storage = this.getApp().storage(bucketUrl);
+        const storage = this.getApp().storage(bucketUrl);
         storage.useEmulator(this.emulators.storage.host, this.emulators.storage.port, { mockUserToken: this.authToken });
         return storage;
-    };
-    RulesTestContextImpl.prototype.getApp = function () {
+    }
+    getApp() {
         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.)');
@@ -457,22 +342,21 @@ var RulesTestContextImpl = /** @class */ (function () {
                 'return a Promise that resolves when the operations are done.');
         }
         if (!this.app) {
-            this.app = firebase__default["default"].initializeApp({ projectId: this.projectId }, "_Firebase_RulesUnitTesting_".concat(Date.now(), "_").concat(Math.random()));
+            this.app = firebase__default["default"].initializeApp({ projectId: this.projectId }, `_Firebase_RulesUnitTesting_${Date.now()}_${Math.random()}`);
         }
         return this.app;
-    };
-    return RulesTestContextImpl;
-}());
+    }
+}
 function assertEmulatorRunning(emulators, emulator) {
     if (!emulators[emulator]) {
         if (emulators.hub) {
-            throw new Error("The ".concat(emulator, " emulator is not running (according to Emulator hub). To force ") +
+            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({...}).');
         }
         else {
-            throw new Error("The host and port of the ".concat(emulator, " emulator must be specified. (You may wrap the test ") +
+            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({".concat(emulator, ": {host, port}})."));
+                `discovery, or specify manually via initializeTestEnvironment({${emulator}: {host, port}}).`);
         }
     }
 }
@@ -496,86 +380,52 @@ function assertEmulatorRunning(emulators, emulator) {
 /**
  * @private
  */
-function loadDatabaseRules(hostAndPort, databaseName, rules) {
-    return __awaiter(this, void 0, void 0, function () {
-        var url, resp, _a;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
-                case 0:
-                    url = makeUrl(hostAndPort, '/.settings/rules.json');
-                    url.searchParams.append('ns', databaseName);
-                    return [4 /*yield*/, fetch__default["default"](url, {
-                            method: 'PUT',
-                            headers: { Authorization: 'Bearer owner' },
-                            body: 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*/];
-            }
-        });
+async function loadDatabaseRules(hostAndPort, databaseName, rules) {
+    const url = makeUrl(hostAndPort, '/.settings/rules.json');
+    url.searchParams.append('ns', databaseName);
+    const resp = await fetch(url, {
+        method: 'PUT',
+        headers: { Authorization: 'Bearer owner' },
+        body: rules
     });
+    if (!resp.ok) {
+        throw new Error(await resp.text());
+    }
 }
 /**
  * @private
  */
-function loadFirestoreRules(hostAndPort, projectId, rules) {
-    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/".concat(projectId, ":securityRules")), {
-                        method: 'PUT',
-                        body: JSON.stringify({
-                            rules: {
-                                files: [{ content: 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*/];
+async function loadFirestoreRules(hostAndPort, projectId, rules) {
+    const resp = await fetch(makeUrl(hostAndPort, `/emulator/v1/projects/${projectId}:securityRules`), {
+        method: 'PUT',
+        body: JSON.stringify({
+            rules: {
+                files: [{ content: rules }]
             }
-        });
+        })
     });
+    if (!resp.ok) {
+        throw new Error(await resp.text());
+    }
 }
 /**
  * @private
  */
-function loadStorageRules(hostAndPort, rules) {
-    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 }]
-                            }
-                        })
-                    })];
-                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*/];
+async function loadStorageRules(hostAndPort, rules) {
+    const resp = await fetch(makeUrl(hostAndPort, '/internal/setRules'), {
+        method: 'PUT',
+        headers: {
+            'Content-Type': 'application/json'
+        },
+        body: JSON.stringify({
+            rules: {
+                files: [{ name: 'storage.rules', content: rules }]
             }
-        });
+        })
     });
+    if (!resp.ok) {
+        throw new Error(await resp.text());
+    }
 }
 
 /**
@@ -615,67 +465,40 @@ function loadStorageRules(hostAndPort, rules) {
  * });
  * ```
  */
-function initializeTestEnvironment(config) {
+async function initializeTestEnvironment(config) {
     var _a, _b, _c;
-    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) {
-                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".)');
-                    }
-                    hub = getEmulatorHostAndPort('hub', config.hub);
-                    if (!hub) return [3 /*break*/, 2];
-                    _e = [{}];
-                    return [4 /*yield*/, discoverEmulators(hub)];
-                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;
-                        }
-                    }
-                    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)];
-            }
-        });
-    });
+    const 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".)');
+    }
+    const hub = getEmulatorHostAndPort('hub', config.hub);
+    let discovered = hub ? Object.assign(Object.assign({}, (await discoverEmulators(hub))), { hub }) : undefined;
+    const emulators = {};
+    if (hub) {
+        emulators.hub = hub;
+    }
+    for (const emulator of SUPPORTED_EMULATORS) {
+        const hostAndPort = getEmulatorHostAndPort(emulator, config[emulator], discovered);
+        if (hostAndPort) {
+            emulators[emulator] = hostAndPort;
+        }
+    }
+    if ((_a = config.database) === null || _a === void 0 ? void 0 : _a.rules) {
+        assertEmulatorRunning(emulators, 'database');
+        await loadDatabaseRules(emulators.database, projectId, config.database.rules);
+    }
+    if ((_b = config.firestore) === null || _b === void 0 ? void 0 : _b.rules) {
+        assertEmulatorRunning(emulators, 'firestore');
+        await loadFirestoreRules(emulators.firestore, projectId, config.firestore.rules);
+    }
+    if ((_c = config.storage) === null || _c === void 0 ? void 0 : _c.rules) {
+        assertEmulatorRunning(emulators, 'storage');
+        await loadStorageRules(emulators.storage, config.storage.rules);
+    }
+    return new RulesTestEnvironmentImpl(projectId, emulators);
 }
-var SUPPORTED_EMULATORS = ['database', 'firestore', 'storage'];
+const SUPPORTED_EMULATORS = ['database', 'firestore', 'storage'];
 
 /**
  * @license
@@ -693,59 +516,47 @@ var SUPPORTED_EMULATORS = ['database', 'firestore', 'storage'];
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-function withFunctionTriggersDisabled(fnOrHub, maybeFn) {
-    return __awaiter(this, void 0, void 0, function () {
-        var hub, 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 ".concat(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'
-                        })];
-                case 1:
-                    disableRes = _a.sent();
-                    if (!disableRes.ok) {
-                        throw new Error("HTTP Error ".concat(disableRes.status, " 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()];
-                case 3:
-                    result = _a.sent();
-                    return [3 /*break*/, 6];
-                case 4: return [4 /*yield*/, fetch__default["default"](makeUrl(hub, '/functions/enableBackgroundTriggers'), {
-                        method: 'PUT'
-                    })];
-                case 5:
-                    enableRes = _a.sent();
-                    if (!enableRes.ok) {
-                        throw new Error("HTTP Error ".concat(enableRes.status, " when enabling functions triggers, are you using firebase-tools 8.13.0 or higher?"));
-                    }
-                    return [7 /*endfinally*/];
-                case 6: 
-                // Return the user's function result
-                return [2 /*return*/, result];
-            }
-        });
+async function withFunctionTriggersDisabled(fnOrHub, maybeFn) {
+    let hub;
+    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 ' +
+            `variable ${EMULATOR_HOST_ENV_VARS.hub}!`);
+    }
+    hub.host = fixHostname(hub.host);
+    makeUrl(hub, '/functions/disableBackgroundTriggers');
+    // Disable background triggers
+    const disableRes = await fetch(makeUrl(hub, '/functions/disableBackgroundTriggers'), {
+        method: 'PUT'
     });
+    if (!disableRes.ok) {
+        throw new Error(`HTTP Error ${disableRes.status} when disabling functions triggers, are you using firebase-tools 8.13.0 or higher?`);
+    }
+    // Run the user's function
+    let result = undefined;
+    try {
+        result = await maybeFn();
+    }
+    finally {
+        // Re-enable background triggers
+        const enableRes = await fetch(makeUrl(hub, '/functions/enableBackgroundTriggers'), {
+            method: 'PUT'
+        });
+        if (!enableRes.ok) {
+            throw new Error(`HTTP Error ${enableRes.status} when enabling functions triggers, are you using firebase-tools 8.13.0 or higher?`);
+        }
+    }
+    // Return the user's function result
+    return result;
 }
 /**
  * Assert the promise to be rejected with a "permission denied" error.
@@ -764,20 +575,20 @@ function withFunctionTriggersDisabled(fnOrHub, maybeFn) {
  * ```
  */
 function assertFails(pr) {
-    return pr.then(function () {
+    return pr.then(() => {
         return Promise.reject(new Error('Expected request to fail, but it succeeded.'));
-    }, function (err) {
+    }, (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 isPermissionDenied = errCode === 'permission-denied' ||
+        const errCode = ((_a = err === null || err === void 0 ? void 0 : err.code) === null || _a === void 0 ? void 0 : _a.toLowerCase()) || '';
+        const errMessage = ((_b = err === null || err === void 0 ? void 0 : err.message) === null || _b === void 0 ? void 0 : _b.toLowerCase()) || '';
+        const isPermissionDenied = errCode === 'permission-denied' ||
             errCode === 'permission_denied' ||
             errMessage.indexOf('permission_denied') >= 0 ||
             errMessage.indexOf('permission denied') >= 0 ||
             // Storage permission errors contain message: (storage/unauthorized)
             errMessage.indexOf('unauthorized') >= 0;
         if (!isPermissionDenied) {
-            return Promise.reject(new Error("Expected PERMISSION_DENIED but got unexpected error: ".concat(err)));
+            return Promise.reject(new Error(`Expected PERMISSION_DENIED but got unexpected error: ${err}`));
         }
         return err;
     });