Merge pull request #19 from regevbr/#17

add functionality to safe mock functions #17

README.md

@@ -89,11 +89,12 @@ provider.getSongs.calledWith(any()).mockReturnValue(['Saw her standing there']);
 provider.getSongs.calledWith(anyString()).mockReturnValue(['Saw her standing there']);
 
 ```
-You can also use ```calledWith()``` on its own to create a ```jest.fn()``` with the calledWith extension:
+You can also use ```mockFn()``` to create a ```jest.fn()``` with the calledWith extension:
 
 ```ts
- const fn = calledWithFn();
- fn.calledWith(1, 2).mockReturnValue(3);
+ type MyFn = (x: number, y: number) => Promise<string>;
+ const fn = mockFn<MyFn>();
+ fn.calledWith(1, 2).mockReturnValue('str');
 ```
 
 ## Clearing / Resetting Mocks

src/Mock.spec.ts

@@ -1,4 +1,4 @@
-import mock, { mockClear, mockDeep, mockReset } from './Mock';
+import mock, { mockClear, mockDeep, mockReset, mockFn } from './Mock';
 import { anyNumber } from './Matchers';
 import calledWithFn from './CalledWithFn';
 
@@ -117,9 +117,9 @@ describe('jest-mock-extended', () => {
 
     describe('calledWith', () => {
         test('can use calledWith without mock', () => {
-            const mockFn = calledWithFn();
-            mockFn.calledWith(anyNumber(), anyNumber()).mockReturnValue(3);
-            expect(mockFn(1, 2)).toBe(3);
+            const mockFunc = calledWithFn();
+            mockFunc.calledWith(anyNumber(), anyNumber()).mockReturnValue(3);
+            expect(mockFunc(1, 2)).toBe(3);
         });
 
         test('Can specify matchers', () => {
@@ -361,4 +361,21 @@ describe('jest-mock-extended', () => {
             expect(mockObj.deepProp.getNumber(1)).toBe(4);
         });
     });
+
+    describe('function mock', () => {
+        test('should mock function', async () => {
+            type MyFn = (x: number, y: number) => Promise<string>;
+            const mockFunc = mockFn<MyFn>();
+            mockFunc.mockResolvedValue(`str`);
+            const result: string = await mockFunc(1, 2);
+            expect(result).toBe(`str`);
+        });
+        test('should mock function and use calledWith', async () => {
+            type MyFn = (x: number, y: number) => Promise<string>;
+            const mockFunc = mockFn<MyFn>();
+            mockFunc.calledWith(1, 2).mockResolvedValue(`str`);
+            const result: string = await mockFunc(1, 2);
+            expect(result).toBe(`str`);
+        });
+    })
 });

src/Mock.ts

@@ -121,4 +121,13 @@ const mock = <T>(mockImplementation: DeepPartial<T> = {} as DeepPartial<T>, opts
     return overrideMockImp(mockImplementation, opts);
 };
 
+export const mockFn = <
+    T extends Function,
+    A extends any[] = T extends (...args: infer AReal) => any ? AReal : any[],
+    R = T extends (...args: any) => infer RReal ? RReal : any
+    >(): CalledWithMock<R, A> & T => {
+    // @ts-ignore
+    return calledWithFn();
+};
+
 export default mock;