vhad/DefinitelyTyped
1
0
Fork 0
mirror of https://github.com/gosticks/DefinitelyTyped.git synced 2026-06-28 22:30:01 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Add stronger typings to jasmine spys

Browse Source
This commit is contained in:
Moshe Kolodny
2019-03-13 17:49:37 -04:00
parent dfd2efad80
commit 18be7de7bd
6 changed files with 2262 additions and 1 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
types/jasmine-ajax/jasmine-ajax-tests.ts
View File

@@ -462,7 +462,7 @@ describe('FakeRequest', () => {
it('ticks the jasmine clock on timeout', () => {
const clock = { tick: jasmine.createSpy('tick') };
spyOn(jasmine, 'clock').and.returnValue(clock);
spyOn(jasmine, 'clock').and.returnValue(clock as any);
const request = new this.FakeRequest();
request.open();

11
types/jasmine/package.json Normal file
View File

@@ -0,0 +1,11 @@
{
"private": true,
"types": "index",
"typesVersions": {
">=3.1.0-0": {
"*": [
"ts3.1/*"
]
}
}
}

857
types/jasmine/ts3.1/index.d.ts vendored Normal file
View File

@@ -0,0 +1,857 @@
// Definitions by: Boris Yankov <https://github.com/borisyankov>
// Theodore Brown <https://github.com/theodorejb>
// David Pärsson <https://github.com/davidparsson>
// Gabe Moothart <https://github.com/gmoothart>
// Lukas Zech <https://github.com/lukas-zech-software>
// Boris Breuer <https://github.com/Engineer2B>
// Chris Yungmann <https://github.com/cyungmann>
// Giles Roadnight <https://github.com/Roaders>
// Yaroslav Admin <https://github.com/devoto13>
// Domas Trijonis <https://github.com/fdim>
// Peter Safranek <https://github.com/pe8ter>
// Moshe Kolodny <https://github.com/kolodny>
// For ddescribe / iit use : https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/karma-jasmine/karma-jasmine.d.ts
type ImplementationCallback = (() => Promise<any>) | ((done: DoneFn) => void);
type InferableFunction = (...args: any[]) => any;
/**
* Create a group of specs (often called a suite).
* @param description Textual description of the group
* @param specDefinitions Function for Jasmine to invoke that will define inner suites a specs
*/
declare function describe(description: string, specDefinitions: () => void): void;
/**
* A focused `describe`. If suites or specs are focused, only those that are focused will be executed.
* @param description Textual description of the group
* @param specDefinitions Function for Jasmine to invoke that will define inner suites a specs
*/
declare function fdescribe(description: string, specDefinitions: () => void): void;
/**
* A temporarily disabled `describe`. Specs within an xdescribe will be marked pending and not executed.
* @param description Textual description of the group
* @param specDefinitions Function for Jasmine to invoke that will define inner suites a specs
*/
declare function xdescribe(description: string, specDefinitions: () => void): void;
/**
* Define a single spec. A spec should contain one or more expectations that test the state of the code.
* A spec whose expectations all succeed will be passing and a spec with any failures will fail.
* @param expectation Textual description of what this spec is checking
* @param assertion Function that contains the code of your test. If not provided the test will be pending.
* @param timeout Custom timeout for an async spec.
*/
declare function it(expectation: string, assertion?: ImplementationCallback, timeout?: number): void;
/**
* A focused `it`. If suites or specs are focused, only those that are focused will be executed.
* @param expectation Textual description of what this spec is checking
* @param assertion Function that contains the code of your test. If not provided the test will be pending.
* @param timeout Custom timeout for an async spec.
*/
declare function fit(expectation: string, assertion?: ImplementationCallback, timeout?: number): void;
/**
* A temporarily disabled `it`. The spec will report as pending and will not be executed.
* @param expectation Textual description of what this spec is checking
* @param assertion Function that contains the code of your test. If not provided the test will be pending.
* @param timeout Custom timeout for an async spec.
*/
declare function xit(expectation: string, assertion?: ImplementationCallback, timeout?: number): void;
/**
* Mark a spec as pending, expectation results will be ignored.
* If you call the function pending anywhere in the spec body, no matter the expectations, the spec will be marked pending.
* @param reason Reason the spec is pending.
*/
declare function pending(reason?: string): void;
/**
* Run some shared setup before each of the specs in the describe in which it is called.
* @param action Function that contains the code to setup your specs.
* @param timeout Custom timeout for an async beforeEach.
*/
declare function beforeEach(action: ImplementationCallback, timeout?: number): void;
/**
* Run some shared teardown after each of the specs in the describe in which it is called.
* @param action Function that contains the code to teardown your specs.
* @param timeout Custom timeout for an async afterEach.
*/
declare function afterEach(action: ImplementationCallback, timeout?: number): void;
/**
* Run some shared setup once before all of the specs in the describe are run.
* Note: Be careful, sharing the setup from a beforeAll makes it easy to accidentally leak state between your specs so that they erroneously pass or fail.
* @param action Function that contains the code to setup your specs.
* @param timeout Custom timeout for an async beforeAll.
*/
declare function beforeAll(action: ImplementationCallback, timeout?: number): void;
/**
* Run some shared teardown once before all of the specs in the describe are run.
* Note: Be careful, sharing the teardown from a afterAll makes it easy to accidentally leak state between your specs so that they erroneously pass or fail.
* @param action Function that contains the code to teardown your specs.
* @param timeout Custom timeout for an async afterAll
*/
declare function afterAll(action: ImplementationCallback, timeout?: number): void;
/**
* Create an expectation for a spec.
* @checkReturnValue see https://tsetse.info/check-return-value
* @param spy
*/
declare function expect(spy: Function): jasmine.Matchers<any>;
/**
* Create an expectation for a spec.
* @checkReturnValue see https://tsetse.info/check-return-value
* @param actual
*/
declare function expect<T>(actual: ArrayLike<T>): jasmine.ArrayLikeMatchers<T>;
/**
* Create an expectation for a spec.
* @checkReturnValue see https://tsetse.info/check-return-value
* @param actual Actual computed value to test expectations against.
*/
declare function expect<T>(actual: T): jasmine.Matchers<T>;
/**
* Create an expectation for a spec.
*/
declare function expect(): jasmine.NothingMatcher;
/**
* Create an asynchronous expectation for a spec. Note that the matchers
* that are provided by an asynchronous expectation all return promises
* which must be either returned from the spec or waited for using `await`
* in order for Jasmine to associate them with the correct spec.
* @checkReturnValue see https://tsetse.info/check-return-value
* @param actual - Actual computed value to test expectations against.
*/
declare function expectAsync<T, U>(actual: Promise<T>): jasmine.AsyncMatchers<T, U>;
/**
* Explicitly mark a spec as failed.
* @param e Reason for the failure
*/
declare function fail(e?: any): void;
/**
* Action method that should be called when the async work is complete.
*/
interface DoneFn extends Function {
(): void;
/** fails the spec and indicates that it has completed. If the message is an Error, Error.message is used */
fail: (message?: Error | string) => void;
}
type Methods<T> = {
[K in {
[K in keyof T]: T[K] extends Function ? K : never
}[keyof T]]: T[K]
};
/**
* Install a spy onto an existing object.
* @param object The object upon which to install the `Spy`.
* @param method The name of the method to replace with a `Spy`.
*/
declare function spyOn<T, K extends keyof T = keyof T>(
object: T, method: T[K] extends InferableFunction ? K : never,
): jasmine.Spy<T[K] extends InferableFunction ? T[K] : never>;
/**
* Install a spy on a property installed with `Object.defineProperty` onto an existing object.
* @param object The object upon which to install the `Spy`.
* @param property The name of the property to replace with a `Spy`.
* @param accessType The access type (get|set) of the property to `Spy` on.
*/
declare function spyOnProperty<T>(object: T, property: keyof T, accessType?: 'get' | 'set'): jasmine.Spy;
/**
* Installs spies on all writable and configurable properties of an object.
* @param object The object upon which to install the `Spy`s.
*/
declare function spyOnAllFunctions(object: object): 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 namespace jasmine {
type Expected<T> = T | ObjectContaining<T> | Any | Spy;
type SpyObjMethodNames<T = undefined> =
T extends undefined ?
(ReadonlyArray<string> | {[methodName: string]: any}) :
(ReadonlyArray<keyof T> | {[P in keyof T]?: ReturnType<T[P] extends InferableFunction ? T[P] : any>});
function clock(): Clock;
var matchersUtil: MatchersUtil;
function any(aclass: any): Any;
function anything(): Any;
function arrayContaining<T>(sample: ArrayLike<T>): ArrayContaining<T>;
function arrayWithExactContents<T>(sample: ArrayLike<T>): ArrayContaining<T>;
function objectContaining<T>(sample: Partial<T>): ObjectContaining<T>;
function createSpy<Fun extends InferableFunction>(name?: string, originalFn?: Fun): Spy<Fun>;
function createSpyObj(baseName: string, methodNames: SpyObjMethodNames): any;
function createSpyObj<T>(baseName: string, methodNames: SpyObjMethodNames<T>): SpyObj<T>;
function createSpyObj(methodNames: SpyObjMethodNames): any;
function createSpyObj<T>(methodNames: SpyObjMethodNames): SpyObj<T>;
function pp(value: any): string;
function getEnv(): Env;
function addCustomEqualityTester(equalityTester: CustomEqualityTester): void;
function addMatchers(matchers: CustomMatcherFactories): void;
function stringMatching(str: string | RegExp): Any;
function formatErrorMsg(domain: string, usage: string): (msg: string) => string;
interface Any {
(...params: any[]): any; // jasmine.Any can also be a function
new (expectedClass: any): any;
jasmineMatches(other: any): boolean;
jasmineToString(): string;
}
// taken from TypeScript lib.core.es6.d.ts, applicable to CustomMatchers.contains()
interface ArrayLike<T> {
length: number;
[n: number]: T;
}
interface ArrayContaining<T> {
new (sample: ArrayLike<T>): ArrayLike<T>;
asymmetricMatch(other: any): boolean;
jasmineToString(): string;
}
interface ObjectContaining<T> {
new (sample: Partial<T>): Partial<T>;
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 {
install(): void;
uninstall(): void;
/** Calls to any registered callback are triggered when the clock is ticked forward via the jasmine.clock().tick function, which takes a number of milliseconds. */
tick(ms: number): void;
mockDate(date?: Date): void;
withMock(func: () => void): void;
}
type CustomEqualityTester = (first: any, second: any) => boolean | void;
interface CustomMatcher {
compare<T>(actual: T, expected: T, ...args: any[]): CustomMatcherResult;
compare(actual: any, ...expected: any[]): CustomMatcherResult;
negativeCompare?<T>(actual: T, expected: T, ...args: any[]): CustomMatcherResult;
negativeCompare?(actual: any, ...expected: any[]): CustomMatcherResult;
}
type CustomMatcherFactory = (util: MatchersUtil, customEqualityTesters: CustomEqualityTester[]) => CustomMatcher;
interface CustomMatcherFactories {
[index: string]: CustomMatcherFactory;
}
interface CustomMatcherResult {
pass: boolean;
message?: string;
}
interface MatchersUtil {
equals(a: any, b: any, customTesters?: CustomEqualityTester[]): boolean;
contains<T>(haystack: ArrayLike<T> | string, needle: any, customTesters?: CustomEqualityTester[]): boolean;
buildFailureMessage(matcherName: string, isNot: boolean, actual: any, ...expected: any[]): string;
}
interface Env {
currentSpec: Spec;
matchersClass: Matchers<any>;
version(): any;
versionString(): string;
nextSpecId(): number;
addReporter(reporter: Reporter | CustomReporter): void;
execute(): void;
describe(description: string, specDefinitions: () => void): Suite;
// ddescribe(description: string, specDefinitions: () => void): Suite; Not a part of jasmine. Angular team adds these
beforeEach(beforeEachFunction: ImplementationCallback, timeout?: number): void;
beforeAll(beforeAllFunction: ImplementationCallback, timeout?: number): void;
currentRunner(): Runner;
afterEach(afterEachFunction: ImplementationCallback, timeout?: number): void;
afterAll(afterAllFunction: ImplementationCallback, timeout?: number): void;
xdescribe(desc: string, specDefinitions: () => void): XSuite;
it(description: string, func: () => void): Spec;
// iit(description: string, func: () => void): Spec; Not a part of jasmine. Angular team adds these
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;
addCustomEqualityTester(equalityTester: CustomEqualityTester): void;
addMatchers(matchers: CustomMatcherFactories): void;
specFilter(spec: Spec): boolean;
throwOnExpectationFailure(value: boolean): void;
seed(seed: string | number): string | number;
provideFallbackReporter(reporter: Reporter): void;
throwingExpectationFailures(): boolean;
allowRespy(allow: boolean): void;
randomTests(): boolean;
randomizeTests(b: boolean): void;
clearReporters(): void;
}
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 HtmlSpecFilter {
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 Order {
new (options: { random: boolean, seed: string }): any;
random: boolean;
seed: string;
sort<T>(items: T[]): T[];
}
namespace errors {
class ExpectationFailed extends Error {
constructor();
stack: any;
}
}
interface TreeProcessor {
new (attrs: any): any;
execute: (done: Function) => void;
processTree(): any;
}
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<T> {
new (env: Env, actual: T, spec: Env, isNot?: boolean): any;
env: Env;
actual: T;
spec: Env;
isNot?: boolean;
message(): any;
/**
*
* @param expected the actual value to be === to the expected value.
* @param expectationFailOutput
*/
toBe(expected: Expected<T>, expectationFailOutput?: any): boolean;
/**
*
* @param expected the actual value to be equal to the expected, using deep equality comparison.
* @param expectationFailOutput
*/
toEqual(expected: Expected<T>, expectationFailOutput?: any): boolean;
toMatch(expected: string | RegExp, expectationFailOutput?: any): boolean;
toBeDefined(expectationFailOutput?: any): boolean;
toBeUndefined(expectationFailOutput?: any): boolean;
toBeNull(expectationFailOutput?: any): boolean;
toBeNaN(): boolean;
toBeTruthy(expectationFailOutput?: any): boolean;
toBeFalsy(expectationFailOutput?: any): boolean;
toHaveBeenCalled(): boolean;
toHaveBeenCalledBefore(expected: Spy): boolean;
toHaveBeenCalledWith(...params: any[]): boolean;
toHaveBeenCalledTimes(expected: number): boolean;
toContain(expected: any, expectationFailOutput?: any): boolean;
toBeLessThan(expected: number, expectationFailOutput?: any): boolean;
toBeLessThanOrEqual(expected: number, expectationFailOutput?: any): boolean;
toBeGreaterThan(expected: number, expectationFailOutput?: any): boolean;
toBeGreaterThanOrEqual(expected: number, expectationFailOutput?: any): boolean;
toBeCloseTo(expected: number, precision?: any, expectationFailOutput?: any): boolean;
toThrow(expected?: any): boolean;
toThrowError(message?: string | RegExp): boolean;
toThrowError(expected?: new (...args: any[]) => Error, message?: string | RegExp): boolean;
toThrowMatching(predicate: (thrown: any) => boolean): boolean;
toBeNegativeInfinity(expectationFailOutput?: any): boolean;
toBePositiveInfinity(expectationFailOutput?: any): boolean;
toHaveClass(expected: any, expectationFailOutput?: any): boolean;
/**
* Add some context for an expect.
* @param message - Additional context to show when the matcher fails
*/
withContext(message: string): Matchers<T>;
not: Matchers<T>;
Any: Any;
}
interface ArrayLikeMatchers<T> extends Matchers<ArrayLike<T>> {
toBe(expected: Expected<ArrayLike<T>> | ArrayContaining<T>, expectationFailOutput?: any): boolean;
toEqual(expected: Expected<ArrayLike<T>> | ArrayContaining<T>, expectationFailOutput?: any): boolean;
toContain(expected: Expected<T>, expectationFailOutput?: any): boolean;
not: ArrayLikeMatchers<T>;
}
interface NothingMatcher {
nothing(): void;
}
interface AsyncMatchers<T, U> {
/**
* Expect a promise to be resolved.
* @param expectationFailOutput
*/
toBeResolved(expectationFailOutput?: any): Promise<void>;
/**
* Expect a promise to be rejected.
* @param expectationFailOutput
*/
toBeRejected(expectationFailOutput?: any): Promise<void>;
/**
* Expect a promise to be resolved to a value equal to the expected, using deep equality comparison.
* @param expected - Value that the promise is expected to resolve to.
*/
toBeResolvedTo(expected: Expected<T>): Promise<void>;
/**
* Expect a promise to be rejected with a value equal to the expected, using deep equality comparison.
* @param expected - Value that the promise is expected to be rejected with.
*/
toBeRejectedWith(expected: Expected<U>): Promise<void>;
/**
* Add some context for an expect.
* @param message - Additional context to show when the matcher fails.
*/
withContext(message: string): AsyncMatchers<T, U>;
/**
* Invert the matcher following this expect.
*/
not: AsyncMatchers<T, U>;
}
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 SuiteInfo {
totalSpecsDefined: number;
}
interface CustomReportExpectation {
matcherName: string;
message: string;
passed: boolean;
stack: string;
}
interface FailedExpectation extends CustomReportExpectation {
actual: string;
expected: string;
}
interface PassedExpectation extends CustomReportExpectation {
}
interface CustomReporterResult {
description: string;
failedExpectations?: FailedExpectation[];
fullName: string;
id: string;
passedExpectations?: PassedExpectation[];
pendingReason?: string;
status?: string;
}
interface RunDetails {
failedExpectations: ExpectationResult[];
order: Order;
}
interface CustomReporter {
jasmineStarted?(suiteInfo: SuiteInfo): void;
suiteStarted?(result: CustomReporterResult): void;
specStarted?(result: CustomReporterResult): void;
specDone?(result: CustomReporterResult): void;
suiteDone?(result: CustomReporterResult): void;
jasmineDone?(runDetails: RunDetails): void;
}
interface Runner {
new (env: Env): any;
execute(): void;
beforeEach(beforeEachFunction: SpecFunction): void;
afterEach(afterEachFunction: SpecFunction): void;
beforeAll(beforeAllFunction: SpecFunction): void;
afterAll(afterAllFunction: SpecFunction): void;
finishCallback(): void;
addSuite(suite: Suite): void;
add(block: Block): void;
specs(): Spec[];
suites(): Suite[];
topLevelSuites(): Suite[];
results(): NestedResults;
}
type 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<any>;
getFullName(): string;
results(): NestedResults;
log(arguments: any): any;
runs(func: SpecFunction): Spec;
addToQueue(block: Block): void;
addMatcherResult(result: Result): void;
getResult(): any;
expect(actual: any): any;
waits(timeout: number): Spec;
waitsFor(latchFunction: SpecFunction, timeoutMessage?: string, timeout?: number): Spec;
fail(e?: any): void;
getMatchersClass_(): Matchers<any>;
addMatchers(matchersPrototype: CustomMatcherFactories): void;
finishCallback(): void;
finish(onComplete?: () => void): void;
after(doAfter: SpecFunction): void;
execute(onComplete?: () => void, enabled?: boolean): any;
addBeforesAndAftersToQueue(): void;
explodes(): void;
spyOn(obj: any, methodName: string, ignoreMethodDoesntExist: boolean): Spy;
spyOnProperty(object: any, property: string, accessType?: 'get' | 'set'): Spy;
spyOnAllFunctions(object: any): Spy;
removeAllSpies(): void;
throwOnExpectationFailure: boolean;
}
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;
beforeAll(beforeAllFunction: SpecFunction): void;
afterAll(afterAllFunction: SpecFunction): void;
results(): NestedResults;
add(suiteOrSpec: SuiteOrSpec): void;
specs(): Spec[];
suites(): Suite[];
children(): any[];
execute(onComplete?: () => void): void;
}
interface XSuite {
execute(): void;
}
interface Spy<Fn extends InferableFunction = InferableFunction> {
(...params: any[]): any;
and: SpyAnd<Fn>;
calls: Calls<Fn>;
withArgs(...args: any[]): Spy<Fn>;
}
type SpyObj<T> = T & {
[k in keyof T]: T[k] extends InferableFunction ? T[k] & Spy<T[k]> : T[k];
};
interface SpyAnd<Fun extends InferableFunction> {
identity: string;
/** By chaining the spy with and.callThrough, the spy will still track all calls to it but in addition it will delegate to the actual implementation. */
callThrough(): Spy<Fun>;
/** By chaining the spy with and.returnValue, all calls to the function will return a specific value. */
returnValue(val: ReturnType<Fun>): Spy<Fun>;
/** By chaining the spy with and.returnValues, all calls to the function will return specific values in order until it reaches the end of the return values list. */
returnValues(...values: Array<ReturnType<Fun>>): Spy<Fun>;
/** By chaining the spy with and.callFake, all calls to the spy will delegate to the supplied function. */
callFake(fn: Fun): Spy<Fun>;
/** By chaining the spy with and.throwError, all calls to the spy will throw the specified value. */
throwError(msg: string): Spy;
/** When a calling strategy is used for a spy, the original stubbing behavior can be returned at any time with and.stub. */
stub(): Spy;
}
interface Calls<Fun extends InferableFunction> {
/** By chaining the spy with calls.any(), will return false if the spy has not been called at all, and then true once at least one call happens. */
any(): boolean;
/** By chaining the spy with calls.count(), will return the number of times the spy was called */
count(): number;
/** By chaining the spy with calls.argsFor(), will return the arguments passed to call number index */
argsFor(index: number): Parameters<Fun>;
/** By chaining the spy with calls.allArgs(), will return the arguments to all calls */
allArgs(): Array<Parameters<Fun>>;
/** By chaining the spy with calls.all(), will return the context (the this) and arguments passed all calls */
all(): Array<CallInfo<Fun>>;
/** By chaining the spy with calls.mostRecent(), will return the context (the this) and arguments for the most recent call */
mostRecent(): CallInfo<Fun>;
/** By chaining the spy with calls.first(), will return the context (the this) and arguments for the first call */
first(): CallInfo<Fun>;
/** By chaining the spy with calls.reset(), will clears all tracking for a spy */
reset(): void;
}
interface CallInfo<Fun extends InferableFunction> {
/** The context (the this) for the call */
object: any;
/** All arguments passed to the call */
args: Parameters<Fun>;
/** The return value of the call */
returnValue: ReturnType<Fun>;
}
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;
runDetails: RunDetails;
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;
}
var HtmlReporter: HtmlReporter;
var HtmlSpecFilter: HtmlSpecFilter;
/**
* Default number of milliseconds Jasmine will wait for an asynchronous spec to complete.
*/
var DEFAULT_TIMEOUT_INTERVAL: number;
/**
* Maximum number of array elements to display when pretty printing objects.
* This will also limit the number of keys and values displayed for an object.
* Elements past this number will be ellipised.
*/
var MAX_PRETTY_PRINT_ARRAY_LENGTH: number;
/**
* Maximum number of charasters to display when pretty printing objects.
* Characters past this number will be ellipised.
*/
var MAX_PRETTY_PRINT_CHARS: number;
/**
* Maximum object depth the pretty printer will print to.
* Set this to a lower value to speed up pretty printing if you have large objects.
*/
var MAX_PRETTY_PRINT_DEPTH: number;
}
declare module "jasmine" {
class jasmine {
constructor(options: any);
jasmine: jasmine.Jasmine;
addMatchers(matchers: jasmine.CustomMatcherFactories): void;
addReporter(reporter: jasmine.Reporter): void;
addSpecFile(filePath: string): void;
addSpecFiles(files: string[]): void;
configureDefaultReporter(options: any, ...args: any[]): void;
execute(files?: string[], filterString?: string): any;
exitCodeCompletion(passed: any): void;
loadConfig(config: any): void;
loadConfigFile(configFilePath: any): void;
loadHelpers(): void;
loadSpecs(): void;
onComplete(onCompleteCallback: (passed: boolean) => void): void;
provideFallbackReporter(reporter: jasmine.Reporter): void;
randomizeTests(value?: any): boolean;
seed(value: any): void;
showColors(value: any): void;
stopSpecOnExpectationFailure(value: any): void;
static ConsoleReporter(): any;
env: jasmine.Env;
reportersCount: number;
completionReporter: jasmine.CustomReporter;
reporter: jasmine.CustomReporter;
coreVersion(): string;
showingColors: boolean;
projectBaseDir: string;
printDeprecation(): void;
specFiles: string[];
helperFiles: string[];
}
export = jasmine;
}

1358
types/jasmine/ts3.1/jasmine-tests.ts Normal file
View File

File diff suppressed because it is too large Load Diff

22
types/jasmine/ts3.1/tsconfig.json Normal file
View File

@@ -0,0 +1,22 @@
{
"files": [
"index.d.ts",
"jasmine-tests.ts"
],
"compilerOptions": {
"module": "commonjs",
"lib": [
"es6",
"dom"
],
"noImplicitAny": true,
"noImplicitThis": true,
"strictNullChecks": true,
"strictFunctionTypes": false,
"baseUrl": "../../",
"typeRoots": ["../../"],
"types": [],
"noEmit": true,
"forceConsistentCasingInFileNames": true
}
}

13
types/jasmine/ts3.1/tslint.json Normal file
View File

@@ -0,0 +1,13 @@
{
"extends": "dtslint/dt.json",
"rules": {
"ban-types": false,
"no-declare-current-package": false,
"no-empty-interface": false,
"no-single-declare-module": false,
"no-unnecessary-generics": false,
"no-var-keyword": false,
"one-variable-per-declaration": false,
"only-arrow-functions": false
}
}