@angular/core 12.1.0-next.6 → 12.1.3

package/bundles/core-testing.umd.js

@@ -1,5 +1,5 @@
 /**
- * @license Angular v12.1.0-next.6
+ * @license Angular v12.1.3
  * (c) 2010-2021 Google LLC. https://angular.io/
  * License: MIT
  */
@@ -647,10 +647,16 @@
                 r[k] = a[j];
         return r;
     }
-    function __spreadArray(to, from) {
-        for (var i = 0, il = from.length, j = to.length; i < il; i++, j++)
-            to[j] = from[i];
-        return to;
+    function __spreadArray(to, from, pack) {
+        if (pack || arguments.length === 2)
+            for (var i = 0, l = from.length, ar; i < l; i++) {
+                if (ar || !(i in from)) {
+                    if (!ar)
+                        ar = Array.prototype.slice.call(from, 0, i);
+                    ar[i] = from[i];
+                }
+            }
+        return to.concat(ar || from);
     }
     function __await(v) {
         return this instanceof __await ? (this.v = v, this) : new __await(v);
@@ -1587,6 +1593,9 @@
                             queueTypesFromModulesArrayRecur(maybeUnwrapFn(def.imports));
                             queueTypesFromModulesArrayRecur(maybeUnwrapFn(def.exports));
                         }
+                        else if (isModuleWithProviders(value)) {
+                            queueTypesFromModulesArrayRecur([value.ngModule]);
+                        }
                     }
                 }
                 catch (e_4_1) { e_4 = { error: e_4_1 }; }
@@ -1928,6 +1937,11 @@
      * Use of this source code is governed by an MIT-style license that can be
      * found in the LICENSE file at https://angular.io/license
      */
+    /**
+     * Whether test modules should be torn down by default.
+     * Currently disabled for backwards-compatibility reasons.
+     */
+    var TEARDOWN_TESTING_MODULE_ON_DESTROY_DEFAULT = false;
     /**
      * An abstract class for inserting the root test component element in a platform independent way.
      *
@@ -1937,6 +1951,7 @@
         function TestComponentRenderer() {
         }
         TestComponentRenderer.prototype.insertRootElement = function (rootElementId) { };
+        TestComponentRenderer.prototype.removeAllRootElements = function () { };
         return TestComponentRenderer;
     }());
     /**
@@ -1989,9 +2004,9 @@
          *
          * @publicApi
          */
