@angular/core
Version:
Angular - the core framework
312 lines • 45 kB
JavaScript
/**
* @license
* Copyright Google Inc. All Rights Reserved.
*
* 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
*/
// The formatter and CI disagree on how this import statement should be formatted. Both try to keep
// it on one line, too, which has gotten very hard to read & manage. So disable the formatter for
// this statement only.
// clang-format off
import { InjectFlags, Injector, NgZone, ɵRender3ComponentFactory as ComponentFactory, ɵflushModuleScopingQueueAsMuchAsPossible as flushModuleScopingQueueAsMuchAsPossible, ɵresetCompiledComponents as resetCompiledComponents, ɵstringify as stringify, } from '@angular/core';
// clang-format on
import { ComponentFixture } from './component_fixture';
import { ComponentFixtureAutoDetect, ComponentFixtureNoNgZone, TestComponentRenderer } from './test_bed_common';
import { R3TestBedCompiler } from './r3_test_bed_compiler';
var _nextRootElementId = 0;
var UNDEFINED = Symbol('UNDEFINED');
/**
* @description
* Configures and initializes environment for unit testing and provides methods for
* creating components and services in unit tests.
*
* TestBed is the primary api for writing unit tests for Angular applications and libraries.
*
* Note: Use `TestBed` in tests. It will be set to either `TestBedViewEngine` or `TestBedRender3`
* according to the compiler used.
*/
var TestBedRender3 = /** @class */ (function () {
function TestBedRender3() {
// Properties
this.platform = null;
this.ngModule = null;
this._compiler = null;
this._testModuleRef = null;
this._activeFixtures = [];
this._globalCompilationChecked = false;
}
/**
* Initialize the environment for testing with a compiler factory, a PlatformRef, and an
* angular module. These are common to every test in the suite.
*
* This may only be called once, to set up the common providers for the current test
* suite on the current platform. If you absolutely need to change the providers,
* first use `resetTestEnvironment`.
*
* Test modules and platforms for individual platforms are available from
* '@angular/<platform_name>/testing'.
*
* @publicApi
*/
TestBedRender3.initTestEnvironment = function (ngModule, platform, aotSummaries) {
var testBed = _getTestBedRender3();
testBed.initTestEnvironment(ngModule, platform, aotSummaries);
return testBed;
};
/**
* Reset the providers for the test injector.
*
* @publicApi
*/
TestBedRender3.resetTestEnvironment = function () { _getTestBedRender3().resetTestEnvironment(); };
TestBedRender3.configureCompiler = function (config) {
_getTestBedRender3().configureCompiler(config);
return TestBedRender3;
};
/**
* Allows overriding default providers, directives, pipes, modules of the test injector,
* which are defined in test_injector.js
*/
TestBedRender3.configureTestingModule = function (moduleDef) {
_getTestBedRender3().configureTestingModule(moduleDef);
return TestBedRender3;
};
/**
* Compile components with a `templateUrl` for the test's NgModule.
* It is necessary to call this function
* as fetching urls is asynchronous.
*/
TestBedRender3.compileComponents = function () { return _getTestBedRender3().compileComponents(); };
TestBedRender3.overrideModule = function (ngModule, override) {
_getTestBedRender3().overrideModule(ngModule, override);
return TestBedRender3;
};
TestBedRender3.overrideComponent = function (component, override) {
_getTestBedRender3().overrideComponent(component, override);
return TestBedRender3;
};
TestBedRender3.overrideDirective = function (directive, override) {
_getTestBedRender3().overrideDirective(directive, override);
return TestBedRender3;
};
TestBedRender3.overridePipe = function (pipe, override) {
_getTestBedRender3().overridePipe(pipe, override);
return TestBedRender3;
};
TestBedRender3.overrideTemplate = function (component, template) {
_getTestBedRender3().overrideComponent(component, { set: { template: template, templateUrl: null } });
return TestBedRender3;
};
/**
* Overrides the template of the given component, compiling the template
* in the context of the TestingModule.
*
* Note: This works for JIT and AOTed components as well.
*/
TestBedRender3.overrideTemplateUsingTestingModule = function (component, template) {
_getTestBedRender3().overrideTemplateUsingTestingModule(component, template);
return TestBedRender3;
};
TestBedRender3.overrideProvider = function (token, provider) {
_getTestBedRender3().overrideProvider(token, provider);
return TestBedRender3;
};
TestBedRender3.get = function (token, notFoundValue, flags) {
if (notFoundValue === void 0) { notFoundValue = Injector.THROW_IF_NOT_FOUND; }
if (flags === void 0) { flags = InjectFlags.Default; }
return _getTestBedRender3().get(token, notFoundValue);
};
TestBedRender3.createComponent = function (component) {
return _getTestBedRender3().createComponent(component);
};
TestBedRender3.resetTestingModule = function () {
_getTestBedRender3().resetTestingModule();
return TestBedRender3;
};
/**
* Initialize the environment for testing with a compiler factory, a PlatformRef, and an
* angular module. These are common to every test in the suite.
*
* This may only be called once, to set up the common providers for the current test
* suite on the current platform. If you absolutely need to change the providers,
* first use `resetTestEnvironment`.
*
* Test modules and platforms for individual platforms are available from
* '@angular/<platform_name>/testing'.
*
* @publicApi
*/
TestBedRender3.prototype.initTestEnvironment = function (ngModule, platform, aotSummaries) {
if (this.platform || this.ngModule) {
throw new Error('Cannot set base providers because it has already been called');
}
this.platform = platform;
this.ngModule = ngModule;
this._compiler = new R3TestBedCompiler(this.platform, this.ngModule);
};
/**
* Reset the providers for the test injector.
*
* @publicApi
*/
TestBedRender3.prototype.resetTestEnvironment = function () {
this.resetTestingModule();
this._compiler = null;
this.platform = null;
this.ngModule = null;
};
TestBedRender3.prototype.resetTestingModule = function () {
this.checkGlobalCompilationFinished();
resetCompiledComponents();
if (this._compiler !== null) {
this.compiler.restoreOriginalState();
}
this._compiler = new R3TestBedCompiler(this.platform, this.ngModule);
this._testModuleRef = null;
this.destroyActiveFixtures();
};
TestBedRender3.prototype.configureCompiler = function (config) {
if (config.useJit != null) {
throw new Error('the Render3 compiler JiT mode is not configurable !');
}
if (config.providers !== undefined) {
this.compiler.setCompilerProviders(config.providers);
}
};
TestBedRender3.prototype.configureTestingModule = function (moduleDef) {
this.assertNotInstantiated('R3TestBed.configureTestingModule', 'configure the test module');
this.compiler.configureTestingModule(moduleDef);
};
TestBedRender3.prototype.compileComponents = function () { return this.compiler.compileComponents(); };
TestBedRender3.prototype.get = function (token, notFoundValue, flags) {
if (notFoundValue === void 0) { notFoundValue = Injector.THROW_IF_NOT_FOUND; }
if (flags === void 0) { flags = InjectFlags.Default; }
if (token === TestBedRender3) {
return this;
}
var result = this.testModuleRef.injector.get(token, UNDEFINED, flags);
return result === UNDEFINED ? this.compiler.injector.get(token, notFoundValue, flags) : result;
};
TestBedRender3.prototype.execute = function (tokens, fn, context) {
var _this = this;
var params = tokens.map(function (t) { return _this.get(t); });
return fn.apply(context, params);
};
TestBedRender3.prototype.overrideModule = function (ngModule, override) {
this.assertNotInstantiated('overrideModule', 'override module metadata');
this.compiler.overrideModule(ngModule, override);
};
TestBedRender3.prototype.overrideComponent = function (component, override) {
this.assertNotInstantiated('overrideComponent', 'override component metadata');
this.compiler.overrideComponent(component, override);
};
TestBedRender3.prototype.overrideTemplateUsingTestingModule = function (component, template) {
this.assertNotInstantiated('R3TestBed.overrideTemplateUsingTestingModule', 'Cannot override template when the test module has already been instantiated');
this.compiler.overrideTemplateUsingTestingModule(component, template);
};
TestBedRender3.prototype.overrideDirective = function (directive, override) {
this.assertNotInstantiated('overrideDirective', 'override directive metadata');
this.compiler.overrideDirective(directive, override);
};
TestBedRender3.prototype.overridePipe = function (pipe, override) {
this.assertNotInstantiated('overridePipe', 'override pipe metadata');
this.compiler.overridePipe(pipe, override);
};
/**
* Overwrites all providers for the given token with the given provider definition.
*/
TestBedRender3.prototype.overrideProvider = function (token, provider) {
this.compiler.overrideProvider(token, provider);
};
TestBedRender3.prototype.createComponent = function (type) {
var _this = this;
var testComponentRenderer = this.get(TestComponentRenderer);
var rootElId = "root-ng-internal-isolated-" + _nextRootElementId++;
testComponentRenderer.insertRootElement(rootElId);
var componentDef = type.ngComponentDef;
if (!componentDef) {
throw new Error("It looks like '" + stringify(type) + "' has not been IVY compiled - it has no 'ngComponentDef' field");
}
// TODO: Don't cast as `any`, proper type is boolean[]
var noNgZone = this.get(ComponentFixtureNoNgZone, false);
// TODO: Don't cast as `any`, proper type is boolean[]
var autoDetect = this.get(ComponentFixtureAutoDetect, false);
var ngZone = noNgZone ? null : this.get(NgZone, null);
var componentFactory = new ComponentFactory(componentDef);
var initComponent = function () {
var componentRef = componentFactory.create(Injector.NULL, [], "#" + rootElId, _this.testModuleRef);
return new ComponentFixture(componentRef, ngZone, autoDetect);
};
var fixture = ngZone ? ngZone.run(initComponent) : initComponent();
this._activeFixtures.push(fixture);
return fixture;
};
Object.defineProperty(TestBedRender3.prototype, "compiler", {
get: function () {
if (this._compiler === null) {
throw new Error("Need to call TestBed.initTestEnvironment() first");
}
return this._compiler;
},
enumerable: true,
configurable: true
});
Object.defineProperty(TestBedRender3.prototype, "testModuleRef", {
get: function () {
if (this._testModuleRef === null) {
this._testModuleRef = this.compiler.finalize();
}
return this._testModuleRef;
},
enumerable: true,
configurable: true
});
TestBedRender3.prototype.assertNotInstantiated = function (methodName, methodDescription) {
if (this._testModuleRef !== null) {
throw new Error("Cannot " + methodDescription + " when the test module has already been instantiated. " +
("Make sure you are not using `inject` before `" + methodName + "`."));
}
};
/**
* Check whether the module scoping queue should be flushed, and flush it if needed.
*
* When the TestBed is reset, it clears the JIT module compilation queue, cancelling any
* in-progress module compilation. This creates a potential hazard - the very first time the
* TestBed is initialized (or if it's reset without being initialized), there may be pending
* compilations of modules declared in global scope. These compilations should be finished.
*
* To ensure that globally declared modules have their components scoped properly, this function
* is called whenever TestBed is initialized or reset. The _first_ time that this happens, prior
* to any other operations, the scoping queue is flushed.
*/
TestBedRender3.prototype.checkGlobalCompilationFinished = function () {
// Checking _testNgModuleRef is null should not be necessary, but is left in as an additional
// guard that compilations queued in tests (after instantiation) are never flushed accidentally.
if (!this._globalCompilationChecked && this._testModuleRef === null) {
flushModuleScopingQueueAsMuchAsPossible();
}
this._globalCompilationChecked = true;
};
TestBedRender3.prototype.destroyActiveFixtures = function () {
this._activeFixtures.forEach(function (fixture) {
try {
fixture.destroy();
}
catch (e) {
console.error('Error during cleanup of component', {
component: fixture.componentInstance,
stacktrace: e,
});
}
});
this._activeFixtures = [];
};
return TestBedRender3;
}());
export { TestBedRender3 };
var testBed;
export function _getTestBedRender3() {
return testBed = testBed || new TestBedRender3();
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"r3_test_bed.js","sourceRoot":"","sources":["../../../../../../../../../../../packages/core/testing/src/r3_test_bed.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,mGAAmG;AACnG,iGAAiG;AACjG,uBAAuB;AACvB,mBAAmB;AACnB,OAAO,EAGL,WAAW,EAEX,QAAQ,EAER,MAAM,EAIN,wBAAwB,IAAI,gBAAgB,EAE5C,wCAAwC,IAAI,uCAAuC,EACnF,wBAAwB,IAAI,uBAAuB,EACnD,UAAU,IAAI,SAAS,GACxB,MAAM,eAAe,CAAC;AACvB,kBAAkB;AAElB,OAAO,EAAC,gBAAgB,EAAC,MAAM,qBAAqB,CAAC;AAGrD,OAAO,EAAC,0BAA0B,EAAE,wBAAwB,EAAiB,qBAAqB,EAAqB,MAAM,mBAAmB,CAAC;AACjJ,OAAO,EAAC,iBAAiB,EAAC,MAAM,wBAAwB,CAAC;AAEzD,IAAI,kBAAkB,GAAG,CAAC,CAAC;AAE3B,IAAM,SAAS,GAAW,MAAM,CAAC,WAAW,CAAC,CAAC;AAE9C;;;;;;;;;GASG;AACH;IAAA;QAyHE,aAAa;QAEb,aAAQ,GAAgB,IAAM,CAAC;QAC/B,aAAQ,GAA0B,IAAM,CAAC;QAEjC,cAAS,GAA2B,IAAI,CAAC;QACzC,mBAAc,GAA0B,IAAI,CAAC;QAE7C,oBAAe,GAA4B,EAAE,CAAC;QAC9C,8BAAyB,GAAG,KAAK,CAAC;IA2M5C,CAAC;IA5UC;;;;;;;;;;;;OAYG;IACI,kCAAmB,GAA1B,UACI,QAA+B,EAAE,QAAqB,EAAE,YAA0B;QACpF,IAAM,OAAO,GAAG,kBAAkB,EAAE,CAAC;QACrC,OAAO,CAAC,mBAAmB,CAAC,QAAQ,EAAE,QAAQ,EAAE,YAAY,CAAC,CAAC;QAC9D,OAAO,OAAO,CAAC;IACjB,CAAC;IAED;;;;OAIG;IACI,mCAAoB,GAA3B,cAAsC,kBAAkB,EAAE,CAAC,oBAAoB,EAAE,CAAC,CAAC,CAAC;IAE7E,gCAAiB,GAAxB,UAAyB,MAA8C;QACrE,kBAAkB,EAAE,CAAC,iBAAiB,CAAC,MAAM,CAAC,CAAC;QAC/C,OAAO,cAAsC,CAAC;IAChD,CAAC;IAED;;;OAGG;IACI,qCAAsB,GAA7B,UAA8B,SAA6B;QACzD,kBAAkB,EAAE,CAAC,sBAAsB,CAAC,SAAS,CAAC,CAAC;QACvD,OAAO,cAAsC,CAAC;IAChD,CAAC;IAED;;;;OAIG;IACI,gCAAiB,GAAxB,cAA2C,OAAO,kBAAkB,EAAE,CAAC,iBAAiB,EAAE,CAAC,CAAC,CAAC;IAEtF,6BAAc,GAArB,UAAsB,QAAmB,EAAE,QAAoC;QAC7E,kBAAkB,EAAE,CAAC,cAAc,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAC;QACxD,OAAO,cAAsC,CAAC;IAChD,CAAC;IAEM,gCAAiB,GAAxB,UAAyB,SAAoB,EAAE,QAAqC;QAElF,kBAAkB,EAAE,CAAC,iBAAiB,CAAC,SAAS,EAAE,QAAQ,CAAC,CAAC;QAC5D,OAAO,cAAsC,CAAC;IAChD,CAAC;IAEM,gCAAiB,GAAxB,UAAyB,SAAoB,EAAE,QAAqC;QAElF,kBAAkB,EAAE,CAAC,iBAAiB,CAAC,SAAS,EAAE,QAAQ,CAAC,CAAC;QAC5D,OAAO,cAAsC,CAAC;IAChD,CAAC;IAEM,2BAAY,GAAnB,UAAoB,IAAe,EAAE,QAAgC;QACnE,kBAAkB,EAAE,CAAC,YAAY,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC;QAClD,OAAO,cAAsC,CAAC;IAChD,CAAC;IAEM,+BAAgB,GAAvB,UAAwB,SAAoB,EAAE,QAAgB;QAC5D,kBAAkB,EAAE,CAAC,iBAAiB,CAAC,SAAS,EAAE,EAAC,GAAG,EAAE,EAAC,QAAQ,UAAA,EAAE,WAAW,EAAE,IAAM,EAAC,EAAC,CAAC,CAAC;QAC1F,OAAO,cAAsC,CAAC;IAChD,CAAC;IAED;;;;;OAKG;IACI,iDAAkC,GAAzC,UAA0C,SAAoB,EAAE,QAAgB;QAC9E,kBAAkB,EAAE,CAAC,kCAAkC,CAAC,SAAS,EAAE,QAAQ,CAAC,CAAC;QAC7E,OAAO,cAAsC,CAAC;IAChD,CAAC;IAOM,+BAAgB,GAAvB,UAAwB,KAAU,EAAE,QAInC;QACC,kBAAkB,EAAE,CAAC,gBAAgB,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC;QACvD,OAAO,cAAsC,CAAC;IAChD,CAAC;IAOM,kBAAG,GAAV,UACI,KAAU,EAAE,aAAgD,EAC5D,KAAwC;QAD5B,8BAAA,EAAA,gBAAqB,QAAQ,CAAC,kBAAkB;QAC5D,sBAAA,EAAA,QAAqB,WAAW,CAAC,OAAO;QAC1C,OAAO,kBAAkB,EAAE,CAAC,GAAG,CAAC,KAAK,EAAE,aAAa,CAAC,CAAC;IACxD,CAAC;IAEM,8BAAe,GAAtB,UAA0B,SAAkB;QAC1C,OAAO,kBAAkB,EAAE,CAAC,eAAe,CAAC,SAAS,CAAC,CAAC;IACzD,CAAC;IAEM,iCAAkB,GAAzB;QACE,kBAAkB,EAAE,CAAC,kBAAkB,EAAE,CAAC;QAC1C,OAAO,cAAsC,CAAC;IAChD,CAAC;IAaD;;;;;;;;;;;;OAYG;IACH,4CAAmB,GAAnB,UACI,QAA+B,EAAE,QAAqB,EAAE,YAA0B;QACpF,IAAI,IAAI,CAAC,QAAQ,IAAI,IAAI,CAAC,QAAQ,EAAE;YAClC,MAAM,IAAI,KAAK,CAAC,8DAA8D,CAAC,CAAC;SACjF;QACD,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC;QACzB,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC;QACzB,IAAI,CAAC,SAAS,GAAG,IAAI,iBAAiB,CAAC,IAAI,CAAC,QAAQ,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAC;IACvE,CAAC;IAED;;;;OAIG;IACH,6CAAoB,GAApB;QACE,IAAI,CAAC,kBAAkB,EAAE,CAAC;QAC1B,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC;QACtB,IAAI,CAAC,QAAQ,GAAG,IAAM,CAAC;QACvB,IAAI,CAAC,QAAQ,GAAG,IAAM,CAAC;IACzB,CAAC;IAED,2CAAkB,GAAlB;QACE,IAAI,CAAC,8BAA8B,EAAE,CAAC;QACtC,uBAAuB,EAAE,CAAC;QAC1B,IAAI,IAAI,CAAC,SAAS,KAAK,IAAI,EAAE;YAC3B,IAAI,CAAC,QAAQ,CAAC,oBAAoB,EAAE,CAAC;SACtC;QACD,IAAI,CAAC,SAAS,GAAG,IAAI,iBAAiB,CAAC,IAAI,CAAC,QAAQ,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAC;QACrE,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC;QAC3B,IAAI,CAAC,qBAAqB,EAAE,CAAC;IAC/B,CAAC;IAED,0CAAiB,GAAjB,UAAkB,MAA8C;QAC9D,IAAI,MAAM,CAAC,MAAM,IAAI,IAAI,EAAE;YACzB,MAAM,IAAI,KAAK,CAAC,qDAAqD,CAAC,CAAC;SACxE;QAED,IAAI,MAAM,CAAC,SAAS,KAAK,SAAS,EAAE;YAClC,IAAI,CAAC,QAAQ,CAAC,oBAAoB,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC;SACtD;IACH,CAAC;IAED,+CAAsB,GAAtB,UAAuB,SAA6B;QAClD,IAAI,CAAC,qBAAqB,CAAC,kCAAkC,EAAE,2BAA2B,CAAC,CAAC;QAC5F,IAAI,CAAC,QAAQ,CAAC,sBAAsB,CAAC,SAAS,CAAC,CAAC;IAClD,CAAC;IAED,0CAAiB,GAAjB,cAAoC,OAAO,IAAI,CAAC,QAAQ,CAAC,iBAAiB,EAAE,CAAC,CAAC,CAAC;IAO/E,4BAAG,GAAH,UAAI,KAAU,EAAE,aAAgD,EAC5D,KAAwC;QAD5B,8BAAA,EAAA,gBAAqB,QAAQ,CAAC,kBAAkB;QAC5D,sBAAA,EAAA,QAAqB,WAAW,CAAC,OAAO;QAC1C,IAAI,KAAK,KAAK,cAAc,EAAE;YAC5B,OAAO,IAAI,CAAC;SACb;QACD,IAAM,MAAM,GAAG,IAAI,CAAC,aAAa,CAAC,QAAQ,CAAC,GAAG,CAAC,KAAK,EAAE,SAAS,EAAE,KAAK,CAAC,CAAC;QACxE,OAAO,MAAM,KAAK,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,GAAG,CAAC,KAAK,EAAE,aAAa,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC;IACjG,CAAC;IAED,gCAAO,GAAP,UAAQ,MAAa,EAAE,EAAY,EAAE,OAAa;QAAlD,iBAGC;QAFC,IAAM,MAAM,GAAG,MAAM,CAAC,GAAG,CAAC,UAAA,CAAC,IAAI,OAAA,KAAI,CAAC,GAAG,CAAC,CAAC,CAAC,EAAX,CAAW,CAAC,CAAC;QAC5C,OAAO,EAAE,CAAC,KAAK,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC;IACnC,CAAC;IAED,uCAAc,GAAd,UAAe,QAAmB,EAAE,QAAoC;QACtE,IAAI,CAAC,qBAAqB,CAAC,gBAAgB,EAAE,0BAA0B,CAAC,CAAC;QACzE,IAAI,CAAC,QAAQ,CAAC,cAAc,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAC;IACnD,CAAC;IAED,0CAAiB,GAAjB,UAAkB,SAAoB,EAAE,QAAqC;QAC3E,IAAI,CAAC,qBAAqB,CAAC,mBAAmB,EAAE,6BAA6B,CAAC,CAAC;QAC/E,IAAI,CAAC,QAAQ,CAAC,iBAAiB,CAAC,SAAS,EAAE,QAAQ,CAAC,CAAC;IACvD,CAAC;IAED,2DAAkC,GAAlC,UAAmC,SAAoB,EAAE,QAAgB;QACvE,IAAI,CAAC,qBAAqB,CACtB,8CAA8C,EAC9C,6EAA6E,CAAC,CAAC;QACnF,IAAI,CAAC,QAAQ,CAAC,kCAAkC,CAAC,SAAS,EAAE,QAAQ,CAAC,CAAC;IACxE,CAAC;IAED,0CAAiB,GAAjB,UAAkB,SAAoB,EAAE,QAAqC;QAC3E,IAAI,CAAC,qBAAqB,CAAC,mBAAmB,EAAE,6BAA6B,CAAC,CAAC;QAC/E,IAAI,CAAC,QAAQ,CAAC,iBAAiB,CAAC,SAAS,EAAE,QAAQ,CAAC,CAAC;IACvD,CAAC;IAED,qCAAY,GAAZ,UAAa,IAAe,EAAE,QAAgC;QAC5D,IAAI,CAAC,qBAAqB,CAAC,cAAc,EAAE,wBAAwB,CAAC,CAAC;QACrE,IAAI,CAAC,QAAQ,CAAC,YAAY,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC;IAC7C,CAAC;IAED;;OAEG;IACH,yCAAgB,GAAhB,UAAiB,KAAU,EAAE,QAA+D;QAE1F,IAAI,CAAC,QAAQ,CAAC,gBAAgB,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC;IAClD,CAAC;IAED,wCAAe,GAAf,UAAmB,IAAa;QAAhC,iBA0BC;QAzBC,IAAM,qBAAqB,GAA0B,IAAI,CAAC,GAAG,CAAC,qBAAqB,CAAC,CAAC;QACrF,IAAM,QAAQ,GAAG,+BAA6B,kBAAkB,EAAI,CAAC;QACrE,qBAAqB,CAAC,iBAAiB,CAAC,QAAQ,CAAC,CAAC;QAElD,IAAM,YAAY,GAAI,IAAY,CAAC,cAAc,CAAC;QAElD,IAAI,CAAC,YAAY,EAAE;YACjB,MAAM,IAAI,KAAK,CACX,oBAAkB,SAAS,CAAC,IAAI,CAAC,mEAAgE,CAAC,CAAC;SACxG;QAED,sDAAsD;QACtD,IAAM,QAAQ,GAAG,IAAI,CAAC,GAAG,CAAC,wBAA+B,EAAE,KAAK,CAAC,CAAC;QAClE,sDAAsD;QACtD,IAAM,UAAU,GAAY,IAAI,CAAC,GAAG,CAAC,0BAAiC,EAAE,KAAK,CAAC,CAAC;QAC/E,IAAM,MAAM,GAAgB,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,MAA2B,EAAE,IAAI,CAAC,CAAC;QAC1F,IAAM,gBAAgB,GAAG,IAAI,gBAAgB,CAAC,YAAY,CAAC,CAAC;QAC5D,IAAM,aAAa,GAAG;YACpB,IAAM,YAAY,GACd,gBAAgB,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAE,EAAE,EAAE,MAAI,QAAU,EAAE,KAAI,CAAC,aAAa,CAAC,CAAC;YACnF,OAAO,IAAI,gBAAgB,CAAM,YAAY,EAAE,MAAM,EAAE,UAAU,CAAC,CAAC;QACrE,CAAC,CAAC;QACF,IAAM,OAAO,GAAG,MAAM,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,aAAa,EAAE,CAAC;QACrE,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QACnC,OAAO,OAAO,CAAC;IACjB,CAAC;IAED,sBAAY,oCAAQ;aAApB;YACE,IAAI,IAAI,CAAC,SAAS,KAAK,IAAI,EAAE;gBAC3B,MAAM,IAAI,KAAK,CAAC,kDAAkD,CAAC,CAAC;aACrE;YACD,OAAO,IAAI,CAAC,SAAS,CAAC;QACxB,CAAC;;;OAAA;IAED,sBAAY,yCAAa;aAAzB;YACE,IAAI,IAAI,CAAC,cAAc,KAAK,IAAI,EAAE;gBAChC,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC,QAAQ,CAAC,QAAQ,EAAE,CAAC;aAChD;YACD,OAAO,IAAI,CAAC,cAAc,CAAC;QAC7B,CAAC;;;OAAA;IAEO,8CAAqB,GAA7B,UAA8B,UAAkB,EAAE,iBAAyB;QACzE,IAAI,IAAI,CAAC,cAAc,KAAK,IAAI,EAAE;YAChC,MAAM,IAAI,KAAK,CACX,YAAU,iBAAiB,0DAAuD;iBAClF,kDAAmD,UAAU,OAAK,CAAA,CAAC,CAAC;SACzE;IACH,CAAC;IAED;;;;;;;;;;;OAWG;IACK,uDAA8B,GAAtC;QACE,6FAA6F;QAC7F,gGAAgG;QAChG,IAAI,CAAC,IAAI,CAAC,yBAAyB,IAAI,IAAI,CAAC,cAAc,KAAK,IAAI,EAAE;YACnE,uCAAuC,EAAE,CAAC;SAC3C;QACD,IAAI,CAAC,yBAAyB,GAAG,IAAI,CAAC;IACxC,CAAC;IAEO,8CAAqB,GAA7B;QACE,IAAI,CAAC,eAAe,CAAC,OAAO,CAAC,UAAC,OAAO;YACnC,IAAI;gBACF,OAAO,CAAC,OAAO,EAAE,CAAC;aACnB;YAAC,OAAO,CAAC,EAAE;gBACV,OAAO,CAAC,KAAK,CAAC,mCAAmC,EAAE;oBACjD,SAAS,EAAE,OAAO,CAAC,iBAAiB;oBACpC,UAAU,EAAE,CAAC;iBACd,CAAC,CAAC;aACJ;QACH,CAAC,CAAC,CAAC;QACH,IAAI,CAAC,eAAe,GAAG,EAAE,CAAC;IAC5B,CAAC;IACH,qBAAC;AAAD,CAAC,AA7UD,IA6UC;;AAED,IAAI,OAAuB,CAAC;AAE5B,MAAM,UAAU,kBAAkB;IAChC,OAAO,OAAO,GAAG,OAAO,IAAI,IAAI,cAAc,EAAE,CAAC;AACnD,CAAC","sourcesContent":["/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\n// The formatter and CI disagree on how this import statement should be formatted. Both try to keep\n// it on one line, too, which has gotten very hard to read & manage. So disable the formatter for\n// this statement only.\n// clang-format off\nimport {\n  Component,\n  Directive,\n  InjectFlags,\n  InjectionToken,\n  Injector,\n  NgModule,\n  NgZone,\n  Pipe,\n  PlatformRef,\n  Type,\n  ɵRender3ComponentFactory as ComponentFactory,\n  ɵRender3NgModuleRef as NgModuleRef,\n  ɵflushModuleScopingQueueAsMuchAsPossible as flushModuleScopingQueueAsMuchAsPossible,\n  ɵresetCompiledComponents as resetCompiledComponents,\n  ɵstringify as stringify,\n} from '@angular/core';\n// clang-format on\n\nimport {ComponentFixture} from './component_fixture';\nimport {MetadataOverride} from './metadata_override';\nimport {TestBed} from './test_bed';\nimport {ComponentFixtureAutoDetect, ComponentFixtureNoNgZone, TestBedStatic, TestComponentRenderer, TestModuleMetadata} from './test_bed_common';\nimport {R3TestBedCompiler} from './r3_test_bed_compiler';\n\nlet _nextRootElementId = 0;\n\nconst UNDEFINED: Symbol = Symbol('UNDEFINED');\n\n/**\n * @description\n * Configures and initializes environment for unit testing and provides methods for\n * creating components and services in unit tests.\n *\n * TestBed is the primary api for writing unit tests for Angular applications and libraries.\n *\n * Note: Use `TestBed` in tests. It will be set to either `TestBedViewEngine` or `TestBedRender3`\n * according to the compiler used.\n */\nexport class TestBedRender3 implements Injector, TestBed {\n  /**\n   * Initialize the environment for testing with a compiler factory, a PlatformRef, and an\n   * angular module. These are common to every test in the suite.\n   *\n   * This may only be called once, to set up the common providers for the current test\n   * suite on the current platform. If you absolutely need to change the providers,\n   * first use `resetTestEnvironment`.\n   *\n   * Test modules and platforms for individual platforms are available from\n   * '@angular/<platform_name>/testing'.\n   *\n   * @publicApi\n   */\n  static initTestEnvironment(\n      ngModule: Type<any>|Type<any>[], platform: PlatformRef, aotSummaries?: () => any[]): TestBed {\n    const testBed = _getTestBedRender3();\n    testBed.initTestEnvironment(ngModule, platform, aotSummaries);\n    return testBed;\n  }\n\n  /**\n   * Reset the providers for the test injector.\n   *\n   * @publicApi\n   */\n  static resetTestEnvironment(): void { _getTestBedRender3().resetTestEnvironment(); }\n\n  static configureCompiler(config: {providers?: any[]; useJit?: boolean;}): TestBedStatic {\n    _getTestBedRender3().configureCompiler(config);\n    return TestBedRender3 as any as TestBedStatic;\n  }\n\n  /**\n   * Allows overriding default providers, directives, pipes, modules of the test injector,\n   * which are defined in test_injector.js\n   */\n  static configureTestingModule(moduleDef: TestModuleMetadata): TestBedStatic {\n    _getTestBedRender3().configureTestingModule(moduleDef);\n    return TestBedRender3 as any as TestBedStatic;\n  }\n\n  /**\n   * Compile components with a `templateUrl` for the test's NgModule.\n   * It is necessary to call this function\n   * as fetching urls is asynchronous.\n   */\n  static compileComponents(): Promise<any> { return _getTestBedRender3().compileComponents(); }\n\n  static overrideModule(ngModule: Type<any>, override: MetadataOverride<NgModule>): TestBedStatic {\n    _getTestBedRender3().overrideModule(ngModule, override);\n    return TestBedRender3 as any as TestBedStatic;\n  }\n\n  static overrideComponent(component: Type<any>, override: MetadataOverride<Component>):\n      TestBedStatic {\n    _getTestBedRender3().overrideComponent(component, override);\n    return TestBedRender3 as any as TestBedStatic;\n  }\n\n  static overrideDirective(directive: Type<any>, override: MetadataOverride<Directive>):\n      TestBedStatic {\n    _getTestBedRender3().overrideDirective(directive, override);\n    return TestBedRender3 as any as TestBedStatic;\n  }\n\n  static overridePipe(pipe: Type<any>, override: MetadataOverride<Pipe>): TestBedStatic {\n    _getTestBedRender3().overridePipe(pipe, override);\n    return TestBedRender3 as any as TestBedStatic;\n  }\n\n  static overrideTemplate(component: Type<any>, template: string): TestBedStatic {\n    _getTestBedRender3().overrideComponent(component, {set: {template, templateUrl: null !}});\n    return TestBedRender3 as any as TestBedStatic;\n  }\n\n  /**\n   * Overrides the template of the given component, compiling the template\n   * in the context of the TestingModule.\n   *\n   * Note: This works for JIT and AOTed components as well.\n   */\n  static overrideTemplateUsingTestingModule(component: Type<any>, template: string): TestBedStatic {\n    _getTestBedRender3().overrideTemplateUsingTestingModule(component, template);\n    return TestBedRender3 as any as TestBedStatic;\n  }\n\n  static overrideProvider(token: any, provider: {\n    useFactory: Function,\n    deps: any[],\n  }): TestBedStatic;\n  static overrideProvider(token: any, provider: {useValue: any;}): TestBedStatic;\n  static overrideProvider(token: any, provider: {\n    useFactory?: Function,\n    useValue?: any,\n    deps?: any[],\n  }): TestBedStatic {\n    _getTestBedRender3().overrideProvider(token, provider);\n    return TestBedRender3 as any as TestBedStatic;\n  }\n\n  static get<T>(token: Type<T>|InjectionToken<T>, notFoundValue?: T, flags?: InjectFlags): any;\n  /**\n   * @deprecated from v8.0.0 use Type<T> or InjectionToken<T>\n   */\n  static get(token: any, notFoundValue?: any): any;\n  static get(\n      token: any, notFoundValue: any = Injector.THROW_IF_NOT_FOUND,\n      flags: InjectFlags = InjectFlags.Default): any {\n    return _getTestBedRender3().get(token, notFoundValue);\n  }\n\n  static createComponent<T>(component: Type<T>): ComponentFixture<T> {\n    return _getTestBedRender3().createComponent(component);\n  }\n\n  static resetTestingModule(): TestBedStatic {\n    _getTestBedRender3().resetTestingModule();\n    return TestBedRender3 as any as TestBedStatic;\n  }\n\n  // Properties\n\n  platform: PlatformRef = null !;\n  ngModule: Type<any>|Type<any>[] = null !;\n\n  private _compiler: R3TestBedCompiler|null = null;\n  private _testModuleRef: NgModuleRef<any>|null = null;\n\n  private _activeFixtures: ComponentFixture<any>[] = [];\n  private _globalCompilationChecked = false;\n\n  /**\n   * Initialize the environment for testing with a compiler factory, a PlatformRef, and an\n   * angular module. These are common to every test in the suite.\n   *\n   * This may only be called once, to set up the common providers for the current test\n   * suite on the current platform. If you absolutely need to change the providers,\n   * first use `resetTestEnvironment`.\n   *\n   * Test modules and platforms for individual platforms are available from\n   * '@angular/<platform_name>/testing'.\n   *\n   * @publicApi\n   */\n  initTestEnvironment(\n      ngModule: Type<any>|Type<any>[], platform: PlatformRef, aotSummaries?: () => any[]): void {\n    if (this.platform || this.ngModule) {\n      throw new Error('Cannot set base providers because it has already been called');\n    }\n    this.platform = platform;\n    this.ngModule = ngModule;\n    this._compiler = new R3TestBedCompiler(this.platform, this.ngModule);\n  }\n\n  /**\n   * Reset the providers for the test injector.\n   *\n   * @publicApi\n   */\n  resetTestEnvironment(): void {\n    this.resetTestingModule();\n    this._compiler = null;\n    this.platform = null !;\n    this.ngModule = null !;\n  }\n\n  resetTestingModule(): void {\n    this.checkGlobalCompilationFinished();\n    resetCompiledComponents();\n    if (this._compiler !== null) {\n      this.compiler.restoreOriginalState();\n    }\n    this._compiler = new R3TestBedCompiler(this.platform, this.ngModule);\n    this._testModuleRef = null;\n    this.destroyActiveFixtures();\n  }\n\n  configureCompiler(config: {providers?: any[]; useJit?: boolean;}): void {\n    if (config.useJit != null) {\n      throw new Error('the Render3 compiler JiT mode is not configurable !');\n    }\n\n    if (config.providers !== undefined) {\n      this.compiler.setCompilerProviders(config.providers);\n    }\n  }\n\n  configureTestingModule(moduleDef: TestModuleMetadata): void {\n    this.assertNotInstantiated('R3TestBed.configureTestingModule', 'configure the test module');\n    this.compiler.configureTestingModule(moduleDef);\n  }\n\n  compileComponents(): Promise<any> { return this.compiler.compileComponents(); }\n\n  get<T>(token: Type<T>|InjectionToken<T>, notFoundValue?: T, flags?: InjectFlags): any;\n  /**\n   * @deprecated from v8.0.0 use Type<T> or InjectionToken<T>\n   */\n  get(token: any, notFoundValue?: any): any;\n  get(token: any, notFoundValue: any = Injector.THROW_IF_NOT_FOUND,\n      flags: InjectFlags = InjectFlags.Default): any {\n    if (token === TestBedRender3) {\n      return this;\n    }\n    const result = this.testModuleRef.injector.get(token, UNDEFINED, flags);\n    return result === UNDEFINED ? this.compiler.injector.get(token, notFoundValue, flags) : result;\n  }\n\n  execute(tokens: any[], fn: Function, context?: any): any {\n    const params = tokens.map(t => this.get(t));\n    return fn.apply(context, params);\n  }\n\n  overrideModule(ngModule: Type<any>, override: MetadataOverride<NgModule>): void {\n    this.assertNotInstantiated('overrideModule', 'override module metadata');\n    this.compiler.overrideModule(ngModule, override);\n  }\n\n  overrideComponent(component: Type<any>, override: MetadataOverride<Component>): void {\n    this.assertNotInstantiated('overrideComponent', 'override component metadata');\n    this.compiler.overrideComponent(component, override);\n  }\n\n  overrideTemplateUsingTestingModule(component: Type<any>, template: string): void {\n    this.assertNotInstantiated(\n        'R3TestBed.overrideTemplateUsingTestingModule',\n        'Cannot override template when the test module has already been instantiated');\n    this.compiler.overrideTemplateUsingTestingModule(component, template);\n  }\n\n  overrideDirective(directive: Type<any>, override: MetadataOverride<Directive>): void {\n    this.assertNotInstantiated('overrideDirective', 'override directive metadata');\n    this.compiler.overrideDirective(directive, override);\n  }\n\n  overridePipe(pipe: Type<any>, override: MetadataOverride<Pipe>): void {\n    this.assertNotInstantiated('overridePipe', 'override pipe metadata');\n    this.compiler.overridePipe(pipe, override);\n  }\n\n  /**\n   * Overwrites all providers for the given token with the given provider definition.\n   */\n  overrideProvider(token: any, provider: {useFactory?: Function, useValue?: any, deps?: any[]}):\n      void {\n    this.compiler.overrideProvider(token, provider);\n  }\n\n  createComponent<T>(type: Type<T>): ComponentFixture<T> {\n    const testComponentRenderer: TestComponentRenderer = this.get(TestComponentRenderer);\n    const rootElId = `root-ng-internal-isolated-${_nextRootElementId++}`;\n    testComponentRenderer.insertRootElement(rootElId);\n\n    const componentDef = (type as any).ngComponentDef;\n\n    if (!componentDef) {\n      throw new Error(\n          `It looks like '${stringify(type)}' has not been IVY compiled - it has no 'ngComponentDef' field`);\n    }\n\n    // TODO: Don't cast as `any`, proper type is boolean[]\n    const noNgZone = this.get(ComponentFixtureNoNgZone as any, false);\n    // TODO: Don't cast as `any`, proper type is boolean[]\n    const autoDetect: boolean = this.get(ComponentFixtureAutoDetect as any, false);\n    const ngZone: NgZone|null = noNgZone ? null : this.get(NgZone as Type<NgZone|null>, null);\n    const componentFactory = new ComponentFactory(componentDef);\n    const initComponent = () => {\n      const componentRef =\n          componentFactory.create(Injector.NULL, [], `#${rootElId}`, this.testModuleRef);\n      return new ComponentFixture<any>(componentRef, ngZone, autoDetect);\n    };\n    const fixture = ngZone ? ngZone.run(initComponent) : initComponent();\n    this._activeFixtures.push(fixture);\n    return fixture;\n  }\n\n  private get compiler(): R3TestBedCompiler {\n    if (this._compiler === null) {\n      throw new Error(`Need to call TestBed.initTestEnvironment() first`);\n    }\n    return this._compiler;\n  }\n\n  private get testModuleRef(): NgModuleRef<any> {\n    if (this._testModuleRef === null) {\n      this._testModuleRef = this.compiler.finalize();\n    }\n    return this._testModuleRef;\n  }\n\n  private assertNotInstantiated(methodName: string, methodDescription: string) {\n    if (this._testModuleRef !== null) {\n      throw new Error(\n          `Cannot ${methodDescription} when the test module has already been instantiated. ` +\n          `Make sure you are not using \\`inject\\` before \\`${methodName}\\`.`);\n    }\n  }\n\n  /**\n   * Check whether the module scoping queue should be flushed, and flush it if needed.\n   *\n   * When the TestBed is reset, it clears the JIT module compilation queue, cancelling any\n   * in-progress module compilation. This creates a potential hazard - the very first time the\n   * TestBed is initialized (or if it's reset without being initialized), there may be pending\n   * compilations of modules declared in global scope. These compilations should be finished.\n   *\n   * To ensure that globally declared modules have their components scoped properly, this function\n   * is called whenever TestBed is initialized or reset. The _first_ time that this happens, prior\n   * to any other operations, the scoping queue is flushed.\n   */\n  private checkGlobalCompilationFinished(): void {\n    // Checking _testNgModuleRef is null should not be necessary, but is left in as an additional\n    // guard that compilations queued in tests (after instantiation) are never flushed accidentally.\n    if (!this._globalCompilationChecked && this._testModuleRef === null) {\n      flushModuleScopingQueueAsMuchAsPossible();\n    }\n    this._globalCompilationChecked = true;\n  }\n\n  private destroyActiveFixtures(): void {\n    this._activeFixtures.forEach((fixture) => {\n      try {\n        fixture.destroy();\n      } catch (e) {\n        console.error('Error during cleanup of component', {\n          component: fixture.componentInstance,\n          stacktrace: e,\n        });\n      }\n    });\n    this._activeFixtures = [];\n  }\n}\n\nlet testBed: TestBedRender3;\n\nexport function _getTestBedRender3(): TestBedRender3 {\n  return testBed = testBed || new TestBedRender3();\n}\n"]}