Add generator function to accepted hook types

packages/jest-circus/src/utils.ts

@@ -215,17 +215,25 @@ export const callAsyncCircusFn = (
         });
       };
 
-      returnedValue = fn.call(testContext, done);
+      returnedValue = fn.call<
+        Circus.TestContext | undefined,
+        Array<typeof done>,
+        void | Promise<unknown> | Generator | undefined
+      >(testContext, done);
 
       return;
     }
 
-    let returnedValue;
+    let returnedValue: any;
     if (isGeneratorFn(fn)) {
       returnedValue = co.wrap(fn).call({});
     } else {
       try {
-        returnedValue = fn.call(testContext);
+        returnedValue = fn.call<
+          Circus.TestContext | undefined,
+          [],
+          void | Promise<unknown> | Generator | undefined
+        >(testContext);
       } catch (error) {
         reject(error);
         return;

packages/jest-types/src/Global.ts

@@ -7,11 +7,14 @@
 
 import type {CoverageMapData} from 'istanbul-lib-coverage';
 
+export type GeneratorFn = (...args: Array<any>) => Generator;
 export type DoneFn = (reason?: string | Error) => void;
-export type TestName = string;
-export type TestFn = (
+export type CallbackFn = (
   done?: DoneFn,
-) => Promise<void | undefined | unknown> | void | undefined;
+) => void | undefined | Promise<void | undefined | unknown>;
+
+export type TestName = string;
+export type TestFn = GeneratorFn | CallbackFn;
 export type ConcurrentTestFn = (
   done?: DoneFn,
 ) => Promise<void | undefined | unknown>;

test-types/top-level-globals.test.ts

@@ -19,24 +19,32 @@ import {
 
 const fn = () => {};
 const asyncFn = async () => {};
+const genFn = function* () {};
 const timeout = 5;
 const testName = 'Test name';
 const testTable = [[1, 2]];
 
 // https://jestjs.io/docs/en/api#methods
 expectType<void>(afterAll(fn));
 expectType<void>(afterAll(asyncFn));
+expectType<void>(afterAll(genFn));
 expectType<void>(afterAll(fn, timeout));
 expectType<void>(afterEach(fn));
 expectType<void>(afterEach(asyncFn));
+expectType<void>(afterEach(genFn));
 expectType<void>(afterEach(fn, timeout));
 expectType<void>(beforeAll(fn));
 expectType<void>(beforeAll(asyncFn));
+expectType<void>(beforeAll(genFn));
 expectType<void>(beforeAll(fn, timeout));
 expectType<void>(beforeEach(fn));
 expectType<void>(beforeEach(asyncFn));
+expectType<void>(beforeEach(genFn));
 expectType<void>(beforeEach(fn, timeout));
 
+expectType<void>(test(testName, fn));
+expectType<void>(test(testName, asyncFn));
+expectType<void>(test(testName, genFn));
 expectType<void>(test.each(testTable)(testName, fn));
 expectType<void>(test.each(testTable)(testName, fn, timeout));
 expectType<void>(test.only.each(testTable)(testName, fn));