@types/jest - npm Package Compare versions

Comparing version 0.9.31 to 15.1.32

jest/index.d.ts

@@ -1,41 +0,80 @@
-// Type definitions for Jest 0.9.0
+// Type definitions for Jest 15.1.1
 // Project: http://facebook.github.io/jest/
-// Definitions by: Asana <https://asana.com>
+// Definitions by: Asana <https://asana.com>, Ivo Stratev <https://github.com/NoHomey>, jwbay <https://github.com/jwbay>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 
-/// <reference types="node" />
-
-declare function afterEach(fn: jest.EmptyFunction): void;
-declare function beforeEach(fn: jest.EmptyFunction): void;
-declare function describe(name: string, fn: jest.EmptyFunction): void;
+declare var beforeAll: jest.Lifecycle;
+declare var beforeEach: jest.Lifecycle;
+declare var afterAll: jest.Lifecycle;
+declare var afterEach: jest.Lifecycle;
+declare var describe: jest.Describe;
+declare var fdescribe: jest.Describe;
+declare var xdescribe: jest.Describe;
 declare var it: jest.It;
+declare var fit: jest.It;
+declare var xit: jest.It;
 declare var test: jest.It;
-declare function pit(name: string, fn: jest.EmptyFunction): void;
+declare var xtest: jest.It;
 
