From fac528820a127590f75bfbde3344d82dfc1b17db Mon Sep 17 00:00:00 2001 From: Peter Safranek Date: Sun, 18 Nov 2018 17:14:58 -0800 Subject: [PATCH] [jasmine] Introduce major version 3 (#30366) * [jasmine] Introduce major version 3 * Remove patch version number * Convert type assertion from "angle bracket" to "as" style --- types/jasmine-ajax/jasmine-ajax-tests.ts | 4 +- types/jasmine/index.d.ts | 4 +- types/jasmine/jasmine-tests.ts | 5 +- types/jasmine/tsconfig.json | 4 +- types/jasmine/tslint.json | 3 +- types/jasmine/v1/index.d.ts | 5 +- types/jasmine/v1/tslint.json | 3 +- types/jasmine/v2/index.d.ts | 753 ++++++++++++++ types/jasmine/v2/jasmine-tests.ts | 1182 ++++++++++++++++++++++ types/jasmine/v2/tsconfig.json | 27 + types/jasmine/v2/tslint.json | 80 ++ 11 files changed, 2057 insertions(+), 13 deletions(-) create mode 100644 types/jasmine/v2/index.d.ts create mode 100644 types/jasmine/v2/jasmine-tests.ts create mode 100644 types/jasmine/v2/tsconfig.json create mode 100644 types/jasmine/v2/tslint.json diff --git a/types/jasmine-ajax/jasmine-ajax-tests.ts b/types/jasmine-ajax/jasmine-ajax-tests.ts index 6e783f3eda..da68ad92a0 100644 --- a/types/jasmine-ajax/jasmine-ajax-tests.ts +++ b/types/jasmine-ajax/jasmine-ajax-tests.ts @@ -1796,7 +1796,7 @@ describe("mockAjax", () => { const mockAjax = new MockAjax(fakeGlobal); mockAjax.install(); - const request = new ( fakeGlobal.XMLHttpRequest)(); + const request = new (fakeGlobal.XMLHttpRequest as any)(); expect(mockAjax.requests.count()).toBe(1); expect(mockAjax.requests.mostRecent()).toBe(request); @@ -1808,7 +1808,7 @@ describe("mockAjax", () => { const mockAjax = new MockAjax(fakeGlobal); mockAjax.install(); - const request = new ( fakeGlobal.XMLHttpRequest)(); + const request = new (fakeGlobal.XMLHttpRequest as any)(); expect(mockAjax.requests.mostRecent()).toBe(request); mockAjax.requests.reset(); diff --git a/types/jasmine/index.d.ts b/types/jasmine/index.d.ts index f7bfdd470c..e9dba1e2cd 100644 --- a/types/jasmine/index.d.ts +++ b/types/jasmine/index.d.ts @@ -1,5 +1,5 @@ -// Type definitions for Jasmine 3.0.0 -// Project: http://jasmine.github.io/ +// Type definitions for Jasmine 3.3 +// Project: https://jasmine.github.io/ // Definitions by: Boris Yankov // Theodore Brown // David Pärsson diff --git a/types/jasmine/jasmine-tests.ts b/types/jasmine/jasmine-tests.ts index 8568e97f38..ba8763ce3d 100644 --- a/types/jasmine/jasmine-tests.ts +++ b/types/jasmine/jasmine-tests.ts @@ -491,6 +491,7 @@ describe("A spy, when configured to throw a value", () => { describe("A spy, when configured with multiple actions", () => { var foo: any, bar: any, fetchedBar: any; + var fakeCalled = false; beforeEach(() => { foo = { @@ -503,7 +504,7 @@ describe("A spy, when configured with multiple actions", () => { }; spyOn(foo, 'getBar').and.callThrough().and.callFake(() => { - this.fakeCalled = true; + fakeCalled = true; }); foo.setBar(123); @@ -523,7 +524,7 @@ describe("A spy, when configured with multiple actions", () => { }); it("should have called the fake implementation", () => { - expect(this.fakeCalled).toEqual(true); + expect(fakeCalled).toEqual(true); }); }); diff --git a/types/jasmine/tsconfig.json b/types/jasmine/tsconfig.json index 0f9f9d3fbe..0c03c98874 100644 --- a/types/jasmine/tsconfig.json +++ b/types/jasmine/tsconfig.json @@ -10,7 +10,7 @@ "dom" ], "noImplicitAny": true, - "noImplicitThis": false, + "noImplicitThis": true, "strictNullChecks": true, "strictFunctionTypes": false, "baseUrl": "../", @@ -21,4 +21,4 @@ "noEmit": true, "forceConsistentCasingInFileNames": true } -} \ No newline at end of file +} diff --git a/types/jasmine/tslint.json b/types/jasmine/tslint.json index a41bf5d19a..2daeb51ad8 100644 --- a/types/jasmine/tslint.json +++ b/types/jasmine/tslint.json @@ -7,9 +7,10 @@ "ban-types": false, "callable-types": false, "comment-format": false, - "dt-header": false, + "dt-header": true, "eofline": false, "export-just-namespace": false, + "file-name-casing": [true, "kebab-case"], "import-spacing": false, "interface-name": false, "interface-over-type-literal": false, diff --git a/types/jasmine/v1/index.d.ts b/types/jasmine/v1/index.d.ts index 3f51240f63..08fa8cf727 100644 --- a/types/jasmine/v1/index.d.ts +++ b/types/jasmine/v1/index.d.ts @@ -1,9 +1,8 @@ // Type definitions for Jasmine 1.3 -// Project: http://pivotal.github.com/jasmine/ -// Definitions by: Boris Yankov +// Project: https://jasmine.github.io/ +// Definitions by: Boris Yankov // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped - declare function describe(description: string, specDefinitions: () => void): void; // declare function ddescribe(description: string, specDefinitions: () => void): void; is not a part of jasmine. It is something angular adds declare function xdescribe(description: string, specDefinitions: () => void): void; diff --git a/types/jasmine/v1/tslint.json b/types/jasmine/v1/tslint.json index a41bf5d19a..2daeb51ad8 100644 --- a/types/jasmine/v1/tslint.json +++ b/types/jasmine/v1/tslint.json @@ -7,9 +7,10 @@ "ban-types": false, "callable-types": false, "comment-format": false, - "dt-header": false, + "dt-header": true, "eofline": false, "export-just-namespace": false, + "file-name-casing": [true, "kebab-case"], "import-spacing": false, "interface-name": false, "interface-over-type-literal": false, diff --git a/types/jasmine/v2/index.d.ts b/types/jasmine/v2/index.d.ts new file mode 100644 index 0000000000..40491f6875 --- /dev/null +++ b/types/jasmine/v2/index.d.ts @@ -0,0 +1,753 @@ +// Type definitions for Jasmine 2.8 +// Project: https://jasmine.github.io/ +// Definitions by: Boris Yankov +// Theodore Brown +// David Pärsson +// Gabe Moothart +// Lukas Zech +// Boris Breuer +// Chris Yungmann +// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped +// TypeScript Version: 2.8 +// For ddescribe / iit use : https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/karma-jasmine/karma-jasmine.d.ts + +/** + * 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; +declare function fdescribe(description: string, specDefinitions: () => void): void; +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?: (done: DoneFn) => void, timeout?: number): void; + +/** + * A focused it + * If suites or specs are focused, only those that are focused will be executed. + * @param expectation + * @param assertion + * @param timeout + */ +declare function fit(expectation: string, assertion?: (done: DoneFn) => void, timeout?: number): void; +declare function xit(expectation: string, assertion?: (done: DoneFn) => void, 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 + * @returns {} + */ +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: (done: DoneFn) => void, 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: (done: DoneFn) => void, 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: (done: DoneFn) => void, 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: (done: DoneFn) => void, timeout?: number): void; + +/** + * Create an expectation for a spec. + * @param spy + */ +declare function expect(spy: Function): jasmine.Matchers; + +/** + * Create an expectation for a spec. + * @param actual + */ +declare function expect(actual: ArrayLike): jasmine.ArrayLikeMatchers; + +/** + * Create an expectation for a spec. + * @param actual Actual computed value to test expectations against. + */ +declare function expect(actual: T): jasmine.Matchers; + +/** + * Create an expectation for a spec. + */ +declare function expect(): jasmine.NothingMatcher; + +/** + * Explicitly mark a spec as failed. + * @param e + */ +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; +} + +/** + * 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(object: T, method: keyof T): jasmine.Spy; + +/** + * Install a spy on a property 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(object: T, property: keyof T, accessType?: 'get' | 'set'): 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 | ObjectContaining | Any | Spy; + type SpyObjMethodNames = T extends undefined ? (ReadonlyArray | {[methodName: string]: any}) : (ReadonlyArray | {[P in keyof T]?: ReturnType any ? T[P] : any>}); + + var clock: () => Clock; + + var matchersUtil: MatchersUtil; + + function any(aclass: any): Any; + + function anything(): Any; + + function arrayContaining(sample: ArrayLike): ArrayContaining; + function arrayWithExactContents(sample: ArrayLike): ArrayContaining; + function objectContaining(sample: Partial): ObjectContaining; + function createSpy(name?: string, originalFn?: Function): Spy; + + function createSpyObj(baseName: string, methodNames: SpyObjMethodNames): any; + function createSpyObj(baseName: string, methodNames: SpyObjMethodNames): SpyObj; + + function createSpyObj(methodNames: SpyObjMethodNames): any; + function createSpyObj(methodNames: SpyObjMethodNames): SpyObj; + + function pp(value: any): string; + + function getEnv(): Env; + + function addCustomEqualityTester(equalityTester: CustomEqualityTester): void; + + function addMatchers(matchers: CustomMatcherFactories): void; + + function stringMatching(str: string): Any; + function stringMatching(str: 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 { + length: number; + [n: number]: T; + } + + interface ArrayContaining { + new (sample: ArrayLike): ArrayLike; + + asymmetricMatch(other: any): boolean; + jasmineToString(): string; + } + + interface ObjectContaining { + new (sample: Partial): Partial; + + 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(actual: T, expected: T, ...args: any[]): CustomMatcherResult; + compare(actual: any, ...expected: any[]): CustomMatcherResult; + negativeCompare?(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(haystack: ArrayLike | string, needle: any, customTesters?: CustomEqualityTester[]): boolean; + buildFailureMessage(matcherName: string, isNot: boolean, actual: any, ...expected: any[]): string; + } + + 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; + addReporter(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: (done: DoneFn) => void, timeout?: number): void; + beforeAll(beforeAllFunction: (done: DoneFn) => void, timeout?: number): void; + currentRunner(): Runner; + afterEach(afterEachFunction: (done: DoneFn) => void, timeout?: number): void; + afterAll(afterAllFunction: (done: DoneFn) => void, 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(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 { + + 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 + * @returns {} + */ + toBe(expected: Expected, expectationFailOutput?: any): boolean; + + /** + * + * @param expected the actual value to be equal to the expected, using deep equality comparison. + * @param expectationFailOutput + * @returns {} + */ + toEqual(expected: Expected, 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; + + not: Matchers; + + Any: Any; + } + + interface ArrayLikeMatchers extends Matchers> { + toBe(expected: Expected> | ArrayContaining, expectationFailOutput?: any): boolean; + toEqual(expected: Expected> | ArrayContaining, expectationFailOutput?: any): boolean; + toContain(expected: Expected, expectationFailOutput?: any): boolean; + not: ArrayLikeMatchers; + } + + interface NothingMatcher { + nothing(): void; + } + + 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: jasmine.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; + + 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; + 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; + 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 { + (...params: any[]): any; + + identity: string; + and: SpyAnd; + calls: Calls; + mostRecentCall: { args: any[]; }; + argsForCall: any[]; + } + + type SpyObj = T & { + [k in keyof T]: Spy; + } + + interface SpyAnd { + /** 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; + /** By chaining the spy with and.returnValue, all calls to the function will return a specific value. */ + returnValue(val: any): Spy; + /** 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: any[]): Spy; + /** By chaining the spy with and.callFake, all calls to the spy will delegate to the supplied function. */ + callFake(fn: Function): Spy; + /** 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 { + /** 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): any[]; + /** By chaining the spy with calls.allArgs(), will return the arguments to all calls **/ + allArgs(): any[]; + /** By chaining the spy with calls.all(), will return the context (the this) and arguments passed all calls **/ + all(): CallInfo[]; + /** By chaining the spy with calls.mostRecent(), will return the context (the this) and arguments for the most recent call **/ + mostRecent(): CallInfo; + /** By chaining the spy with calls.first(), will return the context (the this) and arguments for the first call **/ + first(): CallInfo; + /** By chaining the spy with calls.reset(), will clears all tracking for a spy **/ + reset(): void; + } + + interface CallInfo { + /** The context (the this) for the call */ + object: any; + /** All arguments passed to the call */ + args: any[]; + /** The return value of the call */ + returnValue: any; + } + + 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; + } + + export var HtmlReporter: HtmlReporter; + export var HtmlSpecFilter: HtmlSpecFilter; + export var DEFAULT_TIMEOUT_INTERVAL: number; + export 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; +} diff --git a/types/jasmine/v2/jasmine-tests.ts b/types/jasmine/v2/jasmine-tests.ts new file mode 100644 index 0000000000..cef611ee17 --- /dev/null +++ b/types/jasmine/v2/jasmine-tests.ts @@ -0,0 +1,1182 @@ +// tests based on http://jasmine.github.io/2.2/introduction.html + +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(24); + }); + + 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("should work for optional values", () => { + var opt: string | undefined = "s"; + expect(opt as (string | undefined)).toEqual(undefined); + }); + }); + + 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((a as any).bar).not.toBeDefined(); + }); + + it("The `toBeUndefined` matcher compares against `undefined`", () => { + var a = { + foo: "foo" + }; + + expect(a.foo).not.toBeUndefined(); + expect((a as any).bar).toBeUndefined(); + }); + + it("The 'toBeNull' matcher compares against null", () => { + var a: string | null = 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 | undefined, foo = "foo"; + + expect(foo).toBeTruthy(); + expect(a).not.toBeTruthy(); + }); + + it("The 'toBeFalsy' matcher is for boolean casting testing", () => { + var a: string | undefined, 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('foo'); + expect(a).not.toContain("quux"); + }); + + it("The 'toContain' matcher is also for finding an object containing distinct properties in an Array", () => { + var a = [{ a: "foo" }, { a: "bar" }, { b: "baz" }]; + + expect(a).toContain(jasmine.objectContaining({ a: "foo" })); + expect(a).not.toContain({ a: "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, 2); + 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 = () => { + var a: any; + return a + 1; + }; + + expect(foo).not.toThrow(); + expect(bar).toThrow(); + }); + + it("The 'toThrowError' matcher is for testing a specific thrown exception", () => { + var foo = () => { + throw new TypeError("foo bar baz"); + }; + + expect(foo).toThrowError("foo bar baz"); + expect(foo).toThrowError(/bar/); + expect(foo).toThrowError(TypeError); + expect(foo).toThrowError(TypeError, "foo bar baz"); + }); +}); + +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; + }); + + it("is just a function, so it can contain any code", () => { + expect(foo).toEqual(1); + }); +}); + +describe("Pending specs", () => { + + xit("can be declared 'xit'", () => { + expect(true).toBe(false); + }); + + it("can be declared with 'it' but without a function"); + + it("can be declared by calling 'pending' in the spec body", () => { + expect(true).toBe(false); + pending(); // without reason + pending('this is why it is pending'); + }); +}); + +describe("A spy", () => { + var foo: any, bar: any, baz: any = null; + + beforeEach(() => { + foo = { + setBar: (value: any) => { + bar = value; + }, + setBaz: (value: any) => { + baz = value; + } + }; + + spyOn(foo, 'setBar'); + spyOn(foo, 'setBaz'); + + foo.setBar(123); + foo.setBar(456, 'another param'); + foo.setBaz(789); + }); + + it("tracks that the spy was called", () => { + expect(foo.setBar).toHaveBeenCalled(); + }); + + it("tracks all the arguments of its calls", () => { + expect(foo.setBar).toHaveBeenCalledWith(123); + expect(foo.setBar).toHaveBeenCalledWith(456, 'another param'); + }); + + it("tracks the order in which spies were called", () => { + expect(foo.setBar).toHaveBeenCalledBefore(foo.setBaz); + }); + + 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: (value: any) => { + bar = value; + }, + getBar: () => { + return bar; + } + }; + + spyOn(foo, 'getBar').and.callThrough(); + + 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 configured to fake a return value", () => { + var foo: any, bar: any, fetchedBar: any; + + beforeEach(() => { + foo = { + setBar: (value: any) => { + bar = value; + }, + getBar: () => { + return bar; + } + }; + + spyOn(foo, "getBar").and.returnValue(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 configured to fake a series of return values", () => { + var foo: any, bar: any; + + beforeEach(() => { + foo = { + setBar: (value: any) => { + bar = value; + }, + getBar: () => { + return bar; + } + }; + + spyOn(foo, "getBar").and.returnValues("fetched first", "fetched second"); + + foo.setBar(123); + }); + + it("tracks that the spy was called", () => { + foo.getBar(123); + expect(foo.getBar).toHaveBeenCalled(); + }); + + it("should not affect other functions", () => { + expect(bar).toEqual(123); + }); + + it("when called multiple times returns the requested values in order", () => { + expect(foo.getBar()).toEqual("fetched first"); + expect(foo.getBar()).toEqual("fetched second"); + expect(foo.getBar()).toBeUndefined(); + }); +}); + +describe("A spy, when configured with an alternate implementation", () => { + var foo: any, bar: any, fetchedBar: any; + + beforeEach(() => { + foo = { + setBar: (value: any) => { + bar = value; + }, + getBar: () => { + return bar; + } + }; + + spyOn(foo, "getBar").and.callFake(() => { + 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 configured to throw a value", () => { + var foo: any, bar: any; + + beforeEach(() => { + foo = { + setBar: (value: any) => { + bar = value; + } + }; + + spyOn(foo, "setBar").and.throwError("quux"); + }); + + it("throws the value", () => { + expect(() => { + foo.setBar(123); + }).toThrowError("quux"); + }); +}); + +describe("A spy, when configured with multiple actions", () => { + var foo: any, bar: any, fetchedBar: any; + var fakeCalled = false; + + beforeEach(() => { + foo = { + setBar: (value: any) => { + bar = value; + }, + getBar: () => { + return bar; + } + }; + + spyOn(foo, 'getBar').and.callThrough().and.callFake(() => { + fakeCalled = true; + }); + + 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); + }); + + it("should have called the fake implementation", () => { + expect(fakeCalled).toEqual(true); + }); +}); + +describe("A spy", () => { + var foo: any, bar: any = null; + + beforeEach(() => { + foo = { + setBar: (value: any) => { + bar = value; + } + }; + + spyOn(foo, 'setBar').and.callThrough(); + }); + + it("can call through and then stub in the same spec", () => { + foo.setBar(123); + expect(bar).toEqual(123); + + foo.setBar.and.stub(); + bar = null; + + foo.setBar(123); + expect(bar).toBe(null); + }); +}); + +describe("A spy", () => { + var foo: any, bar: any = null; + + beforeEach(() => { + foo = { + setBar: (value: any) => { + bar = value; + } + }; + + spyOn(foo, 'setBar'); + }); + + it("tracks if it was called at all", () => { + expect(foo.setBar.calls.any()).toEqual(false); + + foo.setBar(); + + expect(foo.setBar.calls.any()).toEqual(true); + }); + + it("tracks the number of times it was called", () => { + expect(foo.setBar.calls.count()).toEqual(0); + + foo.setBar(); + foo.setBar(); + + expect(foo.setBar.calls.count()).toEqual(2); + }); + + it("tracks the arguments of each call", () => { + foo.setBar(123); + foo.setBar(456, "baz"); + + expect(foo.setBar.calls.argsFor(0)).toEqual([123]); + expect(foo.setBar.calls.argsFor(1)).toEqual([456, "baz"]); + }); + + it("tracks the arguments of all calls", () => { + foo.setBar(123); + foo.setBar(456, "baz"); + + expect(foo.setBar.calls.allArgs()).toEqual([[123], [456, "baz"]]); + }); + + it("can provide the context and arguments to all calls", () => { + foo.setBar(123); + + expect(foo.setBar.calls.all()).toEqual([{ object: foo, args: [123], returnValue: undefined }]); + }); + + it("has a shortcut to the most recent call", () => { + foo.setBar(123); + foo.setBar(456, "baz"); + + expect(foo.setBar.calls.mostRecent()).toEqual({ object: foo, args: [456, "baz"], returnValue: undefined }); + }); + + it("has a shortcut to the first call", () => { + foo.setBar(123); + foo.setBar(456, "baz"); + + expect(foo.setBar.calls.first()).toEqual({ object: foo, args: [123], returnValue: undefined }); + }); + + it("can be reset", () => { + foo.setBar(123); + foo.setBar(456, "baz"); + + expect(foo.setBar.calls.any()).toBe(true); + + foo.setBar.calls.reset(); + + expect(foo.setBar.calls.any()).toBe(false); + }); +}); + +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.and.identity()).toEqual('whatAmI'); + }); + + it("tracks that the spy was called", () => { + expect(whatAmI).toHaveBeenCalled(); + }); + + it("tracks its number of calls", () => { + expect(whatAmI.calls.count()).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.calls.mostRecent().args[0]).toEqual("I"); + }); +}); + +describe("Multiple spies, when created manually", () => { + var tape: any; + var el: jasmine.SpyObj; + + beforeEach(() => { + tape = jasmine.createSpyObj('tape', ['play', 'pause', 'stop', 'rewind']); + el = jasmine.createSpyObj('Element', ['hasAttribute']); + + el.hasAttribute.and.returnValue(false); + el.hasAttribute("href"); + + 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.nothing", () => { + it("matches any value", () => { + expect().nothing(); + }); +}); + +describe("jasmine.any", () => { + it("matches any value", () => { + expect({}).toEqual(jasmine.any(Object)); + expect(12).toEqual(jasmine.any(Number)); + }); + + it("matches any function", () => { + interface Test { + fn1(): void; + fn2(param1: number): number; + } + + const a: Test = { + fn1: () => { }, + fn2: (param1: number) => { return param1; }, + }; + + const expected: Test = { + fn1: jasmine.any(Function), + fn2: jasmine.any(Function), + }; + + expect(a).toEqual(expected); + }); + + 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("jasmine.objectContaining", () => { + interface fooType { + a: number; + b: number; + bar: string; + } + var foo: fooType; + + beforeEach(() => { + foo = { + a: 1, + b: 2, + bar: "baz" + }; + }); + + it("matches objects with the expect key/value pairs", () => { + // not explictly providing the type on objectContaining only guards against + // missmatching types on know properties + expect(foo).not.toEqual(jasmine.objectContaining({ + a: 37, + foo: 2, // <-- this does not cause an error as the compiler cannot infer the type completely + // b: '123', <-- this would cause an error as `b` defined as number in fooType + })); + + // explictly providing the type on objectContaining makes the guard more precise + // as misspelled properties are detected as well + expect(foo).not.toEqual(jasmine.objectContaining({ + bar: '', + // foo: 1, <-- this would cause an error as `foo` is not defined in fooType + })); + }); + + describe("when used with a spy", () => { + it("is useful for comparing arguments", () => { + var callback = jasmine.createSpy('callback'); + + callback({ + bar: "baz" + }); + + expect(callback).toHaveBeenCalledWith(jasmine.objectContaining({ + bar: "baz" + })); + expect(callback).not.toHaveBeenCalledWith(jasmine.objectContaining({ + c: 37 + })); + }); + }); +}); + +describe("jasmine.arrayContaining", () => { + var foo: Array; + + beforeEach(() => { + foo = [1, 2, 3, 4]; + }); + + it("matches arrays with some of the values", () => { + expect(foo).toEqual(jasmine.arrayContaining([3, 1])); + expect(foo).not.toEqual(jasmine.arrayContaining([6])); + + expect(foo).toBe(jasmine.arrayContaining([3, 1])); + expect(foo).not.toBe(jasmine.arrayContaining([6])); + }); + + describe("when used with a spy", () => { + it("is useful when comparing arguments", () => { + var callback = jasmine.createSpy('callback'); + + callback([1, 2, 3, 4]); + + expect(callback).toHaveBeenCalledWith(jasmine.arrayContaining([4, 2, 3])); + expect(callback).not.toHaveBeenCalledWith(jasmine.arrayContaining([5, 2])); + }); + }); +}); + +describe("jasmine.arrayWithExactContents", () => { + var foo: Array; + + beforeEach(() => { + foo = [1, 2, 3, 4]; + }); + + it("matches arrays with exactly the same values", () => { + expect(foo).toEqual(jasmine.arrayWithExactContents([1, 2, 3, 4])); + expect(foo).not.toEqual(jasmine.arrayWithExactContents([6])); + + expect(foo).toBe(jasmine.arrayWithExactContents([1, 2, 3, 4])); + expect(foo).not.toBe(jasmine.arrayWithExactContents([6])); + }); + + describe("when used with a spy", () => { + it("is useful when comparing arguments", () => { + var callback = jasmine.createSpy('callback'); + + callback([1, 2, 3, 4]); + + expect(callback).toHaveBeenCalledWith(jasmine.arrayWithExactContents([1, 2, 3, 4])); + expect(callback).not.toHaveBeenCalledWith(jasmine.arrayWithExactContents([5, 2])); + }); + }); +}); + +describe("Manually ticking the Jasmine Clock", () => { + var timerCallback: any; + + beforeEach(() => { + timerCallback = jasmine.createSpy("timerCallback"); + jasmine.clock().install(); + }); + + afterEach(() => { + jasmine.clock().uninstall(); + }); + + 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.calls.count()).toEqual(1); + + jasmine.clock().tick(50); + expect(timerCallback.calls.count()).toEqual(1); + + jasmine.clock().tick(50); + expect(timerCallback.calls.count()).toEqual(2); + }); + + describe("Mocking the Date object", () => { + it("mocks the Date object and sets it to a given time", () => { + var baseTime = new Date(2013, 9, 23); + + jasmine.clock().mockDate(baseTime); + + jasmine.clock().tick(50); + expect(new Date().getTime()).toEqual(baseTime.getTime() + 50); + }); + }); +}); + +describe("Asynchronous specs", () => { + var value: number; + beforeEach((done: DoneFn) => { + setTimeout(() => { + value = 0; + done(); + }, 1); + }); + + it("should support async execution of test preparation and expectations", (done: DoneFn) => { + value++; + expect(value).toBeGreaterThan(0); + done(); + }); + + describe("long asynchronous specs", () => { + beforeEach((done: DoneFn) => { + done(); + }, 1000); + + it("takes a long time", (done: DoneFn) => { + setTimeout(() => { + done(); + }, 9000); + }, 10000); + + afterEach((done: DoneFn) => { + done(); + }, 1000); + }); + +}); + +describe("Fail", () => { + + it("should fail test when called without arguments", () => { + fail(); + }); + + it("should fail test when called with a fail message", () => { + fail("The test failed"); + }); + + it("should fail test when called an error", () => { + fail(new Error("The test failed with this error")); + }); + +}); + +// test based on http://jasmine.github.io/2.2/custom_equality.html +describe("custom equality", () => { + var myCustomEquality: jasmine.CustomEqualityTester = function (first: any, second: any): boolean | void { + if (typeof first === "string" && typeof second === "string") { + return first[0] === second[1]; + } + }; + + beforeEach(() => { + jasmine.addCustomEqualityTester(myCustomEquality); + }); + + + it("should be custom equal", () => { + expect("abc").toEqual("aaa"); + }); + + it("should be custom not equal", () => { + expect("abc").not.toEqual("abc"); + }); +}); + +// test based on http://jasmine.github.io/2.2/custom_matcher.html +var customMatchers: jasmine.CustomMatcherFactories = { + toBeGoofy: (util: jasmine.MatchersUtil, customEqualityTesters: jasmine.CustomEqualityTester[]) => { + return { + compare: (actual: any, expected: any): jasmine.CustomMatcherResult => { + if (expected === undefined) { + expected = ''; + } + var result: jasmine.CustomMatcherResult = { pass: false }; + + result.pass = util.equals(actual.hyuk, "gawrsh" + expected, customEqualityTesters); + + if (result.pass) { + result.message = "Expected " + actual + " not to be quite so goofy"; + } else { + result.message = "Expected " + actual + " to be goofy, but it was not very goofy"; + } + + return result; + } + }; + }, + toBeWithinRange: (util: jasmine.MatchersUtil, customEqualityTesters: jasmine.CustomEqualityTester[]) => { + return { + compare: (actual: any, floor: number, ceiling: number): jasmine.CustomMatcherResult => { + const pass = actual >= floor && actual <= ceiling; + const message = `expected ${actual} to be within range ${floor}-${ceiling}`; + return { message, pass }; + }, + + negativeCompare: (actual: any, floor: number, ceiling: number): jasmine.CustomMatcherResult => { + const pass = actual < floor && actual > ceiling; + const message = `expected ${actual} not to be within range ${floor}-${ceiling}`; + return { message, pass }; + } + }; + } +}; +// add the custom matchers to interface jasmine.Matchers via TypeScript declaration merging +// if your test files import or export anything, you'll want to use: +// declare global { +// namespace jasmine { +// interface Matchers { +// ... +// } +// } +// } +declare namespace jasmine { + interface Matchers { + toBeGoofy(expected?: jasmine.Expected): boolean; + toBeWithinRange(expected?: jasmine.Expected, floor?: number, ceiling?: number): boolean; + } +} + +describe("Custom matcher: 'toBeGoofy'", () => { + beforeEach(() => { + jasmine.addMatchers(customMatchers); + }); + + it("is available on an expectation", () => { + expect({ + hyuk: 'gawrsh' + }).toBeGoofy(); + }); + + it("can take an 'expected' parameter", () => { + expect({ + hyuk: 'gawrsh is fun' + }).toBeGoofy({ hyuk: ' is fun' }); + }); + + it("can take many 'expected' parameters", () => { + expect(2).toBeWithinRange(1, 3); + }); + + it("can use the custom negativeCompare method", () => { + const matcher = customMatchers["toBeWithinRange"](jasmine.matchersUtil, []); + const result = matcher.negativeCompare!(1, 2, 3); + + expect(result.pass).toBe(false); + expect(result.message).toBe("expected 1 not to be within range 2-3"); + }); + + it("can be negated", () => { + expect({ + hyuk: 'this is fun' + }).not.toBeGoofy(); + }); + + it("has a proper message on failure", () => { + const actual = { hyuk: 'this is fun' }; + + const matcher = customMatchers["toBeGoofy"](jasmine.matchersUtil, []); + const result = matcher.compare(actual, null); + + expect(result.pass).toBe(false); + expect(result.message).toBe("Expected " + actual + " to be goofy, but it was not very goofy"); + }); +}); + +// test based on http://jasmine.github.io/2.5/custom_reporter.html +var myReporter: jasmine.CustomReporter = { + jasmineStarted: (suiteInfo: jasmine.SuiteInfo) => { + console.log("Running suite with " + suiteInfo.totalSpecsDefined); + }, + + suiteStarted: (result: jasmine.CustomReporterResult) => { + console.log("Suite started: " + result.description + " whose full description is: " + result.fullName); + }, + + specStarted: (result: jasmine.CustomReporterResult) => { + console.log("Spec started: " + result.description + " whose full description is: " + result.fullName); + }, + + specDone: (result: jasmine.CustomReporterResult) => { + console.log("Spec: " + result.description + " was " + result.status); + //tslint:disable-next-line:prefer-for-of + for (var i = 0; result.failedExpectations && i < result.failedExpectations.length; i++) { + console.log("Failure: " + result.failedExpectations[i].message); + console.log("Actual: " + result.failedExpectations[i].actual); + console.log("Expected: " + result.failedExpectations[i].expected); + console.log(result.failedExpectations[i].stack); + } + console.log(result.passedExpectations && result.passedExpectations.length); + }, + + suiteDone: (result: jasmine.CustomReporterResult) => { + console.log('Suite: ' + result.description + ' was ' + result.status); + //tslint:disable-next-line:prefer-for-of + for (var i = 0; result.failedExpectations && i < result.failedExpectations.length; i++) { + console.log('AfterAll ' + result.failedExpectations[i].message); + console.log(result.failedExpectations[i].stack); + } + }, + + jasmineDone: (runDetails: jasmine.RunDetails) => { + console.log('Finished suite'); + console.log('Random:', runDetails.order.random); + } +}; + +jasmine.getEnv().addReporter(myReporter); + +describe("Randomize Tests", () => { + it("should allow randomization of the order of tests", () => { + expect(() => { + var env = jasmine.getEnv(); + return env.randomizeTests(true); + }).not.toThrow(); + }); + + it("should allow a seed to be passed in for randomization", () => { + expect(() => { + var env = jasmine.getEnv(); + env.randomizeTests(true); + return env.seed(1234); + }).not.toThrow(); + }); +}); + +//dest spces copied from jasmine project (https://github.com/jasmine/jasmine/blob/master/spec/core/SpecSpec.js) +describe("createSpyObj", function () { + it("should create an object with spy methods and corresponding return values when you call jasmine.createSpyObj() with an object", function () { + var spyObj = jasmine.createSpyObj('BaseName', { 'method1': 42, 'method2': 'special sauce' }); + + expect(spyObj.method1()).toEqual(42); + expect(spyObj.method1.and.identity()).toEqual('BaseName.method1'); + + expect(spyObj.method2()).toEqual('special sauce'); + expect(spyObj.method2.and.identity()).toEqual('BaseName.method2'); + }); + + + it("should create an object with a bunch of spy methods when you call jasmine.createSpyObj()", function () { + var spyObj = jasmine.createSpyObj('BaseName', ['method1', 'method2']); + + expect(spyObj).toEqual({ method1: jasmine.any(Function), method2: jasmine.any(Function) }); + expect(spyObj.method1.and.identity()).toEqual('BaseName.method1'); + expect(spyObj.method2.and.identity()).toEqual('BaseName.method2'); + }); + + it("should allow you to omit the baseName and takes only an object", function () { + var spyObj = jasmine.createSpyObj({ 'method1': 42, 'method2': 'special sauce' }); + + expect(spyObj.method1()).toEqual(42); + expect(spyObj.method1.and.identity()).toEqual('unknown.method1'); + + expect(spyObj.method2()).toEqual('special sauce'); + expect(spyObj.method2.and.identity()).toEqual('unknown.method2'); + }); + + it("should allow you to omit the baseName and takes only a list of methods", function () { + var spyObj = jasmine.createSpyObj(['method1', 'method2']); + + expect(spyObj).toEqual({ method1: jasmine.any(Function), method2: jasmine.any(Function) }); + expect(spyObj.method1.and.identity()).toEqual('unknown.method1'); + expect(spyObj.method2.and.identity()).toEqual('unknown.method2'); + }); + + it("should throw if you pass an empty array argument", function () { + expect(function () { + jasmine.createSpyObj('BaseName', []); + }).toThrow("createSpyObj requires a non-empty array or object of method names to create spies for"); + }); + + it("should throw if you pass an empty object argument", function () { + expect(function () { + jasmine.createSpyObj('BaseName', {}); + }).toThrow("createSpyObj requires a non-empty array or object of method names to create spies for"); + }); +}); + +(() => { + // from boot.js + var env = jasmine.getEnv(); + + var htmlReporter = new jasmine.HtmlReporter(); + env.addReporter(htmlReporter); + + var specFilter = new jasmine.HtmlSpecFilter(); + env.specFilter = (spec) => { + return specFilter.matches(spec.getFullName()); + }; + + var currentWindowOnload = window.onload; + window.onload = () => { + if (currentWindowOnload) { + (currentWindowOnload as any)(null); + } + htmlReporter.initialize(); + env.execute(); + }; + +})(); + +jasmine.DEFAULT_TIMEOUT_INTERVAL = 1000; +jasmine.MAX_PRETTY_PRINT_DEPTH = 40; diff --git a/types/jasmine/v2/tsconfig.json b/types/jasmine/v2/tsconfig.json new file mode 100644 index 0000000000..e9212545a7 --- /dev/null +++ b/types/jasmine/v2/tsconfig.json @@ -0,0 +1,27 @@ +{ + "files": [ + "index.d.ts", + "jasmine-tests.ts" + ], + "compilerOptions": { + "module": "commonjs", + "lib": [ + "es6", + "dom" + ], + "noImplicitAny": true, + "noImplicitThis": true, + "strictNullChecks": true, + "strictFunctionTypes": false, + "baseUrl": "../../", + "typeRoots": [ + "../../" + ], + "paths": { + "jasmine": [ "jasmine/v2" ] + }, + "types": [], + "noEmit": true, + "forceConsistentCasingInFileNames": true + } +} diff --git a/types/jasmine/v2/tslint.json b/types/jasmine/v2/tslint.json new file mode 100644 index 0000000000..2daeb51ad8 --- /dev/null +++ b/types/jasmine/v2/tslint.json @@ -0,0 +1,80 @@ +{ + "extends": "dtslint/dt.json", + "rules": { + "adjacent-overload-signatures": false, + "array-type": false, + "arrow-return-shorthand": false, + "ban-types": false, + "callable-types": false, + "comment-format": false, + "dt-header": true, + "eofline": false, + "export-just-namespace": false, + "file-name-casing": [true, "kebab-case"], + "import-spacing": false, + "interface-name": false, + "interface-over-type-literal": false, + "jsdoc-format": false, + "max-line-length": false, + "member-access": false, + "new-parens": false, + "no-any-union": false, + "no-boolean-literal-compare": false, + "no-conditional-assignment": false, + "no-consecutive-blank-lines": false, + "no-construct": false, + "no-declare-current-package": false, + "no-duplicate-imports": false, + "no-duplicate-variable": false, + "no-empty-interface": false, + "no-for-in-array": false, + "no-inferrable-types": false, + "no-internal-module": false, + "no-irregular-whitespace": false, + "no-mergeable-namespace": false, + "no-misused-new": false, + "no-namespace": false, + "no-object-literal-type-assertion": false, + "no-padding": false, + "no-redundant-jsdoc": false, + "no-redundant-jsdoc-2": false, + "no-redundant-undefined": false, + "no-reference-import": false, + "no-relative-import-in-test": false, + "no-self-import": false, + "no-single-declare-module": false, + "no-string-throw": false, + "no-unnecessary-callback-wrapper": false, + "no-unnecessary-class": false, + "no-unnecessary-generics": false, + "no-unnecessary-qualifier": false, + "no-unnecessary-type-assertion": false, + "no-useless-files": false, + "no-var-keyword": false, + "no-var-requires": false, + "no-void-expression": false, + "no-trailing-whitespace": false, + "object-literal-key-quotes": false, + "object-literal-shorthand": false, + "one-line": false, + "one-variable-per-declaration": false, + "only-arrow-functions": false, + "prefer-conditional-expression": false, + "prefer-const": false, + "prefer-declare-function": false, + "prefer-for-of": false, + "prefer-method-signature": false, + "prefer-template": false, + "radix": false, + "semicolon": false, + "space-before-function-paren": false, + "space-within-parens": false, + "strict-export-declare-modifiers": false, + "trim-file": false, + "triple-equals": false, + "typedef-whitespace": false, + "unified-signatures": false, + "void-return": false, + "whitespace": false + } +}