-        TestBedRender3.initTestEnvironment = function (ngModule, platform, aotSummaries) {
+        TestBedRender3.initTestEnvironment = function (ngModule, platform, summariesOrOptions) {
             var testBed = _getTestBedRender3();
-            testBed.initTestEnvironment(ngModule, platform, aotSummaries);
+            testBed.initTestEnvironment(ngModule, platform, summariesOrOptions);
             return testBed;
         };
         /**
@@ -2072,6 +2087,12 @@
             _getTestBedRender3().resetTestingModule();
             return TestBedRender3;
         };
+        TestBedRender3.shouldTearDownTestingModule = function () {
+            return _getTestBedRender3().shouldTearDownTestingModule();
+        };
+        TestBedRender3.tearDownTestingModule = function () {
+            _getTestBedRender3().tearDownTestingModule();
+        };
         /**
          * Initialize the environment for testing with a compiler factory, a PlatformRef, and an
          * angular module. These are common to every test in the suite.
@@ -2085,10 +2106,14 @@
          *
          * @publicApi
          */
-        TestBedRender3.prototype.initTestEnvironment = function (ngModule, platform, aotSummaries) {
+        TestBedRender3.prototype.initTestEnvironment = function (ngModule, platform, summariesOrOptions) {
             if (this.platform || this.ngModule) {
                 throw new Error('Cannot set base providers because it has already been called');
             }
+            // If `summariesOrOptions` is a function, it means that it's
+            // an AOT summaries factory which Ivy doesn't support.
+            TestBedRender3._environmentTeardownOptions =
+                typeof summariesOrOptions === 'function' ? undefined : summariesOrOptions === null || summariesOrOptions === void 0 ? void 0 : summariesOrOptions.teardown;
             this.platform = platform;
             this.ngModule = ngModule;
             this._compiler = new R3TestBedCompiler(this.platform, this.ngModule);
@@ -2103,6 +2128,7 @@
             this._compiler = null;
             this.platform = null;
             this.ngModule = null;
+            TestBedRender3._environmentTeardownOptions = undefined;
         };
         TestBedRender3.prototype.resetTestingModule = function () {
             this.checkGlobalCompilationFinished();
@@ -2111,8 +2137,23 @@
                 this.compiler.restoreOriginalState();
             }
             this._compiler = new R3TestBedCompiler(this.platform, this.ngModule);
-            this._testModuleRef = null;
-            this.destroyActiveFixtures();
+            // We have to chain a couple of try/finally blocks, because each step can
+            // throw errors and we don't want it to interrupt the next step and we also
+            // want an error to be thrown at the end.
+            try {
+                this.destroyActiveFixtures();
+            }
+            finally {
+                try {
+                    if (this.shouldTearDownTestingModule()) {
+                        this.tearDownTestingModule();
+                    }
+                }
+                finally {
+                    this._testModuleRef = null;
+                    this._instanceTeardownOptions = undefined;
+                }
+            }
         };
         TestBedRender3.prototype.configureCompiler = function (config) {
             if (config.useJit != null) {
@@ -2124,6 +2165,9 @@
         };
         TestBedRender3.prototype.configureTestingModule = function (moduleDef) {
             this.assertNotInstantiated('R3TestBed.configureTestingModule', 'configure the test module');
+            // Always re-assign the teardown options, even if they're undefined.
+            // This ensures that we don't carry the options between tests.
+            this._instanceTeardownOptions = moduleDef.teardown;
             this.compiler.configureTestingModule(moduleDef);
         };
         TestBedRender3.prototype.compileComponents = function () {
@@ -2254,11 +2298,13 @@
             this._globalCompilationChecked = true;
         };
         TestBedRender3.prototype.destroyActiveFixtures = function () {
+            var errorCount = 0;
             this._activeFixtures.forEach(function (fixture) {
                 try {
                     fixture.destroy();
                 }
                 catch (e) {
+                    errorCount++;
                     console.error('Error during cleanup of component', {
                         component: fixture.componentInstance,
                         stacktrace: e,
@@ -2266,6 +2312,52 @@
                 }
             });
             this._activeFixtures = [];
+            if (errorCount > 0 && this.shouldRethrowTeardownErrors()) {
+                throw Error(errorCount + " " + (errorCount === 1 ? 'component' : 'components') + " " +
+                    "threw errors during cleanup");
+            }
+        };
+        TestBedRender3.prototype.shouldRethrowTeardownErrors = function () {
+            var _a, _b;
+            var instanceOptions = this._instanceTeardownOptions;
+            var environmentOptions = TestBedRender3._environmentTeardownOptions;
+            // If the new teardown behavior hasn't been configured, preserve the old behavior.
+            if (!instanceOptions && !environmentOptions) {
+                return false;
+            }
+            // Otherwise use the configured behavior or default to rethrowing.
+            return (_b = (_a = instanceOptions === null || instanceOptions === void 0 ? void 0 : instanceOptions.rethrowErrors) !== null && _a !== void 0 ? _a : environmentOptions === null || environmentOptions === void 0 ? void 0 : environmentOptions.rethrowErrors) !== null && _b !== void 0 ? _b : true;
+        };
+        TestBedRender3.prototype.shouldTearDownTestingModule = function () {
+            var _a, _b, _c, _d;
+            return (_d = (_b = (_a = this._instanceTeardownOptions) === null || _a === void 0 ? void 0 : _a.destroyAfterEach) !== null && _b !== void 0 ? _b : (_c = TestBedRender3._environmentTeardownOptions) === null || _c === void 0 ? void 0 : _c.destroyAfterEach) !== null && _d !== void 0 ? _d : TEARDOWN_TESTING_MODULE_ON_DESTROY_DEFAULT;
+        };
+        TestBedRender3.prototype.tearDownTestingModule = function () {
+            var _a;
+            // If the module ref has already been destroyed, we won't be able to get a test renderer.
+            if (this._testModuleRef === null) {
+                return;
+            }
+            // Resolve the renderer ahead of time, because we want to remove the root elements as the very
+            // last step, but the injector will be destroyed as a part of the module ref destruction.
+            var testRenderer = this.inject(TestComponentRenderer);
+            try {
+                this._testModuleRef.destroy();
+            }
+            catch (e) {
+                if (this.shouldRethrowTeardownErrors()) {
+                    throw e;
+                }
+                else {
+                    console.error('Error during cleanup of a testing module', {
+                        component: this._testModuleRef.instance,
+                        stacktrace: e,
+                    });
+                }
+            }
+            finally {
+                (_a = testRenderer.removeAllRootElements) === null || _a === void 0 ? void 0 : _a.call(testRenderer);
+            }
         };
         return TestBedRender3;
     }());
@@ -2361,6 +2453,7 @@
             this._compiler = null;
             this._moduleRef = null;
             this._moduleFactory = null;
+            this._pendingModuleFactory = null;
             this._compilerOptions = [];
             this._moduleOverrides = [];
             this._componentOverrides = [];
@@ -2390,9 +2483,9 @@
          * Test modules and platforms for individual platforms are available from
          * '@angular/<platform_name>/testing'.
          */
-        TestBedViewEngine.initTestEnvironment = function (ngModule, platform, aotSummaries) {
+        TestBedViewEngine.initTestEnvironment = function (ngModule, platform, summariesOrOptions) {
             var testBed = _getTestBedViewEngine();
-            testBed.initTestEnvironment(ngModule, platform, aotSummaries);
+            testBed.initTestEnvironment(ngModule, platform, summariesOrOptions);
             return testBed;
         };
         /**
@@ -2475,6 +2568,12 @@
         TestBedViewEngine.createComponent = function (component) {
             return _getTestBedViewEngine().createComponent(component);
         };
+        TestBedViewEngine.shouldTearDownTestingModule = function () {
+            return _getTestBedViewEngine().shouldTearDownTestingModule();
+        };
+        TestBedViewEngine.tearDownTestingModule = function () {
+            _getTestBedViewEngine().tearDownTestingModule();
+        };
         /**
          * Initialize the environment for testing with a compiler factory, a PlatformRef, and an
          * angular module. These are common to every test in the suite.
@@ -2486,14 +2585,19 @@
          * Test modules and platforms for individual platforms are available from
          * '@angular/<platform_name>/testing'.
          */
-        TestBedViewEngine.prototype.initTestEnvironment = function (ngModule, platform, aotSummaries) {
+        TestBedViewEngine.prototype.initTestEnvironment = function (ngModule, platform, summariesOrOptions) {
             if (this.platform || this.ngModule) {
                 throw new Error('Cannot set base providers because it has already been called');
             }
             this.platform = platform;
             this.ngModule = ngModule;
-            if (aotSummaries) {
-                this._testEnvAotSummaries = aotSummaries;
+            if (typeof summariesOrOptions === 'function') {
+                this._testEnvAotSummaries = summariesOrOptions;
+                TestBedViewEngine._environmentTeardownOptions = undefined;
+            }
+            else {
+                this._testEnvAotSummaries = (summariesOrOptions === null || summariesOrOptions === void 0 ? void 0 : summariesOrOptions.aotSummaries) || (function () { return []; });
+                TestBedViewEngine._environmentTeardownOptions = summariesOrOptions === null || summariesOrOptions === void 0 ? void 0 : summariesOrOptions.teardown;
             }
         };
         /**
@@ -2504,6 +2608,7 @@
             this.platform = null;
             this.ngModule = null;
             this._testEnvAotSummaries = function () { return []; };
+            TestBedViewEngine._environmentTeardownOptions = undefined;
         };
         TestBedViewEngine.prototype.resetTestingModule = function () {
             core.ɵclearOverrides();
@@ -2516,49 +2621,57 @@
             this._pipeOverrides = [];
             this._isRoot = true;
             this._rootProviderOverrides = [];
-            this._moduleRef = null;
             this._moduleFactory = null;
+            this._pendingModuleFactory = null;
             this._compilerOptions = [];
             this._providers = [];
             this._declarations = [];
             this._imports = [];
             this._schemas = [];
-            this._instantiated = false;
-            this._activeFixtures.forEach(function (fixture) {
+            // We have to chain a couple of try/finally blocks, because each step can
+            // throw errors and we don't want it to interrupt the next step and we also
+            // want an error to be thrown at the end.
+            try {
+                this.destroyActiveFixtures();
+            }
+            finally {
                 try {
-                    fixture.destroy();
+                    if (this.shouldTearDownTestingModule()) {
+                        this.tearDownTestingModule();
+                    }
                 }
-                catch (e) {
-                    console.error('Error during cleanup of component', {
-                        component: fixture.componentInstance,
-                        stacktrace: e,
-                    });
+                finally {
+                    this._moduleRef = null;
+                    this._instanceTeardownOptions = undefined;
+                    this._instantiated = false;
                 }
-            });
-            this._activeFixtures = [];
+            }
         };
         TestBedViewEngine.prototype.configureCompiler = function (config) {
             this._assertNotInstantiated('TestBed.configureCompiler', 'configure the compiler');
             this._compilerOptions.push(config);
         };
         TestBedViewEngine.prototype.configureTestingModule = function (moduleDef) {
-            var _a, _b, _c, _d;
+            var _f, _g, _h, _j;
             this._assertNotInstantiated('TestBed.configureTestingModule', 'configure the test module');
             if (moduleDef.providers) {
-                (_a = this._providers).push.apply(_a, __spreadArray([], __read(moduleDef.providers)));
+                (_f = this._providers).push.apply(_f, __spreadArray([], __read(moduleDef.providers)));
             }
             if (moduleDef.declarations) {
-                (_b = this._declarations).push.apply(_b, __spreadArray([], __read(moduleDef.declarations)));
+                (_g = this._declarations).push.apply(_g, __spreadArray([], __read(moduleDef.declarations)));
             }
             if (moduleDef.imports) {
-                (_c = this._imports).push.apply(_c, __spreadArray([], __read(moduleDef.imports)));
+                (_h = this._imports).push.apply(_h, __spreadArray([], __read(moduleDef.imports)));
             }
             if (moduleDef.schemas) {
-                (_d = this._schemas).push.apply(_d, __spreadArray([], __read(moduleDef.schemas)));
+                (_j = this._schemas).push.apply(_j, __spreadArray([], __read(moduleDef.schemas)));
             }
             if (moduleDef.aotSummaries) {
                 this._aotSummaries.push(moduleDef.aotSummaries);
             }
+            // Always re-assign the teardown options, even if they're undefined.
+            // This ensures that we don't carry the options between tests.
+            this._instanceTeardownOptions = moduleDef.teardown;
         };
         TestBedViewEngine.prototype.compileComponents = function () {
             var _this = this;
@@ -2566,13 +2679,19 @@
                 return Promise.resolve(null);
             }
             var moduleType = this._createCompilerAndModule();
-            return this._compiler.compileModuleAndAllComponentsAsync(moduleType)
-                .then(function (moduleAndComponentFactories) {
-                _this._moduleFactory = moduleAndComponentFactories.ngModuleFactory;
+            this._pendingModuleFactory = moduleType;
+            return this._compiler.compileModuleAndAllComponentsAsync(moduleType).then(function (result) {
+                // If the module mismatches by the time the promise resolves, it means that the module has
+                // already been destroyed and a new compilation has started. If that's the case, avoid
+                // overwriting the module factory, because it can cause downstream errors.
+                if (_this._pendingModuleFactory === moduleType) {
+                    _this._moduleFactory = result.ngModuleFactory;
+                    _this._pendingModuleFactory = null;
+                }
             });
         };
         TestBedViewEngine.prototype._initIfNeeded = function () {
-            var e_1, _a;
+            var e_1, _f;
             if (this._instantiated) {
                 return;
             }
@@ -2594,8 +2713,8 @@
                 }
             }
             try {
-                for (var _b = __values(this._templateOverrides), _c = _b.next(); !_c.done; _c = _b.next()) {
-                    var _d = _c.value, component = _d.component, templateOf = _d.templateOf;
+                for (var _g = __values(this._templateOverrides), _h = _g.next(); !_h.done; _h = _g.next()) {
+                    var _j = _h.value, component = _j.component, templateOf = _j.templateOf;
                     var compFactory = this._compiler.getComponentFactory(templateOf);
                     core.ɵoverrideComponentView(component, compFactory);
                 }
@@ -2603,7 +2722,7 @@
             catch (e_1_1) { e_1 = { error: e_1_1 }; }
             finally {
                 try {
-                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                    if (_h && !_h.done && (_f = _g.return)) _f.call(_g);
                 }
                 finally { if (e_1) throw e_1.error; }
             }
@@ -2621,7 +2740,7 @@
             this._instantiated = true;
         };
         TestBedViewEngine.prototype._createCompilerAndModule = function () {
-            var e_2, _a;
+            var e_2, _f;
             var _this = this;
             var providers = this._providers.concat([{ provide: TestBed, useValue: this }]);
             var declarations = __spreadArray(__spreadArray([], __read(this._declarations)), __read(this._templateOverrides.map(function (entry) { return entry.templateOf; })));
@@ -2655,15 +2774,15 @@
             var compilerFactory = this.platform.injector.get(TestingCompilerFactory);
             this._compiler = compilerFactory.createTestingCompiler(this._compilerOptions);
             try {
-                for (var _b = __values(__spreadArray([this._testEnvAotSummaries], __read(this._aotSummaries))), _c = _b.next(); !_c.done; _c = _b.next()) {
-                    var summary = _c.value;
+                for (var _g = __values(__spreadArray([this._testEnvAotSummaries], __read(this._aotSummaries))), _h = _g.next(); !_h.done; _h = _g.next()) {
+                    var summary = _h.value;
                     this._compiler.loadAotSummaries(summary);
                 }
             }
             catch (e_2_1) { e_2 = { error: e_2_1 }; }
             finally {
                 try {
-                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                    if (_h && !_h.done && (_f = _g.return)) _f.call(_g);
                 }
                 finally { if (e_2) throw e_2.error; }
             }
@@ -2802,6 +2921,68 @@
             this._activeFixtures.push(fixture);
             return fixture;
         };
+        TestBedViewEngine.prototype.destroyActiveFixtures = function () {
+            var errorCount = 0;
+            this._activeFixtures.forEach(function (fixture) {
+                try {
+                    fixture.destroy();
+                }
+                catch (e) {
+                    errorCount++;
+                    console.error('Error during cleanup of component', {
+                        component: fixture.componentInstance,
+                        stacktrace: e,
+                    });
+                }
+            });
+            this._activeFixtures = [];
+            if (errorCount > 0 && this.shouldRethrowTeardownErrors()) {
+                throw Error(errorCount + " " + (errorCount === 1 ? 'component' : 'components') + " " +
+                    "threw errors during cleanup");
+            }
+        };
+        TestBedViewEngine.prototype.shouldRethrowTeardownErrors = function () {
+            var _a, _b;
+            var instanceOptions = this._instanceTeardownOptions;
+            var environmentOptions = TestBedViewEngine._environmentTeardownOptions;
+            // If the new teardown behavior hasn't been configured, preserve the old behavior.
+            if (!instanceOptions && !environmentOptions) {
+                return false;
+            }
+            // Otherwise use the configured behavior or default to rethrowing.
+            return (_b = (_a = instanceOptions === null || instanceOptions === void 0 ? void 0 : instanceOptions.rethrowErrors) !== null && _a !== void 0 ? _a : environmentOptions === null || environmentOptions === void 0 ? void 0 : environmentOptions.rethrowErrors) !== null && _b !== void 0 ? _b : true;
+        };
+        TestBedViewEngine.prototype.shouldTearDownTestingModule = function () {
+            var _a, _b, _c, _d;
+            return (_d = (_b = (_a = this._instanceTeardownOptions) === null || _a === void 0 ? void 0 : _a.destroyAfterEach) !== null && _b !== void 0 ? _b : (_c = TestBedViewEngine._environmentTeardownOptions) === null || _c === void 0 ? void 0 : _c.destroyAfterEach) !== null && _d !== void 0 ? _d : TEARDOWN_TESTING_MODULE_ON_DESTROY_DEFAULT;
+        };
+        TestBedViewEngine.prototype.tearDownTestingModule = function () {
+            var _a, _b, _c, _d, _e;
+            // If the module ref has already been destroyed, we won't be able to get a test renderer.
+            if (this._moduleRef === null) {
+                return;
+            }
+            // Resolve the renderer ahead of time, because we want to remove the root elements as the very
+            // last step, but the injector will be destroyed as a part of the module ref destruction.
+            var testRenderer = this.inject(TestComponentRenderer);
+            try {
+                this._moduleRef.destroy();
+            }
+            catch (e) {
+                if ((_d = (_b = (_a = this._instanceTeardownOptions) === null || _a === void 0 ? void 0 : _a.rethrowErrors) !== null && _b !== void 0 ? _b : (_c = TestBedViewEngine._environmentTeardownOptions) === null || _c === void 0 ? void 0 : _c.rethrowErrors) !== null && _d !== void 0 ? _d : true) {
+                    throw e;
+                }
+                else {
+                    console.error('Error during cleanup of a testing module', {
+                        component: this._moduleRef.instance,
+                        stacktrace: e,
+                    });
+                }
+            }
+            finally {
+                (_e = testRenderer === null || testRenderer === void 0 ? void 0 : testRenderer.removeAllRootElements) === null || _e === void 0 ? void 0 : _e.call(testRenderer);
+            }
+        };
         return TestBedViewEngine;
     }());
     /**
@@ -2902,10 +3083,22 @@
     var _global = (typeof window === 'undefined' ? global : window);
     // Reset the test providers and the fake async zone before each test.
     if (_global.beforeEach) {
-        _global.beforeEach(function () {
-            TestBed.resetTestingModule();
-            resetFakeAsyncZone();
-        });
+        _global.beforeEach(getCleanupHook(false));
+    }
+    // We provide both a `beforeEach` and `afterEach`, because the updated behavior for
+    // tearing down the module is supposed to run after the test so that we can associate
+    // teardown errors with the correct test.
+    if (_global.afterEach) {
+        _global.afterEach(getCleanupHook(true));
+    }
+    function getCleanupHook(expectedTeardownValue) {
+        return function () {
+            if (TestBed.shouldTearDownTestingModule() ===
+                expectedTeardownValue) {
+                TestBed.resetTestingModule();
+                resetFakeAsyncZone();
+            }
+        };
     }
     /**
      * This API should be removed. But doing so seems to break `google3` and so it requires a bit of