-declare function xdescribe(name: string, fn: jest.EmptyFunction): void;
-declare function xit(name: string, fn: jest.EmptyFunction): void;
-
 declare function expect(actual: any): jest.Matchers;
 
 interface NodeRequire {
+    /** Returns the actual module instead of a mock, bypassing all checks on whether the module should receive a mock implementation or not. */
     requireActual(moduleName: string): any;
+    /** Returns a mock module instead of the actual module, bypassing all checks on whether the module should be required normally or not. */
+    requireMock(moduleName: string): any;
 }
 
 declare namespace jest {
-    function addMatchers(matchers: CustomMatcherFactories): void;
+    function addMatchers(matchers: jasmine.CustomMatcherFactories): void;
+    /** Disables automatic mocking in the module loader. */
     function autoMockOff(): void;
+    /** Enables automatic mocking in the module loader. */
     function autoMockOn(): void;
+    /** Removes any pending timers from the timer system. If any timers have been scheduled, they will be cleared and will never have the opportunity to execute in the future. */
     function clearAllTimers(): void;
-    function currentTestPath(): string;
+    /** Indicates that the module system should never return a mocked version of the specified module, including all of the specificied module's dependencies. */
+    function deepUnmock(moduleName: string): void;
+    /** Disables automatic mocking in the module loader. */
     function disableAutomock(): void;
+    /** Mocks a module with an auto-mocked version when it is being required. */
+    function doMock(moduleName: string): void;
+    /** Indicates that the module system should never return a mocked version of the specified module from require() (e.g. that it should always return the real module). */
+    function dontMock(moduleName: string): void;
+    /** Enables automatic mocking in the module loader. */
+    function enableAutomock(): void;
+    /** Creates a mock function. Optionally takes a mock implementation. */
     function fn<T>(implementation?: Function): Mock<T>;
-    function dontMock(moduleName: string): void;
-    function genMockFromModule<T>(moduleName: string): Mock<T>;
-    function mock(moduleName: string, factory?: Function): void;
+    /** Use the automatic mocking system to generate a mocked version of the given module. */
+    function genMockFromModule<T>(moduleName: string): T;
+    /** Returns whether the given function is a mock function. */
+    function isMockFunction(fn: any): fn is Mock<any>;
+    /** Mocks a module with an auto-mocked version when it is being required. */
+    function mock(moduleName: string, factory?: any, options?: MockOptions): void;
+    /** Resets the module registry - the cache of all required modules. This is useful to isolate modules where local state might conflict between tests. */
+    function resetModuleRegistry(): void;
+    /** Resets the module registry - the cache of all required modules. This is useful to isolate modules where local state might conflict between tests. */
+    function resetModules(): void;
+    /** Exhausts tasks queued by setImmediate(). */
+    function runAllImmediates(): void;
+    /** Exhausts the micro-task queue (usually interfaced in node via process.nextTick). */
     function runAllTicks(): void;
+    /** Exhausts the macro-task queue (i.e., all tasks queued by setTimeout() and setInterval()). */
     function runAllTimers(): void;
+    /** Executes only the macro-tasks that are currently pending (i.e., only the tasks that have been queued by setTimeout() or setInterval() up to this point).
+     * If any of the currently pending macro-tasks schedule new macro-tasks, those new tasks will not be executed by this call. */
     function runOnlyPendingTimers(): void;
+    /** Explicitly supplies the mock object that the module system should return for the specified module. */
     function setMock<T>(moduleName: string, moduleExports: T): void;
+    /** Indicates that the module system should never return a mocked version of the specified module from require() (e.g. that it should always return the real module). */
     function unmock(moduleName: string): void;
+    /** Instructs Jest to use fake versions of the standard timer functions. */
+    function useFakeTimers(): void;
+    /** Instructs Jest to use the real versions of the standard timer functions. */
+    function useRealTimers(): void;
 
+    interface MockOptions {
+        virtual?: boolean;
+    }
+
     interface EmptyFunction {
@@ -45,34 +84,66 @@ (): void;
 
+    interface DoneCallback {
+        (...args: any[]): any
+        fail(error?: string | { message: string }): any;
+    }
+
+    interface ProvidesCallback {
+        (cb?: DoneCallback): any;
+    }
+
+    interface Lifecycle {
+        (fn: ProvidesCallback): any;
+    }
+
+    interface It {
+        (name: string, fn: ProvidesCallback): void;
+        only: It;
+        skip: It;
+    }
+
+    interface Describe {
+        (name: string, fn: EmptyFunction): void
+        only: Describe;
+        skip: Describe;
+    }
+
     interface Matchers {
         not: Matchers;
-        toThrow(expected?: any): boolean;
-        toBe(expected: any): boolean;
-        toEqual(expected: any): boolean;
-        toBeFalsy(): boolean;
-        toBeTruthy(): boolean;
-        toBeNull(): boolean;
-        toBeDefined(): boolean;
-        toBeUndefined(): boolean;
-        toMatch(expected: RegExp): boolean;
-        toContain(expected: string): boolean;
-        toBeCloseTo(expected: number, delta: number): boolean;
-        toBeGreaterThan(expected: number): boolean;
-        toBeLessThan(expected: number): boolean;
-        toBeCalled(): boolean;
-        toBeCalledWith(...args: any[]): boolean;
-        lastCalledWith(...args: any[]): boolean;
+        lastCalledWith(...args: any[]): void;
+        toBe(expected: any): void;
+        toBeCalled(): void;
+        toBeCalledWith(...args: any[]): void;
+        toBeCloseTo(expected: number, delta: number): void;
+        toBeDefined(): void;
+        toBeFalsy(): void;
+        toBeGreaterThan(expected: number): void;
+        toBeGreaterThanOrEqual(expected: number): void;
+        toBeInstanceOf(expected: any): void
+        toBeLessThan(expected: number): void;
+        toBeLessThanOrEqual(expected: number): void;
+        toBeNull(): void;
+        toBeTruthy(): void;
+        toBeUndefined(): void;
+        toContain(expected: any): void;
+        toEqual(expected: any): void;
+        toHaveBeenCalled(): boolean;
+        toHaveBeenCalledTimes(expected: number): boolean;
+        toHaveBeenCalledWith(...params: any[]): boolean;
+        toMatch(expected: string | RegExp): void;
+        toMatchSnapshot(): void;
+        toThrow(): void;
+        toThrowError(error?: string | Constructable | RegExp): void;
     }
 
-    interface It {
-        (name: string, fn: EmptyFunction): void;
-        only(name: string, fn: EmptyFunction): void;
+    interface Constructable {
+        new (...args: any[]): any
     }
 
-    interface Mock<T> {
+    interface Mock<T> extends Function {
         new (): T;
-        (...args: any[]): any; // TODO please fix this line! added for TypeScript 1.1.0-1 https://github.com/DefinitelyTyped/DefinitelyTyped/pull/2932
+        (...args: any[]): any;
         mock: MockContext<T>;
         mockClear(): void;
         mockImplementation(fn: Function): Mock<T>;
-        mockImpl(fn: Function): Mock<T>;
+        mockImplementationOnce(fn: Function): Mock<T>;
         mockReturnThis(): Mock<T>;
@@ -87,4 +158,106 @@ mockReturnValue(value: any): Mock<T>;
     }
+}
 
-    // taken from Jasmine since addMatchers calls into the jasmine api
+//Jest ships with a copy of Jasmine. They monkey-patch its APIs and divergence/deprecation are expected.
+//Relevant parts of Jasmine's API are below so they can be changed and removed over time.
+//This file can't reference jasmine.d.ts since the globals aren't compatible.
+
+declare function spyOn(object: any, method: string): jasmine.Spy;
+/** If you call the function pending anywhere in the spec body, no matter the expectations, the spec will be marked pending. */
+declare function pending(reason?: string): void;
+/** Fails a test when called within one. */
+declare function fail(error?: any): void;
+declare namespace jasmine {
+    var clock: () => Clock;
+    function any(aclass: any): Any;
+    function anything(): Any;
+    function arrayContaining(sample: any[]): ArrayContaining;
+    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 addCustomEqualityTester(equalityTester: CustomEqualityTester): void;
+    function addMatchers(matchers: CustomMatcherFactories): void;
+    function stringMatching(value: string | RegExp): 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;
+    }
+
+    interface Any {
+        new (expectedClass: any): any;
+        jasmineMatches(other: any): boolean;
+        jasmineToString(): string;
+    }
+
+    interface ArrayContaining {
+        new (sample: any[]): any;
+        asymmetricMatch(other: any): boolean;
+        jasmineToString(): string;
+    }
+
+    interface ObjectContaining {
+        new (sample: any): any;
+        jasmineMatches(other: any, mismatchKeys: any[], mismatchValues: any[]): boolean;
+        jasmineToString(): string;
+    }
+
+    interface Spy {
+        (...params: any[]): any;
+        identity: string;
+        and: SpyAnd;
+        calls: Calls;
+        mostRecentCall: { args: any[]; };
+        argsForCall: any[];
+        wasCalled: boolean;
+    }
+
+    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 CustomMatcherFactories {
@@ -94,3 +267,2 @@ [index: string]: CustomMatcherFactory;
 
-    // taken from Jasmine since addMatchers calls into the jasmine api
     interface CustomMatcherFactory {
@@ -100,3 +272,2 @@ (util: MatchersUtil, customEqualityTesters: Array<CustomEqualityTester>): CustomMatcher;
 
-    // taken from Jasmine since addMatchers calls into the jasmine api
     interface MatchersUtil {
@@ -108,3 +279,2 @@ equals(a: any, b: any, customTesters?: Array<CustomEqualityTester>): boolean;
 
-    // taken from Jasmine since addMatchers calls into the jasmine api
     interface CustomEqualityTester {
@@ -114,3 +284,2 @@ (first: any, second: any): boolean;
 
-    // taken from Jasmine since addMatchers calls into the jasmine api
     interface CustomMatcher {
@@ -121,9 +290,7 @@ compare<T>(actual: T, expected: T): CustomMatcherResult;
 
-    // taken from Jasmine since addMatchers calls into the jasmine api
     interface CustomMatcherResult {
         pass: boolean;
-        message: string;
+        message: string | (() => string);
     }
 
-    // taken from Jasmine which takes from TypeScript lib.core.es6.d.ts, applicable to CustomMatchers.contains()
     interface ArrayLike<T> {
@@ -130,0 +297,0 @@ length: number;

jest/package.json

 {
     "name": "@types/jest",
-    "version": "0.9.31",
-    "description": "TypeScript definitions for Jest 0.9.0",
+    "version": "15.1.32",
+    "description": "TypeScript definitions for Jest 15.1.1",
     "license": "MIT",
-    "author": "Asana <https://asana.com>",
+    "author": "Asana <https://asana.com>, Ivo Stratev <https://github.com/NoHomey>, jwbay <https://github.com/jwbay>",
     "main": "",
@@ -13,7 +13,5 @@ "repository": {
     "scripts": {},
-    "dependencies": {
-        "@types/node": "*"
-    },
+    "dependencies": {},
     "typings": "index.d.ts",
-    "typesPublisherContentHash": "ad32e6cec56fa262641a48560cd14bd6946c1190f6d080227650cf6d3d0dcba9"
+    "typesPublisherContentHash": "a9b6ffd31b389cdb17f14d94e68c1b88467acaaf8e600fcd3f6a2cdf3534fb93"
 }

jest/README.md

@@ -5,3 +5,3 @@ # Installation
 # Summary
-This package contains type definitions for Jest 0.9.0 (http://facebook.github.io/jest/).
+This package contains type definitions for Jest 15.1.1 (http://facebook.github.io/jest/).
 
@@ -12,9 +12,9 @@ # Details
 Additional Details
- * Last updated: Mon, 12 Sep 2016 17:13:58 GMT
+ * Last updated: Wed, 21 Sep 2016 20:25:54 GMT
  * File structure: Global
- * Library Dependencies: node
+ * Library Dependencies: none
  * Module Dependencies: none
- * Global values: afterEach, beforeEach, describe, expect, it, jest, pit, test, xdescribe, xit
+ * Global values: afterAll, afterEach, beforeAll, beforeEach, describe, expect, fail, fdescribe, fit, it, jasmine, jest, pending, spyOn, test, xdescribe, xit, xtest
 
 # Credits
-These definitions were written by Asana <https://asana.com>.
+These definitions were written by Asana <https://asana.com>, Ivo Stratev <https://github.com/NoHomey>, jwbay <https://github.com/jwbay>.

jest/types-metadata.json

 {
-    "authors": "Asana <https://asana.com>",
+    "authors": "Asana <https://asana.com>, Ivo Stratev <https://github.com/NoHomey>, jwbay <https://github.com/jwbay>",
     "definitionFilename": "index.d.ts",
-    "libraryDependencies": [
-        "node"
-    ],
+    "libraryDependencies": [],
     "moduleDependencies": [],
-    "libraryMajorVersion": "0",
-    "libraryMinorVersion": "9",
-    "libraryName": "Jest 0.9.0",
+    "libraryMajorVersion": "15",
+    "libraryMinorVersion": "1",
+    "libraryName": "Jest 15.1.1",
     "typingsPackageName": "jest",
@@ -17,12 +15,20 @@ "projectName": "http://facebook.github.io/jest/",
     "globals": [
+        "afterAll",
         "afterEach",
+        "beforeAll",
         "beforeEach",
         "describe",
         "expect",
+        "fail",
+        "fdescribe",
+        "fit",
         "it",
+        "jasmine",
         "jest",
-        "pit",
+        "pending",
+        "spyOn",
         "test",
         "xdescribe",
-        "xit"
+        "xit",
+        "xtest"
     ],
@@ -34,3 +40,3 @@ "declaredModules": [],
     "hasPackageJson": false,
-    "contentHash": "ad32e6cec56fa262641a48560cd14bd6946c1190f6d080227650cf6d3d0dcba9"
+    "contentHash": "a9b6ffd31b389cdb17f14d94e68c1b88467acaaf8e600fcd3f6a2cdf3534fb93"
 }

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Major refactor

Supply chain risk

Package has recently undergone a major refactor. It may be unstable or indicate significant internal changes. Use caution when updating to versions that include significant changes.

Found 1 instance in 1 package

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

No v1

Quality

Package is not semver >=1. This means it is not stable and does not support ^ ranges.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

15451

increased by131.34%

Dependency count

0

decreased by-100%

Lines of code

300

increased by112.77%

Number of low quality alerts

1

decreased by-50%

Worsened metrics

Number of medium supply chain risk alerts

1

increased byInfinity%

Dependency changes

• - Removed@types/node@*

• - Removed@types/node@22.7.4(transitive)

• - Removedundici-types@6.19.8(transitive)