mirror of
https://github.com/wassname/DefinitelyTyped.git
synced 2026-09-09 11:13:57 +08:00
Copied v1.3 definitions and tests to separate versioned files
This commit is contained in:
Theodore Brown
@@ -0,0 +1,449 @@
|
||||
/// <reference path="jasmine-1.3.d.ts" />
|
||||
|
||||
describe("A suite", () => {
|
||||
it("contains spec with an expectation", () => {
|
||||
expect(true).toBe(true);
|
||||
});
|
||||
});
|
||||
|
||||
describe("A suite is just a function", () => {
|
||||
var a: boolean;
|
||||
it("and so is a spec", () => {
|
||||
a = true;
|
||||
expect(a).toBe(true);
|
||||
});
|
||||
});
|
||||
|
||||
describe("The 'toBe' matcher compares with ===", () => {
|
||||
it("and has a positive case ", () => {
|
||||
expect(true).toBe(true);
|
||||
});
|
||||
it("and can have a negative case", () => {
|
||||
expect(false).not.toBe(true);
|
||||
});
|
||||
});
|
||||
|
||||
describe("Included matchers:", () => {
|
||||
it("The 'toBe' matcher compares with ===", () => {
|
||||
var a = 12;
|
||||
var b = a;
|
||||
expect(a).toBe(b);
|
||||
expect(a).not.toBe(null);
|
||||
});
|
||||
describe("The 'toEqual' matcher", () => {
|
||||
it("works for simple literals and variables", () => {
|
||||
var a = 12;
|
||||
expect(a).toEqual(12);
|
||||
});
|
||||
it("should work for objects", () => {
|
||||
var foo = {
|
||||
a: 12,
|
||||
b: 34
|
||||
};
|
||||
var bar = {
|
||||
a: 12,
|
||||
b: 34
|
||||
};
|
||||
expect(foo).toEqual(bar);
|
||||
});
|
||||
});
|
||||
|
||||
it("The 'toMatch' matcher is for regular expressions", () => {
|
||||
var message = 'foo bar baz';
|
||||
expect(message).toMatch(/bar/);
|
||||
expect(message).toMatch('bar');
|
||||
expect(message).not.toMatch(/quux/);
|
||||
});
|
||||
|
||||
it("The 'toBeDefined' matcher compares against `undefined`", () => {
|
||||
var a = {
|
||||
foo: 'foo'
|
||||
};
|
||||
expect(a.foo).toBeDefined();
|
||||
expect((<any>a).bar).not.toBeDefined();
|
||||
});
|
||||
|
||||
it("The `toBeUndefined` matcher compares against `undefined`", () => {
|
||||
var a = {
|
||||
foo: 'foo'
|
||||
};
|
||||
expect(a.foo).not.toBeUndefined();
|
||||
expect((<any>a).bar).toBeUndefined();
|
||||
});
|
||||
|
||||
it("The 'toBeNull' matcher compares against null", () => {
|
||||
var a: string = null;
|
||||
var foo = 'foo';
|
||||
expect(null).toBeNull();
|
||||
expect(a).toBeNull();
|
||||
expect(foo).not.toBeNull();
|
||||
});
|
||||
|
||||
it("The 'toBeTruthy' matcher is for boolean casting testing", () => {
|
||||
var a: string, foo = 'foo';
|
||||
expect(foo).toBeTruthy();
|
||||
expect(a).not.toBeTruthy();
|
||||
});
|
||||
|
||||
it("The 'toBeFalsy' matcher is for boolean casting testing", () => {
|
||||
var a: string, foo = 'foo';
|
||||
expect(a).toBeFalsy();
|
||||
expect(foo).not.toBeFalsy();
|
||||
});
|
||||
|
||||
it("The 'toContain' matcher is for finding an item in an Array", () => {
|
||||
var a = ['foo', 'bar', 'baz'];
|
||||
expect(a).toContain('bar');
|
||||
expect(a).not.toContain('quux');
|
||||
});
|
||||
|
||||
it("The 'toBeLessThan' matcher is for mathematical comparisons", () => {
|
||||
var pi = 3.1415926, e = 2.78;
|
||||
expect(e).toBeLessThan(pi);
|
||||
expect(pi).not.toBeLessThan(e);
|
||||
});
|
||||
|
||||
it("The 'toBeGreaterThan' is for mathematical comparisons", () => {
|
||||
var pi = 3.1415926, e = 2.78;
|
||||
expect(pi).toBeGreaterThan(e);
|
||||
expect(e).not.toBeGreaterThan(pi);
|
||||
});
|
||||
|
||||
it("The 'toBeCloseTo' matcher is for precision math comparison", () => {
|
||||
var pi = 3.1415926, e = 2.78;
|
||||
expect(pi).not.toBeCloseTo(e, 0.1);
|
||||
expect(pi).toBeCloseTo(e, 0);
|
||||
});
|
||||
|
||||
it("The 'toThrow' matcher is for testing if a function throws an exception", () => {
|
||||
var foo = () => {
|
||||
return 1 + 2;
|
||||
};
|
||||
var bar = () => {
|
||||
//return a + 1;
|
||||
};
|
||||
expect(foo).not.toThrow();
|
||||
expect(bar).toThrow();
|
||||
});
|
||||
});
|
||||
|
||||
describe("A spec", () => {
|
||||
it("is just a function, so it can contain any code", () => {
|
||||
var foo = 0;
|
||||
foo += 1;
|
||||
expect(foo).toEqual(1);
|
||||
});
|
||||
|
||||
it("can have more than one expectation", () => {
|
||||
var foo = 0;
|
||||
foo += 1;
|
||||
expect(foo).toEqual(1);
|
||||
expect(true).toEqual(true);
|
||||
});
|
||||
});
|
||||
|
||||
describe("A spec (with setup and tear-down)", () => {
|
||||
var foo: number;
|
||||
beforeEach(() => {
|
||||
foo = 0;
|
||||
foo += 1;
|
||||
});
|
||||
afterEach(() => {
|
||||
foo = 0;
|
||||
});
|
||||
it("is just a function, so it can contain any code", () => {
|
||||
expect(foo).toEqual(1);
|
||||
});
|
||||
it("can have more than one expectation", () => {
|
||||
expect(foo).toEqual(1);
|
||||
expect(true).toEqual(true);
|
||||
});
|
||||
});
|
||||
|
||||
describe("A spec", () => {
|
||||
var foo: number;
|
||||
beforeEach(() => {
|
||||
foo = 0;
|
||||
foo += 1;
|
||||
});
|
||||
afterEach(() => {
|
||||
foo = 0;
|
||||
});
|
||||
it("is just a function, so it can contain any code", () => {
|
||||
expect(foo).toEqual(1);
|
||||
});
|
||||
it("can have more than one expectation", () => {
|
||||
expect(foo).toEqual(1);
|
||||
expect(true).toEqual(true);
|
||||
});
|
||||
describe("nested inside a second describe", () => {
|
||||
var bar: number;
|
||||
beforeEach(() => {
|
||||
bar = 1;
|
||||
});
|
||||
it("can reference both scopes as needed ", () => {
|
||||
expect(foo).toEqual(bar);
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
xdescribe("A spec", () => {
|
||||
var foo: number;
|
||||
beforeEach(() => {
|
||||
foo = 0;
|
||||
foo += 1;
|
||||
});
|
||||
xit("is just a function, so it can contain any code", () => {
|
||||
expect(foo).toEqual(1);
|
||||
});
|
||||
});
|
||||
|
||||
describe("A spy", () => {
|
||||
var foo: any, bar: any = null;
|
||||
beforeEach(() => {
|
||||
foo = {
|
||||
setBar: function (value: any) {
|
||||
bar = value;
|
||||
}
|
||||
};
|
||||
spyOn(foo, 'setBar');
|
||||
foo.setBar(123);
|
||||
foo.setBar(456, 'another param');
|
||||
});
|
||||
it("tracks that the spy was called", () => {
|
||||
expect(foo.setBar).toHaveBeenCalled();
|
||||
});
|
||||
it("tracks its number of calls", () => {
|
||||
expect(foo.setBar.calls.length).toEqual(2);
|
||||
});
|
||||
it("tracks all the arguments of its calls", () => {
|
||||
expect(foo.setBar).toHaveBeenCalledWith(123);
|
||||
expect(foo.setBar).toHaveBeenCalledWith(456, 'another param');
|
||||
});
|
||||
it("allows access to the most recent call", () => {
|
||||
expect(foo.setBar.mostRecentCall.args[0]).toEqual(456);
|
||||
});
|
||||
it("allows access to other calls", () => {
|
||||
expect(foo.setBar.calls[0].args[0]).toEqual(123);
|
||||
});
|
||||
it("stops all execution on a function", () => {
|
||||
expect(bar).toBeNull();
|
||||
});
|
||||
});
|
||||
|
||||
describe("A spy, when configured to call through", () => {
|
||||
var foo: any, bar: any, fetchedBar: any;
|
||||
beforeEach(() => {
|
||||
foo = {
|
||||
setBar: function (value: any) {
|
||||
bar = value;
|
||||
},
|
||||
getBar: () => {
|
||||
return bar;
|
||||
}
|
||||
};
|
||||
spyOn(foo, 'getBar').andCallThrough();
|
||||
foo.setBar(123);
|
||||
fetchedBar = foo.getBar();
|
||||
});
|
||||
it("tracks that the spy was called", () => {
|
||||
expect(foo.getBar).toHaveBeenCalled();
|
||||
});
|
||||
it("should not effect other functions", () => {
|
||||
expect(bar).toEqual(123);
|
||||
});
|
||||
it("when called returns the requested value", () => {
|
||||
expect(fetchedBar).toEqual(123);
|
||||
});
|
||||
});
|
||||
|
||||
describe("A spy, when faking a return value", () => {
|
||||
var foo: any, bar: any, fetchedBar: any;
|
||||
beforeEach(() => {
|
||||
foo = {
|
||||
setBar: function (value: any) {
|
||||
bar = value;
|
||||
},
|
||||
getBar: () => {
|
||||
return bar;
|
||||
}
|
||||
};
|
||||
spyOn(foo, 'getBar').andReturn(745);
|
||||
foo.setBar(123);
|
||||
fetchedBar = foo.getBar();
|
||||
});
|
||||
it("tracks that the spy was called", () => {
|
||||
expect(foo.getBar).toHaveBeenCalled();
|
||||
});
|
||||
it("should not effect other functions", () => {
|
||||
expect(bar).toEqual(123);
|
||||
});
|
||||
it("when called returns the requested value", () => {
|
||||
expect(fetchedBar).toEqual(745);
|
||||
});
|
||||
});
|
||||
|
||||
describe("A spy, when faking a return value", () => {
|
||||
var foo: any, bar: any, fetchedBar: any;
|
||||
beforeEach(() => {
|
||||
foo = {
|
||||
setBar: function (value: any) {
|
||||
bar = value;
|
||||
},
|
||||
getBar: () => {
|
||||
return bar;
|
||||
}
|
||||
};
|
||||
spyOn(foo, 'getBar').andCallFake(() => {
|
||||
return 1001;
|
||||
});
|
||||
foo.setBar(123);
|
||||
fetchedBar = foo.getBar();
|
||||
});
|
||||
it("tracks that the spy was called", () => {
|
||||
expect(foo.getBar).toHaveBeenCalled();
|
||||
});
|
||||
it("should not effect other functions", () => {
|
||||
expect(bar).toEqual(123);
|
||||
});
|
||||
it("when called returns the requested value", () => {
|
||||
expect(fetchedBar).toEqual(1001);
|
||||
});
|
||||
});
|
||||
|
||||
describe("A spy, when created manually", () => {
|
||||
var whatAmI: any;
|
||||
|
||||
beforeEach(() => {
|
||||
whatAmI = jasmine.createSpy('whatAmI');
|
||||
whatAmI("I", "am", "a", "spy");
|
||||
});
|
||||
it("is named, which helps in error reporting", () => {
|
||||
expect(whatAmI.identity).toEqual('whatAmI')
|
||||
});
|
||||
it("tracks that the spy was called", () => {
|
||||
expect(whatAmI).toHaveBeenCalled();
|
||||
});
|
||||
it("tracks its number of calls", () => {
|
||||
expect(whatAmI.calls.length).toEqual(1);
|
||||
});
|
||||
it("tracks all the arguments of its calls", () => {
|
||||
expect(whatAmI).toHaveBeenCalledWith("I", "am", "a", "spy");
|
||||
});
|
||||
it("allows access to the most recent call", () => {
|
||||
expect(whatAmI.mostRecentCall.args[0]).toEqual("I");
|
||||
});
|
||||
});
|
||||
|
||||
describe("Multiple spies, when created manually", () => {
|
||||
var tape: any;
|
||||
beforeEach(() => {
|
||||
tape = jasmine.createSpyObj('tape', ['play', 'pause', 'stop', 'rewind']);
|
||||
tape.play();
|
||||
tape.pause();
|
||||
tape.rewind(0);
|
||||
});
|
||||
it("creates spies for each requested function", () => {
|
||||
expect(tape.play).toBeDefined();
|
||||
expect(tape.pause).toBeDefined();
|
||||
expect(tape.stop).toBeDefined();
|
||||
expect(tape.rewind).toBeDefined();
|
||||
});
|
||||
it("tracks that the spies were called", () => {
|
||||
expect(tape.play).toHaveBeenCalled();
|
||||
expect(tape.pause).toHaveBeenCalled();
|
||||
expect(tape.rewind).toHaveBeenCalled();
|
||||
expect(tape.stop).not.toHaveBeenCalled();
|
||||
});
|
||||
it("tracks all the arguments of its calls", () => {
|
||||
expect(tape.rewind).toHaveBeenCalledWith(0);
|
||||
});
|
||||
});
|
||||
|
||||
describe("jasmine.any", () => {
|
||||
it("matches any value", () => {
|
||||
expect({}).toEqual(jasmine.any(Object));
|
||||
expect(12).toEqual(jasmine.any(Number));
|
||||
});
|
||||
describe("when used with a spy", () => {
|
||||
it("is useful for comparing arguments", () => {
|
||||
var foo = jasmine.createSpy('foo');
|
||||
foo(12, () => {
|
||||
return true
|
||||
});
|
||||
expect(foo).toHaveBeenCalledWith(jasmine.any(Number), jasmine.any(Function));
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
describe("Manually ticking the Jasmine Mock Clock", () => {
|
||||
var timerCallback: any;
|
||||
beforeEach(() => {
|
||||
timerCallback = jasmine.createSpy('timerCallback');
|
||||
jasmine.Clock.useMock();
|
||||
});
|
||||
it("causes a timeout to be called synchronously", () => {
|
||||
setTimeout(() => {
|
||||
timerCallback();
|
||||
}, 100);
|
||||
expect(timerCallback).not.toHaveBeenCalled();
|
||||
jasmine.Clock.tick(101);
|
||||
expect(timerCallback).toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it("causes an interval to be called synchronously", () => {
|
||||
setInterval(() => {
|
||||
timerCallback();
|
||||
}, 100);
|
||||
expect(timerCallback).not.toHaveBeenCalled();
|
||||
jasmine.Clock.tick(101);
|
||||
expect(timerCallback.callCount).toEqual(1);
|
||||
jasmine.Clock.tick(50);
|
||||
expect(timerCallback.callCount).toEqual(1);
|
||||
jasmine.Clock.tick(50);
|
||||
expect(timerCallback.callCount).toEqual(2);
|
||||
});
|
||||
});
|
||||
|
||||
describe("Asynchronous specs", () => {
|
||||
var value: number, flag: any;
|
||||
it("should support async execution of test preparation and exepectations", () => {
|
||||
runs(() => {
|
||||
flag = false;
|
||||
value = 0;
|
||||
setTimeout(() => {
|
||||
flag = true;
|
||||
}, 500);
|
||||
});
|
||||
waitsFor(() => {
|
||||
value++;
|
||||
return flag;
|
||||
}, "The Value should be incremented", 750);
|
||||
runs(() => {
|
||||
expect(value).toBeGreaterThan(0);
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
(() => {
|
||||
var jasmineEnv = jasmine.getEnv();
|
||||
jasmineEnv.updateInterval = 250;
|
||||
var htmlReporter = new jasmine.HtmlReporter();
|
||||
jasmineEnv.addReporter(htmlReporter);
|
||||
jasmineEnv.specFilter = function (spec) {
|
||||
return htmlReporter.specFilter(spec);
|
||||
};
|
||||
var currentWindowOnload = window.onload;
|
||||
window.onload = () => {
|
||||
if (currentWindowOnload) {
|
||||
currentWindowOnload(null);
|
||||
}
|
||||
|
||||
(<HTMLElement>document.querySelector('.version')).innerHTML = jasmineEnv.versionString();
|
||||
execJasmine();
|
||||
};
|
||||
|
||||
function execJasmine() {
|
||||
jasmineEnv.execute();
|
||||
}
|
||||
})();
|
||||
Vendored
+392
@@ -0,0 +1,392 @@
|
||||
// Type definitions for Jasmine 1.3
|
||||
// Project: http://pivotal.github.com/jasmine/
|
||||
// Definitions by: Boris Yankov <https://github.com/borisyankov/>
|
||||
// DefinitelyTyped: https://github.com/borisyankov/DefinitelyTyped
|
||||
|
||||
|
||||
declare function describe(description: string, specDefinitions: () => void): void;
|
||||
declare function xdescribe(description: string, specDefinitions: () => void): void;
|
||||
|
||||
declare function it(expectation: string, assertion: () => void): void;
|
||||
declare function it(expectation: string, assertion: (done: (err?: any) => void) => void): void;
|
||||
declare function xit(expectation: string, assertion: () => void): void;
|
||||
|
||||
declare function beforeEach(action: () => void): void;
|
||||
declare function afterEach(action: () => void): void;
|
||||
|
||||
declare function expect(spy: Function): jasmine.Matchers;
|
||||
//declare function expect(spy: jasmine.Spy): jasmine.Matchers;
|
||||
declare function expect(actual: any): jasmine.Matchers;
|
||||
|
||||
declare function spyOn(object: any, method: string): jasmine.Spy;
|
||||
|
||||
declare function runs(asyncMethod: Function): void;
|
||||
declare function waitsFor(latchMethod: () => boolean, failureMessage?: string, timeout?: number): void;
|
||||
declare function waits(timeout?: number): void;
|
||||
|
||||
declare module jasmine {
|
||||
|
||||
var Clock: Clock;
|
||||
|
||||
function any(aclass: any): Any;
|
||||
function objectContaining(sample: any): ObjectContaining;
|
||||
function createSpy(name: string, originalFn?: Function): Spy;
|
||||
function createSpyObj(baseName: string, methodNames: any[]): any;
|
||||
function createSpyObj<T>(baseName: string, methodNames: any[]): T;
|
||||
function pp(value: any): string;
|
||||
function getEnv(): Env;
|
||||
|
||||
interface Any {
|
||||
|
||||
new (expectedClass: any): any;
|
||||
|
||||
jasmineMatches(other: any): boolean;
|
||||
jasmineToString(): string;
|
||||
}
|
||||
|
||||
interface ObjectContaining {
|
||||
new (sample: any): any;
|
||||
|
||||
jasmineMatches(other: any, mismatchKeys: any[], mismatchValues: any[]): boolean;
|
||||
jasmineToString(): string;
|
||||
}
|
||||
|
||||
interface Block {
|
||||
|
||||
new (env: Env, func: SpecFunction, spec: Spec): any;
|
||||
|
||||
execute(onComplete: () => void): void;
|
||||
}
|
||||
|
||||
interface WaitsBlock extends Block {
|
||||
new (env: Env, timeout: number, spec: Spec): any;
|
||||
}
|
||||
|
||||
interface WaitsForBlock extends Block {
|
||||
new (env: Env, timeout: number, latchFunction: SpecFunction, message: string, spec: Spec): any;
|
||||
}
|
||||
|
||||
interface Clock {
|
||||
reset(): void;
|
||||
tick(millis: number): void;
|
||||
runFunctionsWithinRange(oldMillis: number, nowMillis: number): void;
|
||||
scheduleFunction(timeoutKey: any, funcToCall: () => void, millis: number, recurring: boolean): void;
|
||||
useMock(): void;
|
||||
installMock(): void;
|
||||
uninstallMock(): void;
|
||||
real: void;
|
||||
assertInstalled(): void;
|
||||
isInstalled(): boolean;
|
||||
installed: any;
|
||||
}
|
||||
|
||||
interface Env {
|
||||
setTimeout: any;
|
||||
clearTimeout: void;
|
||||
setInterval: any;
|
||||
clearInterval: void;
|
||||
updateInterval: number;
|
||||
|
||||
currentSpec: Spec;
|
||||
|
||||
matchersClass: Matchers;
|
||||
|
||||
version(): any;
|
||||
versionString(): string;
|
||||
nextSpecId(): number;
|
||||
addReporter(reporter: Reporter): void;
|
||||
execute(): void;
|
||||
describe(description: string, specDefinitions: () => void): Suite;
|
||||
beforeEach(beforeEachFunction: () => void): void;
|
||||
currentRunner(): Runner;
|
||||
afterEach(afterEachFunction: () => void): void;
|
||||
xdescribe(desc: string, specDefinitions: () => void): XSuite;
|
||||
it(description: string, func: () => void): Spec;
|
||||
xit(desc: string, func: () => void): XSpec;
|
||||
compareRegExps_(a: RegExp, b: RegExp, mismatchKeys: string[], mismatchValues: string[]): boolean;
|
||||
compareObjects_(a: any, b: any, mismatchKeys: string[], mismatchValues: string[]): boolean;
|
||||
equals_(a: any, b: any, mismatchKeys: string[], mismatchValues: string[]): boolean;
|
||||
contains_(haystack: any, needle: any): boolean;
|
||||
addEqualityTester(equalityTester: (a: any, b: any, env: Env, mismatchKeys: string[], mismatchValues: string[]) => boolean): void;
|
||||
specFilter(spec: Spec): boolean;
|
||||
}
|
||||
|
||||
interface FakeTimer {
|
||||
|
||||
new (): any;
|
||||
|
||||
reset(): void;
|
||||
tick(millis: number): void;
|
||||
runFunctionsWithinRange(oldMillis: number, nowMillis: number): void;
|
||||
scheduleFunction(timeoutKey: any, funcToCall: () => void, millis: number, recurring: boolean): void;
|
||||
}
|
||||
|
||||
interface HtmlReporter {
|
||||
new (): any;
|
||||
}
|
||||
|
||||
interface Result {
|
||||
type: string;
|
||||
}
|
||||
|
||||
interface NestedResults extends Result {
|
||||
description: string;
|
||||
|
||||
totalCount: number;
|
||||
passedCount: number;
|
||||
failedCount: number;
|
||||
|
||||
skipped: boolean;
|
||||
|
||||
rollupCounts(result: NestedResults): void;
|
||||
log(values: any): void;
|
||||
getItems(): Result[];
|
||||
addResult(result: Result): void;
|
||||
passed(): boolean;
|
||||
}
|
||||
|
||||
interface MessageResult extends Result {
|
||||
values: any;
|
||||
trace: Trace;
|
||||
}
|
||||
|
||||
interface ExpectationResult extends Result {
|
||||
matcherName: string;
|
||||
passed(): boolean;
|
||||
expected: any;
|
||||
actual: any;
|
||||
message: string;
|
||||
trace: Trace;
|
||||
}
|
||||
|
||||
interface Trace {
|
||||
name: string;
|
||||
message: string;
|
||||
stack: any;
|
||||
}
|
||||
|
||||
interface PrettyPrinter {
|
||||
|
||||
new (): any;
|
||||
|
||||
format(value: any): void;
|
||||
iterateObject(obj: any, fn: (property: string, isGetter: boolean) => void): void;
|
||||
emitScalar(value: any): void;
|
||||
emitString(value: string): void;
|
||||
emitArray(array: any[]): void;
|
||||
emitObject(obj: any): void;
|
||||
append(value: any): void;
|
||||
}
|
||||
|
||||
interface StringPrettyPrinter extends PrettyPrinter {
|
||||
}
|
||||
|
||||
interface Queue {
|
||||
|
||||
new (env: any): any;
|
||||
|
||||
env: Env;
|
||||
ensured: boolean[];
|
||||
blocks: Block[];
|
||||
running: boolean;
|
||||
index: number;
|
||||
offset: number;
|
||||
abort: boolean;
|
||||
|
||||
addBefore(block: Block, ensure?: boolean): void;
|
||||
add(block: any, ensure?: boolean): void;
|
||||
insertNext(block: any, ensure?: boolean): void;
|
||||
start(onComplete?: () => void): void;
|
||||
isRunning(): boolean;
|
||||
next_(): void;
|
||||
results(): NestedResults;
|
||||
}
|
||||
|
||||
interface Matchers {
|
||||
|
||||
new (env: Env, actual: any, spec: Env, isNot?: boolean): any;
|
||||
|
||||
env: Env;
|
||||
actual: any;
|
||||
spec: Env;
|
||||
isNot?: boolean;
|
||||
message(): any;
|
||||
|
||||
toBe(expected: any): boolean;
|
||||
toNotBe(expected: any): boolean;
|
||||
toEqual(expected: any): boolean;
|
||||
toNotEqual(expected: any): boolean;
|
||||
toMatch(expected: any): boolean;
|
||||
toNotMatch(expected: any): boolean;
|
||||
toBeDefined(): boolean;
|
||||
toBeUndefined(): boolean;
|
||||
toBeNull(): boolean;
|
||||
toBeNaN(): boolean;
|
||||
toBeTruthy(): boolean;
|
||||
toBeFalsy(): boolean;
|
||||
toHaveBeenCalled(): boolean;
|
||||
wasNotCalled(): boolean;
|
||||
toHaveBeenCalledWith(...params: any[]): boolean;
|
||||
toContain(expected: any): boolean;
|
||||
toNotContain(expected: any): boolean;
|
||||
toBeLessThan(expected: any): boolean;
|
||||
toBeGreaterThan(expected: any): boolean;
|
||||
toBeCloseTo(expected: any, precision: any): boolean;
|
||||
toContainHtml(expected: string): boolean;
|
||||
toContainText(expected: string): boolean;
|
||||
toThrow(expected?: any): boolean;
|
||||
not: Matchers;
|
||||
|
||||
Any: Any;
|
||||
}
|
||||
|
||||
interface Reporter {
|
||||
reportRunnerStarting(runner: Runner): void;
|
||||
reportRunnerResults(runner: Runner): void;
|
||||
reportSuiteResults(suite: Suite): void;
|
||||
reportSpecStarting(spec: Spec): void;
|
||||
reportSpecResults(spec: Spec): void;
|
||||
log(str: string): void;
|
||||
}
|
||||
|
||||
interface MultiReporter extends Reporter {
|
||||
addReporter(reporter: Reporter): void;
|
||||
}
|
||||
|
||||
interface Runner {
|
||||
|
||||
new (env: Env): any;
|
||||
|
||||
execute(): void;
|
||||
beforeEach(beforeEachFunction: SpecFunction): void;
|
||||
afterEach(afterEachFunction: SpecFunction): void;
|
||||
finishCallback(): void;
|
||||
addSuite(suite: Suite): void;
|
||||
add(block: Block): void;
|
||||
specs(): Spec[];
|
||||
suites(): Suite[];
|
||||
topLevelSuites(): Suite[];
|
||||
results(): NestedResults;
|
||||
}
|
||||
|
||||
interface SpecFunction {
|
||||
(spec?: Spec): void;
|
||||
}
|
||||
|
||||
interface SuiteOrSpec {
|
||||
id: number;
|
||||
env: Env;
|
||||
description: string;
|
||||
queue: Queue;
|
||||
}
|
||||
|
||||
interface Spec extends SuiteOrSpec {
|
||||
|
||||
new (env: Env, suite: Suite, description: string): any;
|
||||
|
||||
suite: Suite;
|
||||
|
||||
afterCallbacks: SpecFunction[];
|
||||
spies_: Spy[];
|
||||
|
||||
results_: NestedResults;
|
||||
matchersClass: Matchers;
|
||||
|
||||
getFullName(): string;
|
||||
results(): NestedResults;
|
||||
log(arguments: any): any;
|
||||
runs(func: SpecFunction): Spec;
|
||||
addToQueue(block: Block): void;
|
||||
addMatcherResult(result: Result): void;
|
||||
expect(actual: any): any;
|
||||
waits(timeout: number): Spec;
|
||||
waitsFor(latchFunction: SpecFunction, timeoutMessage?: string, timeout?: number): Spec;
|
||||
fail(e?: any): void;
|
||||
getMatchersClass_(): Matchers;
|
||||
addMatchers(matchersPrototype: any): void;
|
||||
finishCallback(): void;
|
||||
finish(onComplete?: () => void): void;
|
||||
after(doAfter: SpecFunction): void;
|
||||
execute(onComplete?: () => void): any;
|
||||
addBeforesAndAftersToQueue(): void;
|
||||
explodes(): void;
|
||||
spyOn(obj: any, methodName: string, ignoreMethodDoesntExist: boolean): Spy;
|
||||
removeAllSpies(): void;
|
||||
}
|
||||
|
||||
interface XSpec {
|
||||
id: number;
|
||||
runs(): void;
|
||||
}
|
||||
|
||||
interface Suite extends SuiteOrSpec {
|
||||
|
||||
new (env: Env, description: string, specDefinitions: () => void, parentSuite: Suite): any;
|
||||
|
||||
parentSuite: Suite;
|
||||
|
||||
getFullName(): string;
|
||||
finish(onComplete?: () => void): void;
|
||||
beforeEach(beforeEachFunction: SpecFunction): void;
|
||||
afterEach(afterEachFunction: SpecFunction): void;
|
||||
results(): NestedResults;
|
||||
add(suiteOrSpec: SuiteOrSpec): void;
|
||||
specs(): Spec[];
|
||||
suites(): Suite[];
|
||||
children(): any[];
|
||||
execute(onComplete?: () => void): void;
|
||||
}
|
||||
|
||||
interface XSuite {
|
||||
execute(): void;
|
||||
}
|
||||
|
||||
interface Spy {
|
||||
(...params: any[]): any;
|
||||
|
||||
identity: string;
|
||||
calls: any[];
|
||||
mostRecentCall: { args: any[]; };
|
||||
argsForCall: any[];
|
||||
wasCalled: boolean;
|
||||
callCount: number;
|
||||
|
||||
andReturn(value: any): Spy;
|
||||
andCallThrough(): Spy;
|
||||
andCallFake(fakeFunc: Function): Spy;
|
||||
}
|
||||
|
||||
interface Util {
|
||||
inherit(childClass: Function, parentClass: Function): any;
|
||||
formatException(e: any): any;
|
||||
htmlEscape(str: string): string;
|
||||
argsToArray(args: any): any;
|
||||
extend(destination: any, source: any): any;
|
||||
}
|
||||
|
||||
interface JsApiReporter extends Reporter {
|
||||
|
||||
started: boolean;
|
||||
finished: boolean;
|
||||
result: any;
|
||||
messages: any;
|
||||
|
||||
new (): any;
|
||||
|
||||
suites(): Suite[];
|
||||
summarize_(suiteOrSpec: SuiteOrSpec): any;
|
||||
results(): any;
|
||||
resultsForSpec(specId: any): any;
|
||||
log(str: any): any;
|
||||
resultsForSpecs(specIds: any): any;
|
||||
summarizeResult_(result: any): any;
|
||||
}
|
||||
|
||||
interface Jasmine {
|
||||
Spec: Spec;
|
||||
Clock: Clock;
|
||||
util: Util;
|
||||
}
|
||||
|
||||
export var HtmlReporter: any;
|
||||
}
|
||||
Reference in New Issue
Block a user