angular2
Version:
Angular 2 - a web framework for modern web apps
195 lines • 20.8 kB
JavaScript
'use strict';"use strict";
var core_1 = require('angular2/core');
var exceptions_1 = require('angular2/src/facade/exceptions');
var collection_1 = require('angular2/src/facade/collection');
var lang_1 = require('angular2/src/facade/lang');
var async_1 = require('./async');
var async_test_completer_1 = require('./async_test_completer');
var async_2 = require('./async');
exports.async = async_2.async;
var TestInjector = (function () {
function TestInjector() {
this._instantiated = false;
this._injector = null;
this._providers = [];
this.platformProviders = [];
this.applicationProviders = [];
}
TestInjector.prototype.reset = function () {
this._injector = null;
this._providers = [];
this._instantiated = false;
};
TestInjector.prototype.addProviders = function (providers) {
if (this._instantiated) {
throw new exceptions_1.BaseException('Cannot add providers after test injector is instantiated');
}
this._providers = collection_1.ListWrapper.concat(this._providers, providers);
};
TestInjector.prototype.createInjector = function () {
var rootInjector = core_1.ReflectiveInjector.resolveAndCreate(this.platformProviders);
this._injector = rootInjector.resolveAndCreateChild(collection_1.ListWrapper.concat(this.applicationProviders, this._providers));
this._instantiated = true;
return this._injector;
};
TestInjector.prototype.get = function (token) {
if (!this._instantiated) {
this.createInjector();
}
return this._injector.get(token);
};
TestInjector.prototype.execute = function (tokens, fn) {
var _this = this;
if (!this._instantiated) {
this.createInjector();
}
var params = tokens.map(function (t) { return _this._injector.get(t); });
return lang_1.FunctionWrapper.apply(fn, params);
};
return TestInjector;
}());
exports.TestInjector = TestInjector;
var _testInjector = null;
function getTestInjector() {
if (_testInjector == null) {
_testInjector = new TestInjector();
}
return _testInjector;
}
exports.getTestInjector = getTestInjector;
/**
* 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>'.
*/
function setBaseTestProviders(platformProviders, applicationProviders) {
var testInjector = getTestInjector();
if (testInjector.platformProviders.length > 0 || testInjector.applicationProviders.length > 0) {
throw new exceptions_1.BaseException('Cannot set base providers because it has already been called');
}
testInjector.platformProviders = platformProviders;
testInjector.applicationProviders = applicationProviders;
var injector = testInjector.createInjector();
var inits = injector.get(core_1.PLATFORM_INITIALIZER, null);
if (lang_1.isPresent(inits)) {
inits.forEach(function (init) { return init(); });
}
testInjector.reset();
}
exports.setBaseTestProviders = setBaseTestProviders;
/**
* Reset the providers for the test injector.
*/
function resetBaseTestProviders() {
var testInjector = getTestInjector();
testInjector.platformProviders = [];
testInjector.applicationProviders = [];
testInjector.reset();
}
exports.resetBaseTestProviders = resetBaseTestProviders;
/**
* 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}
*/
function inject(tokens, fn) {
var testInjector = getTestInjector();
if (tokens.indexOf(async_test_completer_1.AsyncTestCompleter) >= 0) {
// Return an async test method that returns a Promise if AsyncTestCompleter is one of the
// injected tokens.
return function () {
var completer = testInjector.get(async_test_completer_1.AsyncTestCompleter);
testInjector.execute(tokens, fn);
return completer.promise;
};
}
else {
// Return a synchronous test method with the injected tokens.
return function () { return getTestInjector().execute(tokens, fn); };
}
}
exports.inject = inject;
var InjectSetupWrapper = (function () {
function InjectSetupWrapper(_providers) {
this._providers = _providers;
}
InjectSetupWrapper.prototype._addProviders = function () {
var additionalProviders = this._providers();
if (additionalProviders.length > 0) {
getTestInjector().addProviders(additionalProviders);
}
};
InjectSetupWrapper.prototype.inject = function (tokens, fn) {
var _this = this;
return function () {
_this._addProviders();
return inject(tokens, fn)();
};
};
/** @Deprecated {use async(withProviders().inject())} */
InjectSetupWrapper.prototype.injectAsync = function (tokens, fn) {
var _this = this;
return function () {
_this._addProviders();
return injectAsync(tokens, fn)();
};
};
return InjectSetupWrapper;
}());
exports.InjectSetupWrapper = InjectSetupWrapper;
function withProviders(providers) {
return new InjectSetupWrapper(providers);
}
exports.withProviders = withProviders;
/**
* @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}
*/
function injectAsync(tokens, fn) {
return async_1.async(inject(tokens, fn));
}
exports.injectAsync = injectAsync;
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"test_injector.js","sourceRoot":"","sources":["diffing_plugin_wrapper-output_path-tsQuqjvF.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"]}