angular2
Version:
Angular 2 - a web framework for modern web apps
180 lines • 19.4 kB
JavaScript
import { ReflectiveInjector, 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';
import { async } from './async';
import { AsyncTestCompleter } from './async_test_completer';
export { async } from './async';
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 = ReflectiveInjector.resolveAndCreate(this.platformProviders);
this._injector = rootInjector.resolveAndCreateChild(ListWrapper.concat(this.applicationProviders, this._providers));
this._instantiated = true;
return this._injector;
}
get(token) {
if (!this._instantiated) {
this.createInjector();
}
return this._injector.get(token);
}
execute(tokens, fn) {
if (!this._instantiated) {
this.createInjector();
}
var params = tokens.map(t => this._injector.get(t));
return FunctionWrapper.apply(fn, params);
}
}
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.get(PLATFORM_INITIALIZER, null);
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 {Function}
*/
export function inject(tokens, fn) {
let testInjector = getTestInjector();
if (tokens.indexOf(AsyncTestCompleter) >= 0) {
// Return an async test method that returns a Promise if AsyncTestCompleter is one of the
// injected tokens.
return () => {
let completer = testInjector.get(AsyncTestCompleter);
testInjector.execute(tokens, fn);
return completer.promise;
};
}
else {
// Return a synchronous test method with the injected tokens.
return () => { return getTestInjector().execute(tokens, fn); };
}
}
export class InjectSetupWrapper {
constructor(_providers) {
this._providers = _providers;
}
_addProviders() {
var additionalProviders = this._providers();
if (additionalProviders.length > 0) {
getTestInjector().addProviders(additionalProviders);
}
}
inject(tokens, fn) {
return () => {
this._addProviders();
return inject(tokens, fn)();
};
}
/** @Deprecated {use async(withProviders().inject())} */
injectAsync(tokens, fn) {
return () => {
this._addProviders();
return injectAsync(tokens, fn)();
};
}
}
export function withProviders(providers) {
return new InjectSetupWrapper(providers);
}
/**
* @Deprecated {use async(inject())}
*
* 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 {Function}
*/
export function injectAsync(tokens, fn) {
return async(inject(tokens, fn));
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"test_injector.js","sourceRoot":"","sources":["diffing_plugin_wrapper-output_path-xBLIBrVR.tmp/angular2/src/testing/test_injector.ts"],"names":[],"mappings":"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","sourcesContent":["import {ReflectiveInjector, 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\nimport {async} from './async';\nimport {AsyncTestCompleter} from './async_test_completer';\n\nexport {async} from './async';\n\nexport class TestInjector {\n  private _instantiated: boolean = false;\n\n  private _injector: ReflectiveInjector = 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 = ReflectiveInjector.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  get(token: any) {\n    if (!this._instantiated) {\n      this.createInjector();\n    }\n    return this._injector.get(token);\n  }\n\n  execute(tokens: any[], fn: Function): any {\n    if (!this._instantiated) {\n      this.createInjector();\n    }\n    var params = tokens.map(t => this._injector.get(t));\n    return FunctionWrapper.apply(fn, params);\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.get(PLATFORM_INITIALIZER, null);\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 {Function}\n */\nexport function inject(tokens: any[], fn: Function): Function {\n  let testInjector = getTestInjector();\n  if (tokens.indexOf(AsyncTestCompleter) >= 0) {\n    // Return an async test method that returns a Promise if AsyncTestCompleter is one of the\n    // injected tokens.\n    return () => {\n      let completer: AsyncTestCompleter = testInjector.get(AsyncTestCompleter);\n      testInjector.execute(tokens, fn);\n      return completer.promise;\n    }\n  } else {\n    // Return a synchronous test method with the injected tokens.\n    return () => { return getTestInjector().execute(tokens, fn); };\n  }\n}\n\nexport class InjectSetupWrapper {\n  constructor(private _providers: () => any) {}\n\n  private _addProviders() {\n    var additionalProviders = this._providers();\n    if (additionalProviders.length > 0) {\n      getTestInjector().addProviders(additionalProviders);\n    }\n  }\n\n  inject(tokens: any[], fn: Function): Function {\n    return () => {\n      this._addProviders();\n      return inject(tokens, fn)();\n    }\n  }\n\n  /** @Deprecated {use async(withProviders().inject())} */\n  injectAsync(tokens: any[], fn: Function): Function {\n    return () => {\n      this._addProviders();\n      return injectAsync(tokens, fn)();\n    }\n  }\n}\n\nexport function withProviders(providers: () => any) {\n  return new InjectSetupWrapper(providers);\n}\n\n/**\n * @Deprecated {use async(inject())}\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 {Function}\n */\nexport function injectAsync(tokens: any[], fn: Function): Function {\n  return async(inject(tokens, fn));\n}\n"]}