chore(transformer): Move overload tests into its own file nested under method

Author: martinjlowm

test/transformer/descriptor/methods/methods.test.ts

@@ -58,22 +58,6 @@ describe('for methods', () => {
     });
   });
 
-  describe('for interface call signature with overload', () => {
-    interface InterfaceWithCallSignature {
-      (a: number): number;
-      (a: string): string;
-      b: string;
-    }
-
-    it('should only consider the first signature declaration', () => {
-      const properties: InterfaceWithCallSignature = createMock<InterfaceWithCallSignature>();
-      expect(properties(2)).toBe(0);
-      // @ts-ignore
-      expect(properties('2')).toBe(0);
-      expect(properties.b).toBe('');
-    });
-  });
-
   describe('for interface call signature with recursive', () => {
     interface InterfaceWithCallSignature<T>  {
       (a: number): InterfaceWithCallSignature<T>;
@@ -99,12 +83,6 @@ describe('for methods', () => {
       b: string;
     }
 
-    interface InterfaceWithConstructSignatureOverload {
-      new (a: number): { a: number };
-      new (b: string): { b: string };
-      new (): { c: Date };
-    }
-
     it('should set the constructor and properties', () => {
       const properties: InterfaceWithConstructSignature = createMock<InterfaceWithConstructSignature>();
       expect(new properties(2).a).toBe(0);
@@ -117,14 +95,6 @@ describe('for methods', () => {
       expect(new properties(2).b).toBe('');
       expect(properties.b).toBe('');
     });
-
-    it('should use the overload as requested by input', () => {
-      const properties: InterfaceWithConstructSignatureOverload = createMock<InterfaceWithConstructSignatureOverload>();
-      // eslint-disable-next-line
-      expect((new properties(0)).a).toBe(0);
-      expect((new properties('')).b).toBe('');
-      expect((new properties()).c).toBeInstanceOf(Date);
-    });
   });
 
   describe('for interface construct signature', () => {

test/transformer/descriptor/methods/overloads.test.ts

@@ -0,0 +1,79 @@
+import { createMock } from 'ts-auto-mock';
+
+import {
+  exportedDeclaredOverloadedFunction,
+  // ExportedDeclaredClass,
+} from '../utils/typeQuery/typeQueryUtils';
+
+describe('for overloads', () => {
+
+  describe('for type query', () => {
+
+    it('should assign the correct function mock for literal inputs', () => {
+      const functionMock: typeof exportedDeclaredOverloadedFunction = createMock<typeof exportedDeclaredOverloadedFunction>();
+
+      // eslint-disable-next-line
+      const expectations = [
+        ['', 0, false],
+        [false, '', 0],
+        [0, false, ''],
+        [false, false, false],
+        [''],
+        [false],
+        [0],
+      ];
+
+      for (const args of expectations) {
+        // eslint-disable-next-line
+        const [first] = args;
+
+        // @ts-ignore
+        expect(functionMock(...args)).toEqual(first);
+      }
+    });
+
+    // FIXME: Support more than just literals
+    // it('should assign the correct function mock for mockable inputs', () => {
+    //   const classMock: typeof ExportedDeclaredClass = createMock<typeof ExportedDeclaredClass>();
+
+    //   const functionMock: typeof exportedDeclaredOverloadedFunction = createMock<typeof exportedDeclaredOverloadedFunction>();
+
+    //   expect(functionMock(new classMock())).toBeInstanceOf(ExportedDeclaredClass);
+    // });
+
+  });
+
+  describe('for interface', () => {
+    describe('for construct signature', () => {
+      interface InterfaceWithConstructSignatureOverload {
+        new (a: number): { a: number };
+        new (b: string): { b: string };
+        new (): { c: Date };
+      }
+
+      it('should use the correct signature as requested by input', () => {
+        const properties: InterfaceWithConstructSignatureOverload = createMock<InterfaceWithConstructSignatureOverload>();
+        expect((new properties(0)).a).toBe(0);
+        expect((new properties('')).b).toBe('');
+        // FIXME: Enable after Date PR
+        // expect((new properties()).c).toBeInstanceOf(Date);
+      });
+    });
+  });
+
+  describe('call signature', () => {
+    interface InterfaceWithCallSignature {
+      (a: number): number;
+      (a: string): string;
+      b: string;
+    }
+
+    it('should consider all signature declarations and properties', () => {
+      const properties: InterfaceWithCallSignature = createMock<InterfaceWithCallSignature>();
+      expect(properties(2)).toBe(0);
+      expect(properties('2')).toBe('');
+      expect(properties.b).toBe('');
+    });
+  });
+
+});

test/transformer/descriptor/typeQuery/typeQuery.test.ts

@@ -6,7 +6,6 @@ import {
   ExportedClass,
   ExportedDeclaredClass,
   exportedDeclaredFunction,
-  exportedDeclaredOverloadedFunction,
   ExportedEnum,
   exportedFunction,
   WrapExportedClass,
@@ -42,27 +41,6 @@ describe('typeQuery', () => {
       expect(functionMock()).toEqual('');
     });
 
-    it('should assign the correct function mock for an imported and overloaded function declaration', () => {
-      const functionMock: typeof exportedDeclaredOverloadedFunction = createMock<typeof exportedDeclaredOverloadedFunction>();
-
-      // eslint-disable-next-line
-      const expectations = [
-        { args: ['', 0, false], returnValue: '' },
-        { args: [false, '', 0], returnValue: false },
-        { args: [0, false, ''], returnValue: 0 },
-        { args: [false, false, false], returnValue: false },
-        { args: [''], returnValue: '' },
-        { args: [false], returnValue: false },
-        { args: [0], returnValue: 0 },
-      ];
-
-      for (const { args, returnValue } of expectations) {
-        // eslint-disable-next-line
-        const [first, second, third] = args;
-        expect(functionMock(first, second, third)).toEqual(returnValue);
-      }
-    });
-
     it('should assign the function mock for an imported function declaration with body', () => {
       const functionMock: typeof exportedFunction = createMock<typeof exportedFunction>();