Fixed mockReturnValue overriding mockImplementationOnce

CHANGELOG.md

@@ -25,6 +25,7 @@
 - `[expect]` Extract names of async and generator functions ([#8362](https://github.com/facebook/jest/pull/8362))
 - `[jest-runtime]` Fix virtual mocks not being unmockable after previously being mocked ([#8396](https://github.com/facebook/jest/pull/8396))
 - `[jest-transform]` Replace special characters in transform cache filenames to support Windows ([#8353](https://github.com/facebook/jest/pull/8353))
+- `[jest-mock]` Fix for mockReturnValue overriding mockImplementationOnce ([#8398](https://github.com/facebook/jest/pull/8398))
 
 ### Chore & Maintenance
 

packages/jest-mock/src/__tests__/index.test.ts

@@ -994,6 +994,15 @@ describe('moduleMocker', () => {
     });
   });
 
+  test('mockReturnValue does not override mockImplementationOnce', () => {
+    const mockFn = jest
+      .fn()
+      .mockReturnValue(1)
+      .mockImplementationOnce(() => 2);
+    expect(mockFn()).toBe(2);
+    expect(mockFn()).toBe(1);
+  });
+
   test('mockImplementation resets the mock', () => {
     const fn = jest.fn();
     expect(fn()).toBeUndefined();

packages/jest-mock/src/index.ts

@@ -71,8 +71,6 @@ type MockFunctionState<T, Y extends Array<unknown>> = {
 };
 
 type MockFunctionConfig = {
-  isReturnValueLastSet: boolean;
-  defaultReturnValue: unknown;
   mockImpl: Function | undefined;
   mockName: string;
   specificReturnValues: Array<unknown>;
@@ -456,8 +454,6 @@ class ModuleMockerClass {
 
   private _defaultMockConfig(): MockFunctionConfig {
     return {
-      defaultReturnValue: undefined,
-      isReturnValueLastSet: false,
       mockImpl: undefined,
       mockName: 'jest.fn()',
       specificMockImpls: [],
@@ -586,40 +582,22 @@ class ModuleMockerClass {
               return mockImpl && mockImpl.apply(this, arguments);
             }
 
-            const returnValue = mockConfig.defaultReturnValue;
-            // If return value is last set, either specific or default, i.e.
-            // mockReturnValueOnce()/mockReturnValue() is called and no
-            // mockImplementationOnce()/mockImplementation() is called after
-            // that.
-            // use the set return value.
-            if (mockConfig.specificReturnValues.length) {
-              return mockConfig.specificReturnValues.shift();
-            }
-
-            if (mockConfig.isReturnValueLastSet) {
-              return mockConfig.defaultReturnValue;
-            }
-
             // If mockImplementationOnce()/mockImplementation() is last set,
             // or specific return values are used up, use the mock
             // implementation.
-            let specificMockImpl;
-            if (returnValue === undefined) {
-              specificMockImpl = mockConfig.specificMockImpls.shift();
-              if (specificMockImpl === undefined) {
-                specificMockImpl = mockConfig.mockImpl;
-              }
-              if (specificMockImpl) {
-                return specificMockImpl.apply(this, arguments);
-              }
+            let specificMockImpl = mockConfig.specificMockImpls.shift();
+            if (specificMockImpl === undefined) {
+              specificMockImpl = mockConfig.mockImpl;
+            }
+            if (specificMockImpl) {
+              return specificMockImpl.apply(this, arguments);
             }
-
             // Otherwise use prototype implementation
-            if (returnValue === undefined && f._protoImpl) {
+            if (f._protoImpl) {
               return f._protoImpl.apply(this, arguments);
             }
 
-            return returnValue;
+            return undefined;
           })();
         } catch (error) {
           // Store the thrown error so we can record it, then re-throw it.
@@ -675,26 +653,19 @@ class ModuleMockerClass {
         return restore ? restore() : undefined;
       };
 
-      f.mockReturnValueOnce = (value: T) => {
+      f.mockReturnValueOnce = (value: T) =>
         // next function call will return this value or default return value
-        const mockConfig = this._ensureMockConfig(f);
-        mockConfig.specificReturnValues.push(value);
-        return f;
-      };
+        f.mockImplementationOnce(() => value);
 
       f.mockResolvedValueOnce = (value: T) =>
         f.mockImplementationOnce(() => Promise.resolve(value));
 
       f.mockRejectedValueOnce = (value: T) =>
         f.mockImplementationOnce(() => Promise.reject(value));
 
-      f.mockReturnValue = (value: T) => {
+      f.mockReturnValue = (value: T) =>
         // next function call will return specified return value or this one
-        const mockConfig = this._ensureMockConfig(f);
-        mockConfig.isReturnValueLastSet = true;
-        mockConfig.defaultReturnValue = value;
-        return f;
-      };
+        f.mockImplementation(() => value);
 
       f.mockResolvedValue = (value: T) =>
         f.mockImplementation(() => Promise.resolve(value));
@@ -708,7 +679,6 @@ class ModuleMockerClass {
         // next function call will use this mock implementation return value
         // or default mock implementation return value
         const mockConfig = this._ensureMockConfig(f);
-        mockConfig.isReturnValueLastSet = false;
         mockConfig.specificMockImpls.push(fn);
         return f;
       };
@@ -718,8 +688,6 @@ class ModuleMockerClass {
       ): Mock<T, Y> => {
         // next function call will use mock implementation return value
         const mockConfig = this._ensureMockConfig(f);
-        mockConfig.isReturnValueLastSet = false;
-        mockConfig.defaultReturnValue = undefined;
         mockConfig.mockImpl = fn;
         return f;
       };