honeymoose
/
angular-cn
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
angular-cn/modules/@angular/core/testing/testing.ts

183 lines
5.1 KiB
TypeScript
Raw Normal View History

chore(lint): Added license headers to most TypeScript files Relates to #9380
2016-06-23 12:47:54 -04:00
/**
* @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
*/
feat(test): Add an external version of the test library Adds test adapters for TypeScript and JavaScript only, exported as part of the test_lib module. These work with the Jasmine test framework, and allow use of the test injector within test blocks via the `inject` function. See #4572, #4177, #4035, #2783 This includes the TestComponentBuilder. It allows using the test injector with Jasmine bindings, and waits for returned promises before completing async test blocks.
2015-10-08 18:33:17 -04:00
/**
refactor(testing): remove wrapping of Jasmine functions (#9564) Instead, the async function now determines whether it should return a promise or instead call a done function parameter. Importing Jasmine functions from `@angular/core/testing` is no longer necessary and is now deprecated. Additionally, beforeEachProviders is also deprecated, as it is specific to the testing framework. Instead, use the new addProviders method directly. Before: ```js import {beforeEachProviders, it, describe, inject} from 'angular2/testing/core'; describe('my code', () => { beforeEachProviders(() => [MyService]); it('does stuff', inject([MyService], (service) => { // actual test }); }); ``` After: ```js import {addProviders, inject} from 'angular2/testing/core'; describe('my code', () => { beforeEach(() => { addProviders([MyService]); }); it('does stuff', inject([MyService], (service) => { // actual test }); }); ```
2016-06-24 20:48:35 -04:00
* Public Test Library for unit testing Angular2 Applications. Assumes that you are running
* with Jasmine, Mocha, or a similar framework which exports a beforeEach function and
* allows tests to be asynchronous by either returning a promise or using a 'done' parameter.
feat(test): Add an external version of the test library Adds test adapters for TypeScript and JavaScript only, exported as part of the test_lib module. These work with the Jasmine test framework, and allow use of the test injector within test blocks via the `inject` function. See #4572, #4177, #4035, #2783 This includes the TestComponentBuilder. It allows using the test injector with Jasmine bindings, and waits for returned promises before completing async test blocks.
2015-10-08 18:33:17 -04:00
*/
fix(core/testing): clean up the core testing public API (#9466) Previously, we were exporting internal mocks and helpers. Move these to core/testing/testing_internal or remove them if they were never used. Remove deprecated items - injectAsync, clearPendingTimers. BREAKING CHANGE: Remove the following APIs from `@angular/core/testing`, which have been deprecated or were never intended to be publicly exported: ``` injectAsync clearPendingTimers Log MockAppliacationHref MockNgZone clearPendingTimers getTypeOf instantiateType ``` Instead of `injectAsync`, use `async(inject())`. `clearPendingTimers` is no longer required.
2016-06-23 20:10:22 -04:00
import {TestInjector, getTestInjector} from './test_injector';
feat(test): Add an external version of the test library Adds test adapters for TypeScript and JavaScript only, exported as part of the test_lib module. These work with the Jasmine test framework, and allow use of the test injector within test blocks via the `inject` function. See #4572, #4177, #4035, #2783 This includes the TestComponentBuilder. It allows using the test injector with Jasmine bindings, and waits for returned promises before completing async test blocks.
2015-10-08 18:33:17 -04:00
fix(HtmlParser): consider <ng-container> when adding required parents
2016-06-15 12:37:33 -04:00
declare var global: any;
feat(test): Add an external version of the test library Adds test adapters for TypeScript and JavaScript only, exported as part of the test_lib module. These work with the Jasmine test framework, and allow use of the test injector within test blocks via the `inject` function. See #4572, #4177, #4035, #2783 This includes the TestComponentBuilder. It allows using the test injector with Jasmine bindings, and waits for returned promises before completing async test blocks.
2015-10-08 18:33:17 -04:00
chore(typings): use mainline DefinitelyTyped repo rather than a fork. The upstream Jasmine typings don't define a type for the global object with Jasmine methods polluting it, so just use any. Also zone.js has a different name upstream.
2016-02-01 13:28:57 -05:00
var _global = <any>(typeof window === 'undefined' ? global : window);
feat(test): Add an external version of the test library Adds test adapters for TypeScript and JavaScript only, exported as part of the test_lib module. These work with the Jasmine test framework, and allow use of the test injector within test blocks via the `inject` function. See #4572, #4177, #4035, #2783 This includes the TestComponentBuilder. It allows using the test injector with Jasmine bindings, and waits for returned promises before completing async test blocks.
2015-10-08 18:33:17 -04:00
refactor(testing): remove wrapping of Jasmine functions (#9564) Instead, the async function now determines whether it should return a promise or instead call a done function parameter. Importing Jasmine functions from `@angular/core/testing` is no longer necessary and is now deprecated. Additionally, beforeEachProviders is also deprecated, as it is specific to the testing framework. Instead, use the new addProviders method directly. Before: ```js import {beforeEachProviders, it, describe, inject} from 'angular2/testing/core'; describe('my code', () => { beforeEachProviders(() => [MyService]); it('does stuff', inject([MyService], (service) => { // actual test }); }); ``` After: ```js import {addProviders, inject} from 'angular2/testing/core'; describe('my code', () => { beforeEach(() => { addProviders([MyService]); }); it('does stuff', inject([MyService], (service) => { // actual test }); }); ```
2016-06-24 20:48:35 -04:00
/**
* @deprecated you no longer need to import jasmine functions from @angular/core/testing. Simply use
* the globals.
*
* See http://jasmine.github.io/ for more details.
*/
repackaging: all the repackaging changes squashed
2016-04-28 20:50:03 -04:00
export var expect: Function = _global.expect;
feat(testing): use zones to avoid the need for injectAsync Use a zone counting timeouts and microtasks to determine when a test is finished, instead of requiring the test writer to use injectAsync and return a promise. See #5322
2015-11-18 21:46:24 -05:00
/**
refactor(testing): remove wrapping of Jasmine functions (#9564) Instead, the async function now determines whether it should return a promise or instead call a done function parameter. Importing Jasmine functions from `@angular/core/testing` is no longer necessary and is now deprecated. Additionally, beforeEachProviders is also deprecated, as it is specific to the testing framework. Instead, use the new addProviders method directly. Before: ```js import {beforeEachProviders, it, describe, inject} from 'angular2/testing/core'; describe('my code', () => { beforeEachProviders(() => [MyService]); it('does stuff', inject([MyService], (service) => { // actual test }); }); ``` After: ```js import {addProviders, inject} from 'angular2/testing/core'; describe('my code', () => { beforeEach(() => { addProviders([MyService]); }); it('does stuff', inject([MyService], (service) => { // actual test }); }); ```
2016-06-24 20:48:35 -04:00
* @deprecated you no longer need to import jasmine functions from @angular/core/testing. Simply use
* the globals.
docs(core): Myriad of documentation changes including lots of new example code.
2015-11-30 11:28:54 -05:00
*
* See http://jasmine.github.io/ for more details.
feat(testing): use zones to avoid the need for injectAsync Use a zone counting timeouts and microtasks to determine when a test is finished, instead of requiring the test writer to use injectAsync and return a promise. See #5322
2015-11-18 21:46:24 -05:00
*/
feat(test): Add an external version of the test library Adds test adapters for TypeScript and JavaScript only, exported as part of the test_lib module. These work with the Jasmine test framework, and allow use of the test injector within test blocks via the `inject` function. See #4572, #4177, #4035, #2783 This includes the TestComponentBuilder. It allows using the test injector with Jasmine bindings, and waits for returned promises before completing async test blocks.
2015-10-08 18:33:17 -04:00
export var afterEach: Function = _global.afterEach;
feat(testing): use zones to avoid the need for injectAsync Use a zone counting timeouts and microtasks to determine when a test is finished, instead of requiring the test writer to use injectAsync and return a promise. See #5322
2015-11-18 21:46:24 -05:00
/**
refactor(testing): remove wrapping of Jasmine functions (#9564) Instead, the async function now determines whether it should return a promise or instead call a done function parameter. Importing Jasmine functions from `@angular/core/testing` is no longer necessary and is now deprecated. Additionally, beforeEachProviders is also deprecated, as it is specific to the testing framework. Instead, use the new addProviders method directly. Before: ```js import {beforeEachProviders, it, describe, inject} from 'angular2/testing/core'; describe('my code', () => { beforeEachProviders(() => [MyService]); it('does stuff', inject([MyService], (service) => { // actual test }); }); ``` After: ```js import {addProviders, inject} from 'angular2/testing/core'; describe('my code', () => { beforeEach(() => { addProviders([MyService]); }); it('does stuff', inject([MyService], (service) => { // actual test }); }); ```
2016-06-24 20:48:35 -04:00
* @deprecated you no longer need to import jasmine functions from @angular/core/testing. Simply use
* the globals.
docs(core): Myriad of documentation changes including lots of new example code.
2015-11-30 11:28:54 -05:00
*
* See http://jasmine.github.io/ for more details.
feat(testing): use zones to avoid the need for injectAsync Use a zone counting timeouts and microtasks to determine when a test is finished, instead of requiring the test writer to use injectAsync and return a promise. See #5322
2015-11-18 21:46:24 -05:00
*/
feat(test): Add an external version of the test library Adds test adapters for TypeScript and JavaScript only, exported as part of the test_lib module. These work with the Jasmine test framework, and allow use of the test injector within test blocks via the `inject` function. See #4572, #4177, #4035, #2783 This includes the TestComponentBuilder. It allows using the test injector with Jasmine bindings, and waits for returned promises before completing async test blocks.
2015-10-08 18:33:17 -04:00
export var describe: Function = _global.describe;
feat(testing): use zones to avoid the need for injectAsync Use a zone counting timeouts and microtasks to determine when a test is finished, instead of requiring the test writer to use injectAsync and return a promise. See #5322
2015-11-18 21:46:24 -05:00
/**
refactor(testing): remove wrapping of Jasmine functions (#9564) Instead, the async function now determines whether it should return a promise or instead call a done function parameter. Importing Jasmine functions from `@angular/core/testing` is no longer necessary and is now deprecated. Additionally, beforeEachProviders is also deprecated, as it is specific to the testing framework. Instead, use the new addProviders method directly. Before: ```js import {beforeEachProviders, it, describe, inject} from 'angular2/testing/core'; describe('my code', () => { beforeEachProviders(() => [MyService]); it('does stuff', inject([MyService], (service) => { // actual test }); }); ``` After: ```js import {addProviders, inject} from 'angular2/testing/core'; describe('my code', () => { beforeEach(() => { addProviders([MyService]); }); it('does stuff', inject([MyService], (service) => { // actual test }); }); ```
2016-06-24 20:48:35 -04:00
* @deprecated you no longer need to import jasmine functions from @angular/core/testing. Simply use
* the globals.
*
* See http://jasmine.github.io/ for more details.
feat(testing): use zones to avoid the need for injectAsync Use a zone counting timeouts and microtasks to determine when a test is finished, instead of requiring the test writer to use injectAsync and return a promise. See #5322
2015-11-18 21:46:24 -05:00
*/
refactor(testing): remove wrapping of Jasmine functions (#9564) Instead, the async function now determines whether it should return a promise or instead call a done function parameter. Importing Jasmine functions from `@angular/core/testing` is no longer necessary and is now deprecated. Additionally, beforeEachProviders is also deprecated, as it is specific to the testing framework. Instead, use the new addProviders method directly. Before: ```js import {beforeEachProviders, it, describe, inject} from 'angular2/testing/core'; describe('my code', () => { beforeEachProviders(() => [MyService]); it('does stuff', inject([MyService], (service) => { // actual test }); }); ``` After: ```js import {addProviders, inject} from 'angular2/testing/core'; describe('my code', () => { beforeEach(() => { addProviders([MyService]); }); it('does stuff', inject([MyService], (service) => { // actual test }); }); ```
2016-06-24 20:48:35 -04:00
export var fdescribe = _global.fdescribe;
feat(testing): use zones to avoid the need for injectAsync Use a zone counting timeouts and microtasks to determine when a test is finished, instead of requiring the test writer to use injectAsync and return a promise. See #5322
2015-11-18 21:46:24 -05:00
/**
refactor(testing): remove wrapping of Jasmine functions (#9564) Instead, the async function now determines whether it should return a promise or instead call a done function parameter. Importing Jasmine functions from `@angular/core/testing` is no longer necessary and is now deprecated. Additionally, beforeEachProviders is also deprecated, as it is specific to the testing framework. Instead, use the new addProviders method directly. Before: ```js import {beforeEachProviders, it, describe, inject} from 'angular2/testing/core'; describe('my code', () => { beforeEachProviders(() => [MyService]); it('does stuff', inject([MyService], (service) => { // actual test }); }); ``` After: ```js import {addProviders, inject} from 'angular2/testing/core'; describe('my code', () => { beforeEach(() => { addProviders([MyService]); }); it('does stuff', inject([MyService], (service) => { // actual test }); }); ```
2016-06-24 20:48:35 -04:00
* @deprecated you no longer need to import jasmine functions from @angular/core/testing. Simply use
* the globals.
docs(core): Myriad of documentation changes including lots of new example code.
2015-11-30 11:28:54 -05:00
*
* See http://jasmine.github.io/ for more details.
feat(testing): use zones to avoid the need for injectAsync Use a zone counting timeouts and microtasks to determine when a test is finished, instead of requiring the test writer to use injectAsync and return a promise. See #5322
2015-11-18 21:46:24 -05:00
*/
refactor(testing): remove wrapping of Jasmine functions (#9564) Instead, the async function now determines whether it should return a promise or instead call a done function parameter. Importing Jasmine functions from `@angular/core/testing` is no longer necessary and is now deprecated. Additionally, beforeEachProviders is also deprecated, as it is specific to the testing framework. Instead, use the new addProviders method directly. Before: ```js import {beforeEachProviders, it, describe, inject} from 'angular2/testing/core'; describe('my code', () => { beforeEachProviders(() => [MyService]); it('does stuff', inject([MyService], (service) => { // actual test }); }); ``` After: ```js import {addProviders, inject} from 'angular2/testing/core'; describe('my code', () => { beforeEach(() => { addProviders([MyService]); }); it('does stuff', inject([MyService], (service) => { // actual test }); }); ```
2016-06-24 20:48:35 -04:00
export var ddescribe = _global.ddescribe;
feat(testing): use zones to avoid the need for injectAsync Use a zone counting timeouts and microtasks to determine when a test is finished, instead of requiring the test writer to use injectAsync and return a promise. See #5322
2015-11-18 21:46:24 -05:00
/**
refactor(testing): remove wrapping of Jasmine functions (#9564) Instead, the async function now determines whether it should return a promise or instead call a done function parameter. Importing Jasmine functions from `@angular/core/testing` is no longer necessary and is now deprecated. Additionally, beforeEachProviders is also deprecated, as it is specific to the testing framework. Instead, use the new addProviders method directly. Before: ```js import {beforeEachProviders, it, describe, inject} from 'angular2/testing/core'; describe('my code', () => { beforeEachProviders(() => [MyService]); it('does stuff', inject([MyService], (service) => { // actual test }); }); ``` After: ```js import {addProviders, inject} from 'angular2/testing/core'; describe('my code', () => { beforeEach(() => { addProviders([MyService]); }); it('does stuff', inject([MyService], (service) => { // actual test }); }); ```
2016-06-24 20:48:35 -04:00
* @deprecated you no longer need to import jasmine functions from @angular/core/testing. Simply use
* the globals.
docs(core): Myriad of documentation changes including lots of new example code.
2015-11-30 11:28:54 -05:00
*
* See http://jasmine.github.io/ for more details.
feat(testing): use zones to avoid the need for injectAsync Use a zone counting timeouts and microtasks to determine when a test is finished, instead of requiring the test writer to use injectAsync and return a promise. See #5322
2015-11-18 21:46:24 -05:00
*/
feat(test): Add an external version of the test library Adds test adapters for TypeScript and JavaScript only, exported as part of the test_lib module. These work with the Jasmine test framework, and allow use of the test injector within test blocks via the `inject` function. See #4572, #4177, #4035, #2783 This includes the TestComponentBuilder. It allows using the test injector with Jasmine bindings, and waits for returned promises before completing async test blocks.
2015-10-08 18:33:17 -04:00
export var xdescribe: Function = _global.xdescribe;
/**
refactor(testing): remove wrapping of Jasmine functions (#9564) Instead, the async function now determines whether it should return a promise or instead call a done function parameter. Importing Jasmine functions from `@angular/core/testing` is no longer necessary and is now deprecated. Additionally, beforeEachProviders is also deprecated, as it is specific to the testing framework. Instead, use the new addProviders method directly. Before: ```js import {beforeEachProviders, it, describe, inject} from 'angular2/testing/core'; describe('my code', () => { beforeEachProviders(() => [MyService]); it('does stuff', inject([MyService], (service) => { // actual test }); }); ``` After: ```js import {addProviders, inject} from 'angular2/testing/core'; describe('my code', () => { beforeEach(() => { addProviders([MyService]); }); it('does stuff', inject([MyService], (service) => { // actual test }); }); ```
2016-06-24 20:48:35 -04:00
* @deprecated you no longer need to import jasmine functions from @angular/core/testing. Simply use
* the globals.
feat(test): Add an external version of the test library Adds test adapters for TypeScript and JavaScript only, exported as part of the test_lib module. These work with the Jasmine test framework, and allow use of the test injector within test blocks via the `inject` function. See #4572, #4177, #4035, #2783 This includes the TestComponentBuilder. It allows using the test injector with Jasmine bindings, and waits for returned promises before completing async test blocks.
2015-10-08 18:33:17 -04:00
*
refactor(testing): remove wrapping of Jasmine functions (#9564) Instead, the async function now determines whether it should return a promise or instead call a done function parameter. Importing Jasmine functions from `@angular/core/testing` is no longer necessary and is now deprecated. Additionally, beforeEachProviders is also deprecated, as it is specific to the testing framework. Instead, use the new addProviders method directly. Before: ```js import {beforeEachProviders, it, describe, inject} from 'angular2/testing/core'; describe('my code', () => { beforeEachProviders(() => [MyService]); it('does stuff', inject([MyService], (service) => { // actual test }); }); ``` After: ```js import {addProviders, inject} from 'angular2/testing/core'; describe('my code', () => { beforeEach(() => { addProviders([MyService]); }); it('does stuff', inject([MyService], (service) => { // actual test }); }); ```
2016-06-24 20:48:35 -04:00
* See http://jasmine.github.io/ for more details.
feat(test): Add an external version of the test library Adds test adapters for TypeScript and JavaScript only, exported as part of the test_lib module. These work with the Jasmine test framework, and allow use of the test injector within test blocks via the `inject` function. See #4572, #4177, #4035, #2783 This includes the TestComponentBuilder. It allows using the test injector with Jasmine bindings, and waits for returned promises before completing async test blocks.
2015-10-08 18:33:17 -04:00
*/
refactor(testing): remove wrapping of Jasmine functions (#9564) Instead, the async function now determines whether it should return a promise or instead call a done function parameter. Importing Jasmine functions from `@angular/core/testing` is no longer necessary and is now deprecated. Additionally, beforeEachProviders is also deprecated, as it is specific to the testing framework. Instead, use the new addProviders method directly. Before: ```js import {beforeEachProviders, it, describe, inject} from 'angular2/testing/core'; describe('my code', () => { beforeEachProviders(() => [MyService]); it('does stuff', inject([MyService], (service) => { // actual test }); }); ``` After: ```js import {addProviders, inject} from 'angular2/testing/core'; describe('my code', () => { beforeEach(() => { addProviders([MyService]); }); it('does stuff', inject([MyService], (service) => { // actual test }); }); ```
2016-06-24 20:48:35 -04:00
export var beforeEach = _global.beforeEach;
feat(test): Add an external version of the test library Adds test adapters for TypeScript and JavaScript only, exported as part of the test_lib module. These work with the Jasmine test framework, and allow use of the test injector within test blocks via the `inject` function. See #4572, #4177, #4035, #2783 This includes the TestComponentBuilder. It allows using the test injector with Jasmine bindings, and waits for returned promises before completing async test blocks.
2015-10-08 18:33:17 -04:00
feat(testing): use zones to avoid the need for injectAsync Use a zone counting timeouts and microtasks to determine when a test is finished, instead of requiring the test writer to use injectAsync and return a promise. See #5322
2015-11-18 21:46:24 -05:00
/**
refactor(testing): remove wrapping of Jasmine functions (#9564) Instead, the async function now determines whether it should return a promise or instead call a done function parameter. Importing Jasmine functions from `@angular/core/testing` is no longer necessary and is now deprecated. Additionally, beforeEachProviders is also deprecated, as it is specific to the testing framework. Instead, use the new addProviders method directly. Before: ```js import {beforeEachProviders, it, describe, inject} from 'angular2/testing/core'; describe('my code', () => { beforeEachProviders(() => [MyService]); it('does stuff', inject([MyService], (service) => { // actual test }); }); ``` After: ```js import {addProviders, inject} from 'angular2/testing/core'; describe('my code', () => { beforeEach(() => { addProviders([MyService]); }); it('does stuff', inject([MyService], (service) => { // actual test }); }); ```
2016-06-24 20:48:35 -04:00
* @deprecated you no longer need to import jasmine functions from @angular/core/testing. Simply use
* the globals.
docs(core): Myriad of documentation changes including lots of new example code.
2015-11-30 11:28:54 -05:00
*
* See http://jasmine.github.io/ for more details.
feat(testing): use zones to avoid the need for injectAsync Use a zone counting timeouts and microtasks to determine when a test is finished, instead of requiring the test writer to use injectAsync and return a promise. See #5322
2015-11-18 21:46:24 -05:00
*/
refactor(testing): remove wrapping of Jasmine functions (#9564) Instead, the async function now determines whether it should return a promise or instead call a done function parameter. Importing Jasmine functions from `@angular/core/testing` is no longer necessary and is now deprecated. Additionally, beforeEachProviders is also deprecated, as it is specific to the testing framework. Instead, use the new addProviders method directly. Before: ```js import {beforeEachProviders, it, describe, inject} from 'angular2/testing/core'; describe('my code', () => { beforeEachProviders(() => [MyService]); it('does stuff', inject([MyService], (service) => { // actual test }); }); ``` After: ```js import {addProviders, inject} from 'angular2/testing/core'; describe('my code', () => { beforeEach(() => { addProviders([MyService]); }); it('does stuff', inject([MyService], (service) => { // actual test }); }); ```
2016-06-24 20:48:35 -04:00
export var it = _global.it;
feat(test): Add an external version of the test library Adds test adapters for TypeScript and JavaScript only, exported as part of the test_lib module. These work with the Jasmine test framework, and allow use of the test injector within test blocks via the `inject` function. See #4572, #4177, #4035, #2783 This includes the TestComponentBuilder. It allows using the test injector with Jasmine bindings, and waits for returned promises before completing async test blocks.
2015-10-08 18:33:17 -04:00
feat(testing): use zones to avoid the need for injectAsync Use a zone counting timeouts and microtasks to determine when a test is finished, instead of requiring the test writer to use injectAsync and return a promise. See #5322
2015-11-18 21:46:24 -05:00
/**
refactor(testing): remove wrapping of Jasmine functions (#9564) Instead, the async function now determines whether it should return a promise or instead call a done function parameter. Importing Jasmine functions from `@angular/core/testing` is no longer necessary and is now deprecated. Additionally, beforeEachProviders is also deprecated, as it is specific to the testing framework. Instead, use the new addProviders method directly. Before: ```js import {beforeEachProviders, it, describe, inject} from 'angular2/testing/core'; describe('my code', () => { beforeEachProviders(() => [MyService]); it('does stuff', inject([MyService], (service) => { // actual test }); }); ``` After: ```js import {addProviders, inject} from 'angular2/testing/core'; describe('my code', () => { beforeEach(() => { addProviders([MyService]); }); it('does stuff', inject([MyService], (service) => { // actual test }); }); ```
2016-06-24 20:48:35 -04:00
* @deprecated you no longer need to import jasmine functions from @angular/core/testing. Simply use
* the globals.
docs(core): Myriad of documentation changes including lots of new example code.
2015-11-30 11:28:54 -05:00
*
refactor(testing): remove wrapping of Jasmine functions (#9564) Instead, the async function now determines whether it should return a promise or instead call a done function parameter. Importing Jasmine functions from `@angular/core/testing` is no longer necessary and is now deprecated. Additionally, beforeEachProviders is also deprecated, as it is specific to the testing framework. Instead, use the new addProviders method directly. Before: ```js import {beforeEachProviders, it, describe, inject} from 'angular2/testing/core'; describe('my code', () => { beforeEachProviders(() => [MyService]); it('does stuff', inject([MyService], (service) => { // actual test }); }); ``` After: ```js import {addProviders, inject} from 'angular2/testing/core'; describe('my code', () => { beforeEach(() => { addProviders([MyService]); }); it('does stuff', inject([MyService], (service) => { // actual test }); }); ```
2016-06-24 20:48:35 -04:00
* See http://jasmine.github.io/ for more details.
feat(testing): use zones to avoid the need for injectAsync Use a zone counting timeouts and microtasks to determine when a test is finished, instead of requiring the test writer to use injectAsync and return a promise. See #5322
2015-11-18 21:46:24 -05:00
*/
refactor(testing): remove wrapping of Jasmine functions (#9564) Instead, the async function now determines whether it should return a promise or instead call a done function parameter. Importing Jasmine functions from `@angular/core/testing` is no longer necessary and is now deprecated. Additionally, beforeEachProviders is also deprecated, as it is specific to the testing framework. Instead, use the new addProviders method directly. Before: ```js import {beforeEachProviders, it, describe, inject} from 'angular2/testing/core'; describe('my code', () => { beforeEachProviders(() => [MyService]); it('does stuff', inject([MyService], (service) => { // actual test }); }); ``` After: ```js import {addProviders, inject} from 'angular2/testing/core'; describe('my code', () => { beforeEach(() => { addProviders([MyService]); }); it('does stuff', inject([MyService], (service) => { // actual test }); }); ```
2016-06-24 20:48:35 -04:00
export var fit = _global.fit;
feat(test): Add an external version of the test library Adds test adapters for TypeScript and JavaScript only, exported as part of the test_lib module. These work with the Jasmine test framework, and allow use of the test injector within test blocks via the `inject` function. See #4572, #4177, #4035, #2783 This includes the TestComponentBuilder. It allows using the test injector with Jasmine bindings, and waits for returned promises before completing async test blocks.
2015-10-08 18:33:17 -04:00
feat(testing): use zones to avoid the need for injectAsync Use a zone counting timeouts and microtasks to determine when a test is finished, instead of requiring the test writer to use injectAsync and return a promise. See #5322
2015-11-18 21:46:24 -05:00
/**
refactor(testing): remove wrapping of Jasmine functions (#9564) Instead, the async function now determines whether it should return a promise or instead call a done function parameter. Importing Jasmine functions from `@angular/core/testing` is no longer necessary and is now deprecated. Additionally, beforeEachProviders is also deprecated, as it is specific to the testing framework. Instead, use the new addProviders method directly. Before: ```js import {beforeEachProviders, it, describe, inject} from 'angular2/testing/core'; describe('my code', () => { beforeEachProviders(() => [MyService]); it('does stuff', inject([MyService], (service) => { // actual test }); }); ``` After: ```js import {addProviders, inject} from 'angular2/testing/core'; describe('my code', () => { beforeEach(() => { addProviders([MyService]); }); it('does stuff', inject([MyService], (service) => { // actual test }); }); ```
2016-06-24 20:48:35 -04:00
* @deprecated you no longer need to import jasmine functions from @angular/core/testing. Simply use
* the globals.
feat(testing): use zones to avoid the need for injectAsync Use a zone counting timeouts and microtasks to determine when a test is finished, instead of requiring the test writer to use injectAsync and return a promise. See #5322
2015-11-18 21:46:24 -05:00
*
refactor(testing): remove wrapping of Jasmine functions (#9564) Instead, the async function now determines whether it should return a promise or instead call a done function parameter. Importing Jasmine functions from `@angular/core/testing` is no longer necessary and is now deprecated. Additionally, beforeEachProviders is also deprecated, as it is specific to the testing framework. Instead, use the new addProviders method directly. Before: ```js import {beforeEachProviders, it, describe, inject} from 'angular2/testing/core'; describe('my code', () => { beforeEachProviders(() => [MyService]); it('does stuff', inject([MyService], (service) => { // actual test }); }); ``` After: ```js import {addProviders, inject} from 'angular2/testing/core'; describe('my code', () => { beforeEach(() => { addProviders([MyService]); }); it('does stuff', inject([MyService], (service) => { // actual test }); }); ```
2016-06-24 20:48:35 -04:00
* See http://jasmine.github.io/ for more details.
*/
export var iit = _global.fit;
/**
* @deprecated you no longer need to import jasmine functions from @angular/core/testing. Simply use
* the globals.
docs(core): Myriad of documentation changes including lots of new example code.
2015-11-30 11:28:54 -05:00
*
refactor(testing): remove wrapping of Jasmine functions (#9564) Instead, the async function now determines whether it should return a promise or instead call a done function parameter. Importing Jasmine functions from `@angular/core/testing` is no longer necessary and is now deprecated. Additionally, beforeEachProviders is also deprecated, as it is specific to the testing framework. Instead, use the new addProviders method directly. Before: ```js import {beforeEachProviders, it, describe, inject} from 'angular2/testing/core'; describe('my code', () => { beforeEachProviders(() => [MyService]); it('does stuff', inject([MyService], (service) => { // actual test }); }); ``` After: ```js import {addProviders, inject} from 'angular2/testing/core'; describe('my code', () => { beforeEach(() => { addProviders([MyService]); }); it('does stuff', inject([MyService], (service) => { // actual test }); }); ```
2016-06-24 20:48:35 -04:00
* See http://jasmine.github.io/ for more details.
feat(testing): use zones to avoid the need for injectAsync Use a zone counting timeouts and microtasks to determine when a test is finished, instead of requiring the test writer to use injectAsync and return a promise. See #5322
2015-11-18 21:46:24 -05:00
*/
refactor(testing): remove wrapping of Jasmine functions (#9564) Instead, the async function now determines whether it should return a promise or instead call a done function parameter. Importing Jasmine functions from `@angular/core/testing` is no longer necessary and is now deprecated. Additionally, beforeEachProviders is also deprecated, as it is specific to the testing framework. Instead, use the new addProviders method directly. Before: ```js import {beforeEachProviders, it, describe, inject} from 'angular2/testing/core'; describe('my code', () => { beforeEachProviders(() => [MyService]); it('does stuff', inject([MyService], (service) => { // actual test }); }); ``` After: ```js import {addProviders, inject} from 'angular2/testing/core'; describe('my code', () => { beforeEach(() => { addProviders([MyService]); }); it('does stuff', inject([MyService], (service) => { // actual test }); }); ```
2016-06-24 20:48:35 -04:00
export var xit = _global.xit;
var testInjector: TestInjector = getTestInjector();
// Reset the test providers before each test.
if (_global.beforeEach) {
beforeEach(() => { testInjector.reset(); });
feat(test): Add an external version of the test library Adds test adapters for TypeScript and JavaScript only, exported as part of the test_lib module. These work with the Jasmine test framework, and allow use of the test injector within test blocks via the `inject` function. See #4572, #4177, #4035, #2783 This includes the TestComponentBuilder. It allows using the test injector with Jasmine bindings, and waits for returned promises before completing async test blocks.
2015-10-08 18:33:17 -04:00
}
feat(testing): use zones to avoid the need for injectAsync Use a zone counting timeouts and microtasks to determine when a test is finished, instead of requiring the test writer to use injectAsync and return a promise. See #5322
2015-11-18 21:46:24 -05:00
/**
refactor(testing): remove wrapping of Jasmine functions (#9564) Instead, the async function now determines whether it should return a promise or instead call a done function parameter. Importing Jasmine functions from `@angular/core/testing` is no longer necessary and is now deprecated. Additionally, beforeEachProviders is also deprecated, as it is specific to the testing framework. Instead, use the new addProviders method directly. Before: ```js import {beforeEachProviders, it, describe, inject} from 'angular2/testing/core'; describe('my code', () => { beforeEachProviders(() => [MyService]); it('does stuff', inject([MyService], (service) => { // actual test }); }); ``` After: ```js import {addProviders, inject} from 'angular2/testing/core'; describe('my code', () => { beforeEach(() => { addProviders([MyService]); }); it('does stuff', inject([MyService], (service) => { // actual test }); }); ```
2016-06-24 20:48:35 -04:00
* Allows overriding default providers of the test injector,
* which are defined in test_injector.js
fix: public api surface fixes + stability markers - ts-api-guardian will now error if a new public symbol is added with a stability marker (`@stable`, `@experimental`, `@deprecated`) - DomEventsPlugin and KeyEventsPlugin were removed from public api surface - these classes is an implementation detail - deprecated BROWSER_PROVIDERS was removed completely - `@angular/compiler` was removed from the ts-api-guardian check since this package shouldn't contain anything that users need to directly import - the rest of the api surface was conservatively marked as stable or experimental BREAKING CHANGES: DomEventsPlugin and KeyEventsPlugin previously exported from core are no longer public - these classes are implementation detail. Previously deprecated BROWSER_PROVIDERS was completely removed from platform-browser. Closes #9236 Closes #9235 Ref #9234
2016-06-27 15:27:23 -04:00
*
* @stable
feat(testing): use zones to avoid the need for injectAsync Use a zone counting timeouts and microtasks to determine when a test is finished, instead of requiring the test writer to use injectAsync and return a promise. See #5322
2015-11-18 21:46:24 -05:00
*/
refactor(testing): remove wrapping of Jasmine functions (#9564) Instead, the async function now determines whether it should return a promise or instead call a done function parameter. Importing Jasmine functions from `@angular/core/testing` is no longer necessary and is now deprecated. Additionally, beforeEachProviders is also deprecated, as it is specific to the testing framework. Instead, use the new addProviders method directly. Before: ```js import {beforeEachProviders, it, describe, inject} from 'angular2/testing/core'; describe('my code', () => { beforeEachProviders(() => [MyService]); it('does stuff', inject([MyService], (service) => { // actual test }); }); ``` After: ```js import {addProviders, inject} from 'angular2/testing/core'; describe('my code', () => { beforeEach(() => { addProviders([MyService]); }); it('does stuff', inject([MyService], (service) => { // actual test }); }); ```
2016-06-24 20:48:35 -04:00
export function addProviders(providers: Array<any>): void {
if (!providers) return;
try {
feat(testing): add implicit test module Every test now has an implicit module. It can be configured via `configureModule` (from @angular/core/testing) to add providers, directives, pipes, ... The compiler now has to be configured separately via `configureCompiler` (from @angular/core/testing) to add providers or define whether to use jit. BREAKING CHANGE: - Application providers can no longer inject compiler internals (i.e. everything from `@angular/compiler). Inject `Compiler` instead. This reflects the changes to `bootstrap` for module support (3f55aa609f60f130f1d69188ed057214b1267cb3). - Compiler providers can no longer be added via `addProviders` / `withProviders`. Use the new method `configureCompiler` instead. - Platform directives / pipes need to be provided via `configureModule` and can no longer be provided via the `PLATFORM_PIPES` / `PLATFORM_DIRECTIVES` tokens. - `setBaseTestProviders()` was renamed into `initTestEnvironment` and now takes a `PlatformRef` and a factory for a `Compiler`. - E.g. for the browser platform: BEFORE: ``` import {setBaseTestProviders} from ‘@angular/core/testing’; import {TEST_BROWSER_DYNAMIC_PLATFORM_PROVIDERS, TEST_BROWSER_DYNAMIC_APPLICATION_PROVIDERS} from ‘@angular/platform-browser-dynamic/testing’; setBaseTestProviders(TEST_BROWSER_DYNAMIC_PLATFORM_PROVIDERS, TEST_BROWSER_DYNAMIC_APPLICATION_PROVIDERS); ``` AFTER: ``` import {setBaseTestProviders} from ‘@angular/core/testing’; import {browserTestCompiler, browserDynamicTestPlatform, BrowserDynamicTestModule} from ‘@angular/platform-browser-dynamic/testing’; initTestEnvironment( browserTestCompiler, browserDynamicTestPlatform(), BrowserDynamicTestModule); ``` - E.g. for the server platform: BEFORE: ``` import {setBaseTestProviders} from ‘@angular/core/testing’; import {TEST_SERVER_PLATFORM_PROVIDERS, TEST_SERVER_APPLICATION_PROVIDERS} from ‘@angular/platform-server/testing/server’; setBaseTestProviders(TEST_SERVER_PLATFORM_PROVIDERS, TEST_SERVER_APPLICATION_PROVIDERS); ``` AFTER: ``` import {setBaseTestProviders} from ‘@angular/core/testing’; import {serverTestCompiler, serverTestPlatform, ServerTestModule} from ‘@angular/platform-browser-dynamic/testing’; initTestEnvironment( serverTestCompiler, serverTestPlatform(), ServerTestModule); ``` Related to #9726 Closes #9846
2016-07-04 12:37:30 -04:00
testInjector.configureModule({providers: providers});
refactor(testing): remove wrapping of Jasmine functions (#9564) Instead, the async function now determines whether it should return a promise or instead call a done function parameter. Importing Jasmine functions from `@angular/core/testing` is no longer necessary and is now deprecated. Additionally, beforeEachProviders is also deprecated, as it is specific to the testing framework. Instead, use the new addProviders method directly. Before: ```js import {beforeEachProviders, it, describe, inject} from 'angular2/testing/core'; describe('my code', () => { beforeEachProviders(() => [MyService]); it('does stuff', inject([MyService], (service) => { // actual test }); }); ``` After: ```js import {addProviders, inject} from 'angular2/testing/core'; describe('my code', () => { beforeEach(() => { addProviders([MyService]); }); it('does stuff', inject([MyService], (service) => { // actual test }); }); ```
2016-06-24 20:48:35 -04:00
} catch (e) {
throw new Error(
'addProviders can\'t be called after the injector has been already created for this test. ' +
'This is most likely because you\'ve already used the injector to inject a beforeEach or the ' +
'current `it` function.');
}
feat(test): Add an external version of the test library Adds test adapters for TypeScript and JavaScript only, exported as part of the test_lib module. These work with the Jasmine test framework, and allow use of the test injector within test blocks via the `inject` function. See #4572, #4177, #4035, #2783 This includes the TestComponentBuilder. It allows using the test injector with Jasmine bindings, and waits for returned promises before completing async test blocks.
2015-10-08 18:33:17 -04:00
}
feat(testing): add implicit test module Every test now has an implicit module. It can be configured via `configureModule` (from @angular/core/testing) to add providers, directives, pipes, ... The compiler now has to be configured separately via `configureCompiler` (from @angular/core/testing) to add providers or define whether to use jit. BREAKING CHANGE: - Application providers can no longer inject compiler internals (i.e. everything from `@angular/compiler). Inject `Compiler` instead. This reflects the changes to `bootstrap` for module support (3f55aa609f60f130f1d69188ed057214b1267cb3). - Compiler providers can no longer be added via `addProviders` / `withProviders`. Use the new method `configureCompiler` instead. - Platform directives / pipes need to be provided via `configureModule` and can no longer be provided via the `PLATFORM_PIPES` / `PLATFORM_DIRECTIVES` tokens. - `setBaseTestProviders()` was renamed into `initTestEnvironment` and now takes a `PlatformRef` and a factory for a `Compiler`. - E.g. for the browser platform: BEFORE: ``` import {setBaseTestProviders} from ‘@angular/core/testing’; import {TEST_BROWSER_DYNAMIC_PLATFORM_PROVIDERS, TEST_BROWSER_DYNAMIC_APPLICATION_PROVIDERS} from ‘@angular/platform-browser-dynamic/testing’; setBaseTestProviders(TEST_BROWSER_DYNAMIC_PLATFORM_PROVIDERS, TEST_BROWSER_DYNAMIC_APPLICATION_PROVIDERS); ``` AFTER: ``` import {setBaseTestProviders} from ‘@angular/core/testing’; import {browserTestCompiler, browserDynamicTestPlatform, BrowserDynamicTestModule} from ‘@angular/platform-browser-dynamic/testing’; initTestEnvironment( browserTestCompiler, browserDynamicTestPlatform(), BrowserDynamicTestModule); ``` - E.g. for the server platform: BEFORE: ``` import {setBaseTestProviders} from ‘@angular/core/testing’; import {TEST_SERVER_PLATFORM_PROVIDERS, TEST_SERVER_APPLICATION_PROVIDERS} from ‘@angular/platform-server/testing/server’; setBaseTestProviders(TEST_SERVER_PLATFORM_PROVIDERS, TEST_SERVER_APPLICATION_PROVIDERS); ``` AFTER: ``` import {setBaseTestProviders} from ‘@angular/core/testing’; import {serverTestCompiler, serverTestPlatform, ServerTestModule} from ‘@angular/platform-browser-dynamic/testing’; initTestEnvironment( serverTestCompiler, serverTestPlatform(), ServerTestModule); ``` Related to #9726 Closes #9846
2016-07-04 12:37:30 -04:00
/**
* Allows overriding default providers, directives, pipes, modules of the test injector,
* which are defined in test_injector.js
*
* @stable
*/
export function configureModule(moduleDef: {
providers?: any[],
directives?: any[],
pipes?: any[],
precompile?: any[],
modules?: any[]
}): void {
if (!moduleDef) return;
try {
testInjector.configureModule(moduleDef);
} catch (e) {
throw new Error(
'configureModule can\'t be called after the injector has been already created for this test. ' +
'This is most likely because you\'ve already used the injector to inject a beforeEach or the ' +
'current `it` function.');
}
}
/**
* Allows overriding default compiler providers and settings
* which are defined in test_injector.js
*
* @stable
*/
export function configureCompiler(config: {providers?: any[], useJit?: boolean}): void {
if (!config) return;
try {
testInjector.configureCompiler(config);
} catch (e) {
throw new Error(
'configureCompiler can\'t be called after the injector has been already created for this test. ' +
'This is most likely because you\'ve already used the injector to inject a beforeEach or the ' +
'current `it` function.');
}
}
feat(testing): use zones to avoid the need for injectAsync Use a zone counting timeouts and microtasks to determine when a test is finished, instead of requiring the test writer to use injectAsync and return a promise. See #5322
2015-11-18 21:46:24 -05:00
/**
refactor(testing): remove wrapping of Jasmine functions (#9564) Instead, the async function now determines whether it should return a promise or instead call a done function parameter. Importing Jasmine functions from `@angular/core/testing` is no longer necessary and is now deprecated. Additionally, beforeEachProviders is also deprecated, as it is specific to the testing framework. Instead, use the new addProviders method directly. Before: ```js import {beforeEachProviders, it, describe, inject} from 'angular2/testing/core'; describe('my code', () => { beforeEachProviders(() => [MyService]); it('does stuff', inject([MyService], (service) => { // actual test }); }); ``` After: ```js import {addProviders, inject} from 'angular2/testing/core'; describe('my code', () => { beforeEach(() => { addProviders([MyService]); }); it('does stuff', inject([MyService], (service) => { // actual test }); }); ```
2016-06-24 20:48:35 -04:00
* @deprecated Use beforeEach(() => addProviders())
feat(testing): use zones to avoid the need for injectAsync Use a zone counting timeouts and microtasks to determine when a test is finished, instead of requiring the test writer to use injectAsync and return a promise. See #5322
2015-11-18 21:46:24 -05:00
*/
refactor(testing): remove wrapping of Jasmine functions (#9564) Instead, the async function now determines whether it should return a promise or instead call a done function parameter. Importing Jasmine functions from `@angular/core/testing` is no longer necessary and is now deprecated. Additionally, beforeEachProviders is also deprecated, as it is specific to the testing framework. Instead, use the new addProviders method directly. Before: ```js import {beforeEachProviders, it, describe, inject} from 'angular2/testing/core'; describe('my code', () => { beforeEachProviders(() => [MyService]); it('does stuff', inject([MyService], (service) => { // actual test }); }); ``` After: ```js import {addProviders, inject} from 'angular2/testing/core'; describe('my code', () => { beforeEach(() => { addProviders([MyService]); }); it('does stuff', inject([MyService], (service) => { // actual test }); }); ```
2016-06-24 20:48:35 -04:00
export function beforeEachProviders(fn: () => Array<any>): void {
beforeEach(() => { addProviders(fn()); });
feat(test): Add an external version of the test library Adds test adapters for TypeScript and JavaScript only, exported as part of the test_lib module. These work with the Jasmine test framework, and allow use of the test injector within test blocks via the `inject` function. See #4572, #4177, #4035, #2783 This includes the TestComponentBuilder. It allows using the test injector with Jasmine bindings, and waits for returned promises before completing async test blocks.
2015-10-08 18:33:17 -04:00
}