2015-11-06 20:34:07 -05:00
|
|
|
import {StringMapWrapper} from 'angular2/src/facade/collection';
|
|
|
|
import {global, isFunction, Math} from 'angular2/src/facade/lang';
|
2015-05-20 20:19:46 -04:00
|
|
|
|
2015-12-04 08:29:39 -05:00
|
|
|
import {provide} from 'angular2/core';
|
2015-05-20 20:19:46 -04:00
|
|
|
|
2016-02-25 17:24:17 -05:00
|
|
|
import {getTestInjector, FunctionWithParamTokens, inject} from './test_injector';
|
2015-09-09 10:41:11 -04:00
|
|
|
import {browserDetection} from './utils';
|
2016-02-25 17:24:17 -05:00
|
|
|
import {NgZone} from 'angular2/src/core/zone/ng_zone';
|
2015-05-20 20:19:46 -04:00
|
|
|
|
|
|
|
export {inject} from './test_injector';
|
|
|
|
|
2015-10-08 18:33:17 -04:00
|
|
|
export {expect, NgMatchers} from './matchers';
|
|
|
|
|
2015-08-06 13:02:49 -04:00
|
|
|
export var proxy: ClassDecorator = (t) => t;
|
2015-05-20 20:19:46 -04:00
|
|
|
|
2016-02-01 13:28:57 -05:00
|
|
|
var _global = <any>(typeof window === 'undefined' ? global : window);
|
2015-05-20 20:19:46 -04:00
|
|
|
|
2015-09-03 17:45:25 -04:00
|
|
|
export var afterEach: Function = _global.afterEach;
|
2015-05-21 19:30:07 -04:00
|
|
|
|
2015-09-03 17:45:25 -04:00
|
|
|
export type SyncTestFn = () => void;
|
2015-08-28 19:23:28 -04:00
|
|
|
type AsyncTestFn = (done: () => void) => void;
|
|
|
|
type AnyTestFn = SyncTestFn | AsyncTestFn;
|
|
|
|
|
2015-12-03 18:49:09 -05:00
|
|
|
/**
|
|
|
|
* Injectable completer that allows signaling completion of an asynchronous test. Used internally.
|
|
|
|
*/
|
2015-05-20 20:19:46 -04:00
|
|
|
export class AsyncTestCompleter {
|
2015-08-28 19:23:28 -04:00
|
|
|
constructor(private _done: Function) {}
|
2015-05-20 20:19:46 -04:00
|
|
|
|
2015-08-28 19:23:28 -04:00
|
|
|
done(): void { this._done(); }
|
2015-05-20 20:19:46 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
var jsmBeforeEach = _global.beforeEach;
|
|
|
|
var jsmDescribe = _global.describe;
|
|
|
|
var jsmDDescribe = _global.fdescribe;
|
|
|
|
var jsmXDescribe = _global.xdescribe;
|
|
|
|
var jsmIt = _global.it;
|
|
|
|
var jsmIIt = _global.fit;
|
|
|
|
var jsmXIt = _global.xit;
|
|
|
|
|
|
|
|
var runnerStack = [];
|
|
|
|
var inIt = false;
|
2015-10-26 13:19:52 -04:00
|
|
|
jasmine.DEFAULT_TIMEOUT_INTERVAL = 500;
|
2015-09-09 10:41:11 -04:00
|
|
|
var globalTimeOut = browserDetection.isSlow ? 3000 : jasmine.DEFAULT_TIMEOUT_INTERVAL;
|
2015-05-20 20:19:46 -04:00
|
|
|
|
2015-12-08 22:03:21 -05:00
|
|
|
var testInjector = getTestInjector();
|
2015-05-20 20:19:46 -04:00
|
|
|
|
2015-08-28 19:23:28 -04:00
|
|
|
/**
|
|
|
|
* Mechanism to run `beforeEach()` functions of Angular tests.
|
|
|
|
*
|
2015-10-11 01:11:13 -04:00
|
|
|
* Note: Jasmine own `beforeEach` is used by this library to handle DI providers.
|
2015-08-28 19:23:28 -04:00
|
|
|
*/
|
2015-05-20 20:19:46 -04:00
|
|
|
class BeforeEachRunner {
|
2016-04-12 12:40:37 -04:00
|
|
|
private _fns: Array<FunctionWithParamTokens | SyncTestFn> = [];
|
2015-05-20 20:19:46 -04:00
|
|
|
|
2015-08-28 19:23:28 -04:00
|
|
|
constructor(private _parent: BeforeEachRunner) {}
|
2015-05-20 20:19:46 -04:00
|
|
|
|
2016-04-12 12:40:37 -04:00
|
|
|
beforeEach(fn: FunctionWithParamTokens | SyncTestFn): void { this._fns.push(fn); }
|
2015-08-28 19:23:28 -04:00
|
|
|
|
2015-12-08 22:03:21 -05:00
|
|
|
run(): void {
|
|
|
|
if (this._parent) this._parent.run();
|
2015-08-28 19:23:28 -04:00
|
|
|
this._fns.forEach((fn) => {
|
2015-12-08 22:03:21 -05:00
|
|
|
return isFunction(fn) ? (<SyncTestFn>fn)() :
|
|
|
|
(testInjector.execute(<FunctionWithParamTokens>fn));
|
2015-08-28 19:23:28 -04:00
|
|
|
});
|
2015-05-20 20:19:46 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-10-11 01:11:13 -04:00
|
|
|
// Reset the test providers before each test
|
2015-12-08 22:03:21 -05:00
|
|
|
jsmBeforeEach(() => { testInjector.reset(); });
|
2015-05-20 20:19:46 -04:00
|
|
|
|
2015-06-02 12:51:40 -04:00
|
|
|
function _describe(jsmFn, ...args) {
|
2015-05-20 20:19:46 -04:00
|
|
|
var parentRunner = runnerStack.length === 0 ? null : runnerStack[runnerStack.length - 1];
|
|
|
|
var runner = new BeforeEachRunner(parentRunner);
|
|
|
|
runnerStack.push(runner);
|
2015-06-02 12:51:40 -04:00
|
|
|
var suite = jsmFn(...args);
|
2015-05-20 20:19:46 -04:00
|
|
|
runnerStack.pop();
|
|
|
|
return suite;
|
|
|
|
}
|
|
|
|
|
2015-09-03 17:45:25 -04:00
|
|
|
export function describe(...args): void {
|
2015-06-02 12:51:40 -04:00
|
|
|
return _describe(jsmDescribe, ...args);
|
2015-05-20 20:19:46 -04:00
|
|
|
}
|
|
|
|
|
2015-09-03 17:45:25 -04:00
|
|
|
export function ddescribe(...args): void {
|
2015-06-02 12:51:40 -04:00
|
|
|
return _describe(jsmDDescribe, ...args);
|
2015-05-20 20:19:46 -04:00
|
|
|
}
|
|
|
|
|
2015-09-03 17:45:25 -04:00
|
|
|
export function xdescribe(...args): void {
|
2015-06-02 12:51:40 -04:00
|
|
|
return _describe(jsmXDescribe, ...args);
|
2015-05-20 20:19:46 -04:00
|
|
|
}
|
|
|
|
|
2015-09-03 17:45:25 -04:00
|
|
|
export function beforeEach(fn: FunctionWithParamTokens | SyncTestFn): void {
|
2015-05-20 20:19:46 -04:00
|
|
|
if (runnerStack.length > 0) {
|
|
|
|
// Inside a describe block, beforeEach() uses a BeforeEachRunner
|
2015-08-28 19:23:28 -04:00
|
|
|
runnerStack[runnerStack.length - 1].beforeEach(fn);
|
2015-05-20 20:19:46 -04:00
|
|
|
} else {
|
|
|
|
// Top level beforeEach() are delegated to jasmine
|
2015-08-28 19:23:28 -04:00
|
|
|
jsmBeforeEach(<SyncTestFn>fn);
|
2015-05-20 20:19:46 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2015-10-11 01:11:13 -04:00
|
|
|
* Allows overriding default providers defined in test_injector.js.
|
2015-05-20 20:19:46 -04:00
|
|
|
*
|
2015-10-11 01:11:13 -04:00
|
|
|
* The given function must return a list of DI providers.
|
2015-05-20 20:19:46 -04:00
|
|
|
*
|
|
|
|
* Example:
|
|
|
|
*
|
2015-11-11 08:28:23 -05:00
|
|
|
* beforeEachProviders(() => [
|
2015-10-12 14:30:34 -04:00
|
|
|
* provide(Compiler, {useClass: MockCompiler}),
|
|
|
|
* provide(SomeToken, {useValue: myValue}),
|
2015-05-20 20:19:46 -04:00
|
|
|
* ]);
|
|
|
|
*/
|
2015-10-11 01:11:13 -04:00
|
|
|
export function beforeEachProviders(fn): void {
|
2015-05-20 20:19:46 -04:00
|
|
|
jsmBeforeEach(() => {
|
2015-11-11 08:28:23 -05:00
|
|
|
var providers = fn();
|
|
|
|
if (!providers) return;
|
2015-12-08 22:03:21 -05:00
|
|
|
testInjector.addProviders(providers);
|
2015-05-20 20:19:46 -04:00
|
|
|
});
|
|
|
|
}
|
|
|
|
|
2015-10-11 01:11:13 -04:00
|
|
|
/**
|
|
|
|
* @deprecated
|
|
|
|
*/
|
|
|
|
export function beforeEachBindings(fn): void {
|
|
|
|
beforeEachProviders(fn);
|
|
|
|
}
|
|
|
|
|
2016-04-12 12:40:37 -04:00
|
|
|
function _it(jsmFn: Function, name: string, testFn: FunctionWithParamTokens | AnyTestFn,
|
|
|
|
testTimeOut: number): void {
|
2015-05-20 20:19:46 -04:00
|
|
|
var runner = runnerStack[runnerStack.length - 1];
|
2015-09-09 10:41:11 -04:00
|
|
|
var timeOut = Math.max(globalTimeOut, testTimeOut);
|
2015-05-20 20:19:46 -04:00
|
|
|
|
2015-08-28 19:23:28 -04:00
|
|
|
if (testFn instanceof FunctionWithParamTokens) {
|
|
|
|
// The test case uses inject(). ie `it('test', inject([AsyncTestCompleter], (async) => { ...
|
|
|
|
// }));`
|
2016-04-07 16:29:52 -04:00
|
|
|
let testFnT = testFn;
|
2015-08-28 19:23:28 -04:00
|
|
|
|
|
|
|
if (testFn.hasToken(AsyncTestCompleter)) {
|
|
|
|
jsmFn(name, (done) => {
|
2015-10-11 01:11:13 -04:00
|
|
|
var completerProvider = provide(AsyncTestCompleter, {
|
2015-10-12 14:30:34 -04:00
|
|
|
useFactory: () => {
|
2015-10-11 01:11:13 -04:00
|
|
|
// Mark the test as async when an AsyncTestCompleter is injected in an it()
|
|
|
|
if (!inIt) throw new Error('AsyncTestCompleter can only be injected in an "it()"');
|
|
|
|
return new AsyncTestCompleter(done);
|
|
|
|
}
|
|
|
|
});
|
|
|
|
|
2015-12-08 22:03:21 -05:00
|
|
|
testInjector.addProviders([completerProvider]);
|
|
|
|
runner.run();
|
2015-08-28 19:23:28 -04:00
|
|
|
|
|
|
|
inIt = true;
|
2016-04-07 16:29:52 -04:00
|
|
|
testInjector.execute(testFnT);
|
2015-08-28 19:23:28 -04:00
|
|
|
inIt = false;
|
|
|
|
}, timeOut);
|
|
|
|
} else {
|
|
|
|
jsmFn(name, () => {
|
2015-12-08 22:03:21 -05:00
|
|
|
runner.run();
|
2016-04-07 16:29:52 -04:00
|
|
|
testInjector.execute(testFnT);
|
2015-08-28 19:23:28 -04:00
|
|
|
}, timeOut);
|
2015-05-20 20:19:46 -04:00
|
|
|
}
|
|
|
|
|
2015-08-28 19:23:28 -04:00
|
|
|
} else {
|
|
|
|
// The test case doesn't use inject(). ie `it('test', (done) => { ... }));`
|
|
|
|
|
|
|
|
if ((<any>testFn).length === 0) {
|
|
|
|
jsmFn(name, () => {
|
2015-12-08 22:03:21 -05:00
|
|
|
runner.run();
|
2015-08-28 19:23:28 -04:00
|
|
|
(<SyncTestFn>testFn)();
|
|
|
|
}, timeOut);
|
|
|
|
} else {
|
|
|
|
jsmFn(name, (done) => {
|
2015-12-08 22:03:21 -05:00
|
|
|
runner.run();
|
2015-08-28 19:23:28 -04:00
|
|
|
(<AsyncTestFn>testFn)(done);
|
|
|
|
}, timeOut);
|
|
|
|
}
|
|
|
|
}
|
2015-05-20 20:19:46 -04:00
|
|
|
}
|
|
|
|
|
2015-09-03 17:45:25 -04:00
|
|
|
export function it(name, fn, timeOut = null): void {
|
2015-06-02 10:29:09 -04:00
|
|
|
return _it(jsmIt, name, fn, timeOut);
|
2015-05-20 20:19:46 -04:00
|
|
|
}
|
|
|
|
|
2015-09-03 17:45:25 -04:00
|
|
|
export function xit(name, fn, timeOut = null): void {
|
2015-06-02 10:29:09 -04:00
|
|
|
return _it(jsmXIt, name, fn, timeOut);
|
2015-05-20 20:19:46 -04:00
|
|
|
}
|
|
|
|
|
2015-09-03 17:45:25 -04:00
|
|
|
export function iit(name, fn, timeOut = null): void {
|
2015-06-02 10:29:09 -04:00
|
|
|
return _it(jsmIIt, name, fn, timeOut);
|
2015-05-20 20:19:46 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
export interface GuinessCompatibleSpy extends jasmine.Spy {
|
|
|
|
/** By chaining the spy with and.returnValue, all calls to the function will return a specific
|
|
|
|
* value. */
|
|
|
|
andReturn(val: any): void;
|
|
|
|
/** By chaining the spy with and.callFake, all calls to the spy will delegate to the supplied
|
|
|
|
* function. */
|
|
|
|
andCallFake(fn: Function): GuinessCompatibleSpy;
|
2015-06-24 16:46:39 -04:00
|
|
|
/** removes all recorded calls */
|
|
|
|
reset();
|
2015-05-20 20:19:46 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
export class SpyObject {
|
2015-06-18 18:40:12 -04:00
|
|
|
constructor(type = null) {
|
2015-05-20 20:19:46 -04:00
|
|
|
if (type) {
|
|
|
|
for (var prop in type.prototype) {
|
|
|
|
var m = null;
|
|
|
|
try {
|
|
|
|
m = type.prototype[prop];
|
|
|
|
} catch (e) {
|
|
|
|
// As we are creating spys for abstract classes,
|
|
|
|
// these classes might have getters that throw when they are accessed.
|
|
|
|
// As we are only auto creating spys for methods, this
|
|
|
|
// should not matter.
|
|
|
|
}
|
|
|
|
if (typeof m === 'function') {
|
2015-06-18 18:40:12 -04:00
|
|
|
this.spy(prop);
|
2015-05-20 20:19:46 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2015-09-11 17:51:43 -04:00
|
|
|
// Noop so that SpyObject has the same interface as in Dart
|
2015-05-26 12:25:16 -04:00
|
|
|
noSuchMethod(args) {}
|
|
|
|
|
2015-05-20 20:19:46 -04:00
|
|
|
spy(name) {
|
|
|
|
if (!this[name]) {
|
2015-06-18 18:40:12 -04:00
|
|
|
this[name] = this._createGuinnessCompatibleSpy(name);
|
2015-05-20 20:19:46 -04:00
|
|
|
}
|
|
|
|
return this[name];
|
|
|
|
}
|
|
|
|
|
2015-08-26 14:41:41 -04:00
|
|
|
prop(name, value) { this[name] = value; }
|
|
|
|
|
2015-05-20 20:19:46 -04:00
|
|
|
static stub(object = null, config = null, overrides = null) {
|
|
|
|
if (!(object instanceof SpyObject)) {
|
|
|
|
overrides = config;
|
|
|
|
config = object;
|
|
|
|
object = new SpyObject();
|
|
|
|
}
|
|
|
|
|
|
|
|
var m = StringMapWrapper.merge(config, overrides);
|
|
|
|
StringMapWrapper.forEach(m, (value, key) => { object.spy(key).andReturn(value); });
|
|
|
|
return object;
|
|
|
|
}
|
|
|
|
|
2015-10-09 20:21:25 -04:00
|
|
|
/** @internal */
|
2015-05-20 20:19:46 -04:00
|
|
|
_createGuinnessCompatibleSpy(name): GuinessCompatibleSpy {
|
|
|
|
var newSpy: GuinessCompatibleSpy = <any>jasmine.createSpy(name);
|
|
|
|
newSpy.andCallFake = <any>newSpy.and.callFake;
|
|
|
|
newSpy.andReturn = <any>newSpy.and.returnValue;
|
2015-06-24 16:46:39 -04:00
|
|
|
newSpy.reset = <any>newSpy.calls.reset;
|
2015-09-09 22:00:22 -04:00
|
|
|
// revisit return null here (previously needed for rtts_assert).
|
2015-05-20 20:19:46 -04:00
|
|
|
newSpy.and.returnValue(null);
|
|
|
|
return newSpy;
|
|
|
|
}
|
|
|
|
}
|