jest: Update for v27

types/jest/index.d.ts

@@ -1,4 +1,4 @@
-// Type definitions for Jest 26.0
+// Type definitions for Jest 27.0
 // Project: https://jestjs.io/
 // Definitions by: Asana (https://asana.com)
 //                 Ivo Stratev <https://github.com/NoHomey>
@@ -28,6 +28,7 @@
 //                 Pawel Fajfer <https://github.com/pawfa>
 //                 Regev Brody <https://github.com/regevbr>
 //                 Alexandre Germain <https://github.com/gerkindev>
+//                 Adam Jones <https://github.com/domdomegg>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 // Minimum TypeScript Version: 3.8
 
@@ -73,10 +74,6 @@ type ExtractEachCallbackArgs<T extends ReadonlyArray<any>> = {
 ];
 
 declare namespace jest {
-    /**
-     * Provides a way to add Jasmine-compatible matchers into your Jest context.
-     */
-    function addMatchers(matchers: jasmine.CustomMatcherFactories): typeof jest;
     /**
      * Disables automatic mocking in the module loader.
      */
@@ -194,11 +191,6 @@ declare namespace jest {
      */
     // tslint:disable-next-line: no-unnecessary-generics
     function requireMock<TModule extends {} = any>(moduleName: string): TModule;
-    /**
-     * 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(): typeof jest;
     /**
      * Resets the module registry - the cache of all required modules. This is
      * useful to isolate modules where local state might conflict between tests.
@@ -216,14 +208,18 @@ declare namespace jest {
     function retryTimes(numRetries: number): typeof jest;
     /**
      * Exhausts tasks queued by setImmediate().
+     * > Note: This function is only available when using modern fake timers
+     * > implementation
      */
     function runAllImmediates(): typeof jest;
     /**
      * Exhausts the micro-task queue (usually interfaced in node via process.nextTick).
      */
     function runAllTicks(): typeof jest;
     /**
-     * Exhausts the macro-task queue (i.e., all tasks queued by setTimeout() and setInterval()).
+     * Exhausts both the macro-task queue (i.e., all tasks queued by setTimeout(),
+     * setInterval(), and setImmediate()) and the micro-task queue (usually interfaced
+     * in node via process.nextTick).
      */
     function runAllTimers(): typeof jest;
     /**
@@ -233,11 +229,6 @@ declare namespace jest {
      * those new tasks will not be executed by this call.
      */
     function runOnlyPendingTimers(): typeof jest;
-    /**
-     * (renamed to `advanceTimersByTime` in Jest 21.3.0+) Executes only the macro
-     * task queue (i.e. all tasks queued by setTimeout() or setInterval() and setImmediate()).
-     */
-    function runTimersToTime(msToRun: number): typeof jest;
     /**
      * Advances all timers by msToRun milliseconds. All pending "macro-tasks" that have been
      * queued via setTimeout() or setInterval(), and would be executed within this timeframe
@@ -340,9 +331,10 @@ declare namespace jest {
         fail(error?: string | { message: string }): any;
     }
 
-    type ProvidesCallback = (cb: DoneCallback) => any;
+    type ProvidesCallback = ((cb: DoneCallback) => void | undefined) | (() => Promise<unknown>);
+    type ProvidesHookCallback = (() => any) | ProvidesCallback;
 
-    type Lifecycle = (fn: ProvidesCallback, timeout?: number) => any;
+    type Lifecycle = (fn: ProvidesHookCallback, timeout?: number) => any;
 
     interface FunctionLike {
         readonly name: string;
@@ -1371,7 +1363,6 @@ declare namespace jasmine {
     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 {

types/jest/jest-tests.ts

@@ -15,20 +15,36 @@ describe('', () => {
 /* Lifecycle events */
 
 beforeAll(() => {});
+beforeAll(() => null);
+beforeAll(() => true);
 beforeAll((done: jest.DoneCallback) => {});
 beforeAll((done: jest.DoneCallback) => done.fail(), 9001);
+// $ExpectError
+beforeAll((done: jest.DoneCallback) => Promise.resolve());
 
 beforeEach(() => {});
+beforeEach(() => null);
+beforeEach(() => true);
 beforeEach((done: jest.DoneCallback) => {});
 beforeEach((done: jest.DoneCallback) => done.fail(), 9001);
+// $ExpectError
+beforeEach((done: jest.DoneCallback) => Promise.resolve());
 
 afterAll(() => {});
+afterAll(() => null);
+afterAll(() => true);
 afterAll((done: jest.DoneCallback) => {});
 afterAll((done: jest.DoneCallback) => done.fail(), 9001);
+// $ExpectError
+afterAll((done: jest.DoneCallback) => Promise.resolve());
 
 afterEach(() => {});
+afterEach(() => null, 9001);
+afterEach(() => true, 9001);
 afterEach((done: jest.DoneCallback) => {});
 afterEach((done: jest.DoneCallback) => done.fail(), 9001);
+// $ExpectError
+afterEach((done: jest.DoneCallback) => Promise.resolve());
 
 /* describe */
 
@@ -246,10 +262,7 @@ describe('', () => {
 
 const customMatcherFactories: jasmine.CustomMatcherFactories = {};
 
-jest.addMatchers(customMatcherFactories)
-    .addMatchers({})
-    .addMatchers(customMatcherFactories)
-    .autoMockOff()
+jest.autoMockOff()
     .autoMockOn()
     .clearAllMocks()
     .clearAllTimers()
@@ -268,15 +281,13 @@ jest.addMatchers(customMatcherFactories)
     .mock('moduleName', jest.fn())
     .mock('moduleName', jest.fn(), {})
     .mock('moduleName', jest.fn(), { virtual: true })
-    .resetModuleRegistry()
     .resetModules()
     .isolateModules(() => {})
     .retryTimes(3)
     .runAllImmediates()
     .runAllTicks()
     .runAllTimers()
     .runOnlyPendingTimers()
-    .runTimersToTime(9001)
     .advanceTimersByTime(9001)
     .setMock('moduleName', {})
     .setMock<{}>('moduleName', {})
@@ -1494,3 +1505,70 @@ test.only.each`
 
 expect('').toHaveProperty('path.to.thing');
 expect('').toHaveProperty('path.to.thing', {});
+
+/* Test function can return a promise */
+
+test(`returns a Promise<boolean>`, () => {
+    return Promise.resolve(true);
+});
+
+test(`returns a Promise<{ isAnObject: boolean }>`, () => {
+    return Promise.resolve({ isAnObject: true });
+});
+
+test(`returns a Promise<any>`, () => {
+    return Promise.resolve('any' as any);
+});
+
+/* Test function can take and call the done callback function */
+
+test(`uses done`, (done) => {
+    done();
+});
+
+/* Test function can do nothing */
+
+test(`does nothing`, () => {
+    // noop
+});
+
+/* Test function should not return non-promise */
+
+// $ExpectError
+test(`returns a boolean`, () => {
+    return true;
+});
+
+// $ExpectError
+test(`returns a number`, () => {
+    return 3;
+});
+
+// $ExpectError
+test(`returns an object`, () => {
+    return {
+        isAnObject: true
+    };
+});
+
+/* Test function should not return promise and takes done callback function */
+
+// $ExpectError
+test(`returns a Promise<boolean> and takes done`, (done) => {
+    return Promise.resolve(true);
+});
+
+// $ExpectError
+test(`returns a Promise<{ isAnObject: boolean }> and takes done`, (done) => {
+    return Promise.resolve({ isAnObject: true });
+});
+
+// $ExpectError
+test(`returns a Promise<any> and takes done`, (done) => {
+    return Promise.resolve('any' as any);
+});
+
+// $ExpectError
+test(`async function takes done`, async (done) => {
+    done();
+});