fix: mocking of getters/setters on automatically mocked classes

packages/jest-mock/src/__tests__/__fixtures__/class-mocks-types.ts

@@ -52,3 +52,16 @@ export default class SuperTestClass {
 }
 
 export class TestClass extends SuperTestClass {}
+
+export function testFunction1() {
+  return 'testFunction1';
+}
+
+function testFunction() {
+  return 'testFunction2';
+}
+export const testFunction2 = testFunction;
+
+export const testFunction3 = () => {
+  return 'testFunction3';
+};

packages/jest-mock/src/__tests__/class-mocks-single-import.test.ts

@@ -6,9 +6,32 @@
  *
  */
 
-import SuperTestClass, {TestClass} from './__fixtures__/class-mocks-types';
+import SuperTestClass, * as testTypes from './__fixtures__/class-mocks-types';
 jest.mock('./__fixtures__/class-mocks-types');
 
+describe('Testing the mocking of exported functions', () => {
+  it('can mock a directly exported function', () => {
+    jest.spyOn(testTypes, 'testFunction1').mockImplementation(() => {
+      return 'mockTestFunction';
+    });
+    expect(testTypes.testFunction1()).toBe('mockTestFunction');
+  });
+
+  it('can mock an indirectly exported function', () => {
+    jest.spyOn(testTypes, 'testFunction2').mockImplementation(() => {
+      return 'mockTestFunction';
+    });
+    expect(testTypes.testFunction2()).toBe('mockTestFunction');
+  });
+
+  it('can mock an indirectly exported anonymous function', () => {
+    jest.spyOn(testTypes, 'testFunction3').mockImplementation(() => {
+      return 'mockTestFunction';
+    });
+    expect(testTypes.testFunction3()).toBe('mockTestFunction');
+  });
+});
+
 describe('Testing the mocking of a class hierarchy defined in a single import', () => {
   it('can call an instance method - Auto-mocked class', () => {
     const mockTestMethod = jest
@@ -25,11 +48,11 @@ describe('Testing the mocking of a class hierarchy defined in a single import',
 
   it('can call a superclass instance method - Auto-mocked class', () => {
     const mockTestMethod = jest
-      .spyOn(TestClass.prototype, 'testMethod')
+      .spyOn(testTypes.TestClass.prototype, 'testMethod')
       .mockImplementation(() => {
         return 'mockTestMethod';
       });
-    const testClassInstance = new TestClass();
+    const testClassInstance = new testTypes.TestClass();
     expect(testClassInstance.testMethod()).toBe('mockTestMethod');
     expect(mockTestMethod).toHaveBeenCalledTimes(1);
   });
@@ -49,11 +72,11 @@ describe('Testing the mocking of a class hierarchy defined in a single import',
 
   it('can call a superclass instance method named "get" - Auto-mocked class', () => {
     const mockTestMethod = jest
-      .spyOn(TestClass.prototype, 'get')
+      .spyOn(testTypes.TestClass.prototype, 'get')
       .mockImplementation(() => {
         return 'mockTestMethod';
       });
-    const testClassInstance = new TestClass();
+    const testClassInstance = new testTypes.TestClass();
     expect(testClassInstance.get()).toBe('mockTestMethod');
     expect(mockTestMethod).toHaveBeenCalledTimes(1);
 
@@ -75,11 +98,11 @@ describe('Testing the mocking of a class hierarchy defined in a single import',
 
   it('can call a superclass instance method named "set" - Auto-mocked class', () => {
     const mockTestMethod = jest
-      .spyOn(TestClass.prototype, 'set')
+      .spyOn(testTypes.TestClass.prototype, 'set')
       .mockImplementation(() => {
         return 'mockTestMethod';
       });
-    const testClassInstance = new TestClass();
+    const testClassInstance = new testTypes.TestClass();
     expect(testClassInstance.set()).toBe('mockTestMethod');
     expect(mockTestMethod).toHaveBeenCalledTimes(1);
 
@@ -101,11 +124,11 @@ describe('Testing the mocking of a class hierarchy defined in a single import',
 
   it('can read a value from a superclass instance getter - Auto-mocked class', () => {
     const mockTestMethod = jest
-      .spyOn(TestClass.prototype, 'testAccessor', 'get')
+      .spyOn(testTypes.TestClass.prototype, 'testAccessor', 'get')
       .mockImplementation(() => {
         return 'mockTestAccessor';
       });
-    const testClassInstance = new TestClass();
+    const testClassInstance = new testTypes.TestClass();
     expect(testClassInstance.testAccessor).toBe('mockTestAccessor');
     expect(mockTestMethod).toHaveBeenCalledTimes(1);
   });
@@ -125,11 +148,11 @@ describe('Testing the mocking of a class hierarchy defined in a single import',
 
   it('can write a value to a superclass instance setter - Auto-mocked class', () => {
     const mockTestMethod = jest
-      .spyOn(TestClass.prototype, 'testAccessor', 'set')
+      .spyOn(testTypes.TestClass.prototype, 'testAccessor', 'set')
       .mockImplementation((_x: string) => {
         return () => {};
       });
-    const testClassInstance = new TestClass();
+    const testClassInstance = new testTypes.TestClass();
     testClassInstance.testAccessor = '';
     expect(mockTestMethod).toHaveBeenCalledTimes(1);
   });
@@ -148,11 +171,11 @@ describe('Testing the mocking of a class hierarchy defined in a single import',
 
   it('can call a superclass static method - Auto-mocked class', () => {
     const mockTestMethod = jest
-      .spyOn(TestClass, 'staticTestMethod')
+      .spyOn(testTypes.TestClass, 'staticTestMethod')
       .mockImplementation(() => {
         return 'mockTestMethod';
       });
-    expect(TestClass.staticTestMethod()).toBe('mockTestMethod');
+    expect(testTypes.TestClass.staticTestMethod()).toBe('mockTestMethod');
     expect(mockTestMethod).toHaveBeenCalledTimes(1);
   });
 
@@ -170,11 +193,11 @@ describe('Testing the mocking of a class hierarchy defined in a single import',
 
   it('can call a superclass static method named "get" - Auto-mocked class', () => {
     const mockTestMethod = jest
-      .spyOn(TestClass, 'get')
+      .spyOn(testTypes.TestClass, 'get')
       .mockImplementation(() => {
         return 'mockTestMethod';
       });
-    expect(TestClass.get()).toBe('mockTestMethod');
+    expect(testTypes.TestClass.get()).toBe('mockTestMethod');
     expect(mockTestMethod).toHaveBeenCalledTimes(1);
 
     mockTestMethod.mockClear();
@@ -194,11 +217,11 @@ describe('Testing the mocking of a class hierarchy defined in a single import',
 
   it('can call a superclass static method named "set" - Auto-mocked class', () => {
     const mockTestMethod = jest
-      .spyOn(TestClass, 'set')
+      .spyOn(testTypes.TestClass, 'set')
       .mockImplementation(() => {
         return 'mockTestMethod';
       });
-    expect(TestClass.set()).toBe('mockTestMethod');
+    expect(testTypes.TestClass.set()).toBe('mockTestMethod');
     expect(mockTestMethod).toHaveBeenCalledTimes(1);
 
     mockTestMethod.mockClear();
@@ -218,11 +241,13 @@ describe('Testing the mocking of a class hierarchy defined in a single import',
 
   it('can read a value from a superclass static getter - Auto-mocked class', () => {
     const mockTestMethod = jest
-      .spyOn(TestClass, 'staticTestAccessor', 'get')
+      .spyOn(testTypes.TestClass, 'staticTestAccessor', 'get')
       .mockImplementation(() => {
         return 'mockStaticTestAccessor';
       });
-    expect(TestClass.staticTestAccessor).toBe('mockStaticTestAccessor');
+    expect(testTypes.TestClass.staticTestAccessor).toBe(
+      'mockStaticTestAccessor',
+    );
     expect(mockTestMethod).toHaveBeenCalledTimes(1);
   });
 
@@ -240,11 +265,11 @@ describe('Testing the mocking of a class hierarchy defined in a single import',
 
   it('can write a value to a superclass static setter - Auto-mocked class', () => {
     const mockTestMethod = jest
-      .spyOn(TestClass, 'staticTestAccessor', 'set')
+      .spyOn(testTypes.TestClass, 'staticTestAccessor', 'set')
       .mockImplementation((_x: string) => {
         return () => {};
       });
-    TestClass.staticTestAccessor = '';
+    testTypes.TestClass.staticTestAccessor = '';
     expect(mockTestMethod).toHaveBeenCalledTimes(1);
   });
 });