angular2
Version:
Angular 2 - a web framework for modern web apps
165 lines • 19.4 kB
JavaScript
import { Injector, PLATFORM_INITIALIZER } from 'angular2/core';
import { BaseException } from 'angular2/src/facade/exceptions';
import { ListWrapper } from 'angular2/src/facade/collection';
import { FunctionWrapper, isPresent } from 'angular2/src/facade/lang';
export class TestInjector {
constructor() {
this._instantiated = false;
this._injector = null;
this._providers = [];
this.platformProviders = [];
this.applicationProviders = [];
}
reset() {
this._injector = null;
this._providers = [];
this._instantiated = false;
}
addProviders(providers) {
if (this._instantiated) {
throw new BaseException('Cannot add providers after test injector is instantiated');
}
this._providers = ListWrapper.concat(this._providers, providers);
}
createInjector() {
var rootInjector = Injector.resolveAndCreate(this.platformProviders);
this._injector = rootInjector.resolveAndCreateChild(ListWrapper.concat(this.applicationProviders, this._providers));
this._instantiated = true;
return this._injector;
}
execute(fn) {
var additionalProviders = fn.additionalProviders();
if (additionalProviders.length > 0) {
this.addProviders(additionalProviders);
}
if (!this._instantiated) {
this.createInjector();
}
return fn.execute(this._injector);
}
}
var _testInjector = null;
export function getTestInjector() {
if (_testInjector == null) {
_testInjector = new TestInjector();
}
return _testInjector;
}
/**
* Set the providers that the test injector should use. These should be providers
* 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 teh current platform. If you absolutely need to change the providers,
* first use `resetBaseTestProviders`.
*
* Test Providers for individual platforms are available from
* 'angular2/platform/testing/<platform_name>'.
*/
export function setBaseTestProviders(platformProviders, applicationProviders) {
var testInjector = getTestInjector();
if (testInjector.platformProviders.length > 0 || testInjector.applicationProviders.length > 0) {
throw new BaseException('Cannot set base providers because it has already been called');
}
testInjector.platformProviders = platformProviders;
testInjector.applicationProviders = applicationProviders;
var injector = testInjector.createInjector();
let inits = injector.getOptional(PLATFORM_INITIALIZER);
if (isPresent(inits)) {
inits.forEach(init => init());
}
testInjector.reset();
}
/**
* Reset the providers for the test injector.
*/
export function resetBaseTestProviders() {
var testInjector = getTestInjector();
testInjector.platformProviders = [];
testInjector.applicationProviders = [];
testInjector.reset();
}
/**
* Allows injecting dependencies in `beforeEach()` and `it()`.
*
* Example:
*
* ```
* beforeEach(inject([Dependency, AClass], (dep, object) => {
* // some code that uses `dep` and `object`
* // ...
* }));
*
* it('...', inject([AClass], (object) => {
* object.doSomething();
* expect(...);
* })
* ```
*
* Notes:
* - inject is currently a function because of some Traceur limitation the syntax should
* eventually
* becomes `it('...', @Inject (object: AClass, async: AsyncTestCompleter) => { ... });`
*
* @param {Array} tokens
* @param {Function} fn
* @return {FunctionWithParamTokens}
*/
export function inject(tokens, fn) {
return new FunctionWithParamTokens(tokens, fn, false);
}
export class InjectSetupWrapper {
constructor(_providers) {
this._providers = _providers;
}
inject(tokens, fn) {
return new FunctionWithParamTokens(tokens, fn, false, this._providers);
}
injectAsync(tokens, fn) {
return new FunctionWithParamTokens(tokens, fn, true, this._providers);
}
}
export function withProviders(providers) {
return new InjectSetupWrapper(providers);
}
/**
* Allows injecting dependencies in `beforeEach()` and `it()`. The test must return
* a promise which will resolve when all asynchronous activity is complete.
*
* Example:
*
* ```
* it('...', injectAsync([AClass], (object) => {
* return object.doSomething().then(() => {
* expect(...);
* });
* })
* ```
*
* @param {Array} tokens
* @param {Function} fn
* @return {FunctionWithParamTokens}
*/
export function injectAsync(tokens, fn) {
return new FunctionWithParamTokens(tokens, fn, true);
}
function emptyArray() {
return [];
}
export class FunctionWithParamTokens {
constructor(_tokens, _fn, isAsync, additionalProviders = emptyArray) {
this._tokens = _tokens;
this._fn = _fn;
this.isAsync = isAsync;
this.additionalProviders = additionalProviders;
}
/**
* Returns the value of the executed function.
*/
execute(injector) {
var params = this._tokens.map(t => injector.get(t));
return FunctionWrapper.apply(this._fn, params);
}
hasToken(token) { return this._tokens.indexOf(token) > -1; }
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"test_injector.js","sourceRoot":"","sources":["angular2/src/testing/test_injector.ts"],"names":["TestInjector","TestInjector.constructor","TestInjector.reset","TestInjector.addProviders","TestInjector.createInjector","TestInjector.execute","getTestInjector","setBaseTestProviders","resetBaseTestProviders","inject","InjectSetupWrapper","InjectSetupWrapper.constructor","InjectSetupWrapper.inject","InjectSetupWrapper.injectAsync","withProviders","injectAsync","emptyArray","FunctionWithParamTokens","FunctionWithParamTokens.constructor","FunctionWithParamTokens.execute","FunctionWithParamTokens.hasToken"],"mappings":"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","sourcesContent":["import {Injector, Provider, PLATFORM_INITIALIZER} from 'angular2/core';\nimport {BaseException, ExceptionHandler} from 'angular2/src/facade/exceptions';\nimport {ListWrapper} from 'angular2/src/facade/collection';\nimport {FunctionWrapper, isPresent, Type} from 'angular2/src/facade/lang';\n\nexport class TestInjector {\n  private _instantiated: boolean = false;\n\n  private _injector: Injector = null;\n\n  private _providers: Array<Type | Provider | any[]> = [];\n\n  reset() {\n    this._injector = null;\n    this._providers = [];\n    this._instantiated = false;\n  }\n\n  platformProviders: Array<Type | Provider | any[]> = [];\n\n  applicationProviders: Array<Type | Provider | any[]> = [];\n\n  addProviders(providers: Array<Type | Provider | any[]>) {\n    if (this._instantiated) {\n      throw new BaseException('Cannot add providers after test injector is instantiated');\n    }\n    this._providers = ListWrapper.concat(this._providers, providers);\n  }\n\n  createInjector() {\n    var rootInjector = Injector.resolveAndCreate(this.platformProviders);\n    this._injector = rootInjector.resolveAndCreateChild(\n        ListWrapper.concat(this.applicationProviders, this._providers));\n    this._instantiated = true;\n    return this._injector;\n  }\n\n  execute(fn: FunctionWithParamTokens): any {\n    var additionalProviders = fn.additionalProviders();\n    if (additionalProviders.length > 0) {\n      this.addProviders(additionalProviders);\n    }\n    if (!this._instantiated) {\n      this.createInjector();\n    }\n    return fn.execute(this._injector);\n  }\n}\n\nvar _testInjector: TestInjector = null;\n\nexport function getTestInjector() {\n  if (_testInjector == null) {\n    _testInjector = new TestInjector();\n  }\n  return _testInjector;\n}\n\n/**\n * Set the providers that the test injector should use. These should be providers\n * 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 teh current platform. If you absolutely need to change the providers,\n * first use `resetBaseTestProviders`.\n *\n * Test Providers for individual platforms are available from\n * 'angular2/platform/testing/<platform_name>'.\n */\nexport function setBaseTestProviders(platformProviders: Array<Type | Provider | any[]>,\n                                     applicationProviders: Array<Type | Provider | any[]>) {\n  var testInjector = getTestInjector();\n  if (testInjector.platformProviders.length > 0 || testInjector.applicationProviders.length > 0) {\n    throw new BaseException('Cannot set base providers because it has already been called');\n  }\n  testInjector.platformProviders = platformProviders;\n  testInjector.applicationProviders = applicationProviders;\n  var injector = testInjector.createInjector();\n  let inits: Function[] = injector.getOptional(PLATFORM_INITIALIZER);\n  if (isPresent(inits)) {\n    inits.forEach(init => init());\n  }\n  testInjector.reset();\n}\n\n/**\n * Reset the providers for the test injector.\n */\nexport function resetBaseTestProviders() {\n  var testInjector = getTestInjector();\n  testInjector.platformProviders = [];\n  testInjector.applicationProviders = [];\n  testInjector.reset();\n}\n\n/**\n * Allows injecting dependencies in `beforeEach()` and `it()`.\n *\n * Example:\n *\n * ```\n * beforeEach(inject([Dependency, AClass], (dep, object) => {\n *   // some code that uses `dep` and `object`\n *   // ...\n * }));\n *\n * it('...', inject([AClass], (object) => {\n *   object.doSomething();\n *   expect(...);\n * })\n * ```\n *\n * Notes:\n * - inject is currently a function because of some Traceur limitation the syntax should\n * eventually\n *   becomes `it('...', @Inject (object: AClass, async: AsyncTestCompleter) => { ... });`\n *\n * @param {Array} tokens\n * @param {Function} fn\n * @return {FunctionWithParamTokens}\n */\nexport function inject(tokens: any[], fn: Function): FunctionWithParamTokens {\n  return new FunctionWithParamTokens(tokens, fn, false);\n}\n\nexport class InjectSetupWrapper {\n  constructor(private _providers: () => any) {}\n\n  inject(tokens: any[], fn: Function): FunctionWithParamTokens {\n    return new FunctionWithParamTokens(tokens, fn, false, this._providers);\n  }\n\n  injectAsync(tokens: any[], fn: Function): FunctionWithParamTokens {\n    return new FunctionWithParamTokens(tokens, fn, true, this._providers);\n  }\n}\n\nexport function withProviders(providers: () => any) {\n  return new InjectSetupWrapper(providers);\n}\n\n/**\n * Allows injecting dependencies in `beforeEach()` and `it()`. The test must return\n * a promise which will resolve when all asynchronous activity is complete.\n *\n * Example:\n *\n * ```\n * it('...', injectAsync([AClass], (object) => {\n *   return object.doSomething().then(() => {\n *     expect(...);\n *   });\n * })\n * ```\n *\n * @param {Array} tokens\n * @param {Function} fn\n * @return {FunctionWithParamTokens}\n */\nexport function injectAsync(tokens: any[], fn: Function): FunctionWithParamTokens {\n  return new FunctionWithParamTokens(tokens, fn, true);\n}\n\nfunction emptyArray(): Array<any> {\n  return [];\n}\n\nexport class FunctionWithParamTokens {\n  constructor(private _tokens: any[], private _fn: Function, public isAsync: boolean,\n              public additionalProviders: () => any = emptyArray) {}\n\n  /**\n   * Returns the value of the executed function.\n   */\n  execute(injector: Injector): any {\n    var params = this._tokens.map(t => injector.get(t));\n    return FunctionWrapper.apply(this._fn, params);\n  }\n\n  hasToken(token: any): boolean { return this._tokens.indexOf(token) > -1; }\n}\n"]}