Fix type definitions for promises

When calling `mockResolvedValue` (-`Once`), the argument should be
the expected return value unwrapped from its Promise. Likewise,
when mocking a rejected value, the passed argument needs not
necessarily be of the same type as the expected successful return
value.

Author: Vinnl

CHANGELOG.md

@@ -4,6 +4,8 @@
 
 ### Fixes
 
+- `[jest-mock]` Fix typings for `mockResolvedValue`, `mockResolvedValueOnce`, `mockRejectedValue` and `mockRejectedValueOnce`
+
 ### Chore & Maintenance
 
 ### Performance

packages/jest-mock/src/index.ts

@@ -63,13 +63,15 @@ namespace JestMock {
     mockReturnThis(): this;
     mockReturnValue(value: T): this;
     mockReturnValueOnce(value: T): this;
-    mockResolvedValue(value: T): this;
-    mockResolvedValueOnce(value: T): this;
-    mockRejectedValue(value: T): this;
-    mockRejectedValueOnce(value: T): this;
+    mockResolvedValue(value: Unpromisify<T>): this;
+    mockResolvedValueOnce(value: Unpromisify<T>): this;
+    mockRejectedValue(value: unknown): this;
+    mockRejectedValueOnce(value: unknown): this;
   }
 }
 
+type Unpromisify<T> = T extends Promise<infer R> ? R : never;
+
 /**
  * Possible types of a MockFunctionResult.
  * 'return': The call completed by returning normally.
@@ -661,20 +663,20 @@ class ModuleMockerClass {
         // next function call will return this value or default return value
         f.mockImplementationOnce(() => value);
 
-      f.mockResolvedValueOnce = (value: T) =>
-        f.mockImplementationOnce(() => Promise.resolve(value));
+      f.mockResolvedValueOnce = (value: Unpromisify<T>) =>
+        f.mockImplementationOnce(() => Promise.resolve(value as T));
 
-      f.mockRejectedValueOnce = (value: T) =>
+      f.mockRejectedValueOnce = (value: unknown) =>
         f.mockImplementationOnce(() => Promise.reject(value));
 
       f.mockReturnValue = (value: T) =>
         // next function call will return specified return value or this one
         f.mockImplementation(() => value);
 
-      f.mockResolvedValue = (value: T) =>
-        f.mockImplementation(() => Promise.resolve(value));
+      f.mockResolvedValue = (value: Unpromisify<T>) =>
+        f.mockImplementation(() => Promise.resolve(value as T));
 
-      f.mockRejectedValue = (value: T) =>
+      f.mockRejectedValue = (value: unknown) =>
         f.mockImplementation(() => Promise.reject(value));
 
       f.mockImplementationOnce = (

test-types/top-level-jest-namespace.test.ts

@@ -10,6 +10,7 @@
 import {expectError, expectType} from 'mlh-tsd';
 //eslint-disable-next-line import/no-extraneous-dependencies
 import {jest} from '@jest/globals';
+import JestMock = require('jest-mock');
 
 expectType<void>(jest.addMatchers({}));
 expectType<typeof jest>(jest.autoMockOff());
@@ -37,6 +38,26 @@ expectType<typeof jest>(jest.resetModuleRegistry());
 expectType<typeof jest>(jest.resetModules());
 expectType<typeof jest>(jest.isolateModules(() => {}));
 expectType<typeof jest>(jest.retryTimes(3));
+expectType<JestMock.Mock<Promise<string>, []>>(
+  jest
+    .fn(() => Promise.resolve('string value'))
+    .mockResolvedValueOnce('A string, not a Promise'),
+);
+expectType<JestMock.Mock<Promise<string>, []>>(
+  jest
+    .fn(() => Promise.resolve('string value'))
+    .mockResolvedValue('A string, not a Promise'),
+);
+expectType<JestMock.Mock<Promise<string>, []>>(
+  jest
+    .fn(() => Promise.resolve('string value'))
+    .mockRejectedValueOnce(new Error('An error, not a string')),
+);
+expectType<JestMock.Mock<Promise<string>, []>>(
+  jest
+    .fn(() => Promise.resolve('string value'))
+    .mockRejectedValue(new Error('An error, not a string')),
+);
 
 expectType<void>(jest.runAllImmediates());
 expectType<void>(jest.runAllTicks());