feat(intersectionsfunction): add support for function intersections

src/transformer/descriptor/descriptor.ts

@@ -26,6 +26,7 @@ import { GetMockPropertiesFromSymbol } from './mock/mockProperties';
 import { GetNullDescriptor } from './null/null';
 import { GetNumberDescriptor } from './number/number';
 import { GetObjectLiteralDescriptor } from './objectLiteral/objectLiteral';
+import { GetParenthesizedDescriptor } from './parenthesized/parenthesized';
 import { GetPropertyDescriptor } from './property/propertySignature';
 import { GetStringDescriptor } from './string/string';
 import { GetTypeAliasDescriptor } from './typeAlias/typeAlias';
@@ -94,6 +95,8 @@ export function GetDescriptor(node: ts.Node, scope: Scope): ts.Expression {
             return GetEnumDeclarationDescriptor(node as ts.EnumDeclaration);
         case ts.SyntaxKind.MappedType:
             return GetMappedDescriptor(node as ts.MappedTypeNode, scope);
+        case ts.SyntaxKind.ParenthesizedType:
+            return GetParenthesizedDescriptor(node as ts.ParenthesizedTypeNode, scope);
         case ts.SyntaxKind.ArrayType:
         case ts.SyntaxKind.TupleType:
             return GetArrayDescriptor();

src/transformer/descriptor/parenthesized/parenthesized.ts

@@ -0,0 +1,7 @@
+import * as ts from 'typescript';
+import { Scope } from '../../scope/scope';
+import { GetProperties } from '../properties/properties';
+
+export function GetParenthesizedDescriptor(node: ts.ParenthesizedTypeNode, scope: Scope): ts.Expression {
+    return GetProperties(node.type, scope);
+}

src/transformer/descriptor/properties/properties.ts

@@ -9,8 +9,8 @@ export function GetProperties(node: ts.Node, scope: Scope): ts.Expression {
     const type: ts.Type = typeChecker.getTypeAtLocation(node);
     const symbols: ts.Symbol[] = typeChecker.getPropertiesOfType(type);
 
-    if (!symbols.length) {
-        return GetPropertiesFromMembers(node as ts.TypeLiteralNode, scope);
+    if (!symbols.length && ts.isTypeLiteralNode(node)) {
+        return GetPropertiesFromMembers(node, scope);
     } else {
         const signatures: Array<ts.Signature> = [];
 

src/transformer/descriptor/type/type.ts

@@ -60,5 +60,9 @@ export function GetType(node: ts.Node, scope: Scope): ts.Node {
         return GetType(node.type, scope);
     }
 
+    if (ts.isParenthesizedTypeNode(node)) {
+        return GetType(node.type, scope);
+    }
+
     return node;
 }

test/transformer/descriptor/intersection/functions.test.ts

@@ -0,0 +1,17 @@
+import { createMock } from 'ts-auto-mock';
+
+describe('functions', () => {
+    it('should assign the first function', () => {
+        type A = () => number;
+
+        type B = () => string;
+
+        interface C {
+            prop: A & B;
+        }
+
+        const mock: C = createMock<C>();
+
+        expect(mock.prop()).toBe(0);
+    });
+});

test/transformer/descriptor/intersection/interfaceWithoutProperties.test.ts

@@ -0,0 +1,23 @@
+import { createMock } from 'ts-auto-mock';
+
+describe('interface without properties and with methods', () => {
+    it('should assign the first method', () => {
+        interface A {
+            // tslint:disable-next-line
+            (): string;
+        }
+
+        interface B {
+            // tslint:disable-next-line
+            (): number;
+        }
+
+        interface C {
+            prop: A & B;
+        }
+
+        const mock: C = createMock<C>();
+
+        expect(mock.prop()).toBe('');
+    });
+});

test/transformer/descriptor/parenthesized/intersection.test.ts

@@ -0,0 +1,32 @@
+import { createMock } from 'ts-auto-mock';
+
+describe('parenthesized intersection ', () => {
+    it('should return undefined for primitive and object ', () => {
+        interface B {}
+
+        type A = (string) & B;
+
+        expect(createMock<A>()).toBeUndefined();
+    });
+
+    it('should intersect correctly for function and object ', () => {
+        interface B {
+            prop: number;
+        }
+
+        type A = (() => string) & B;
+
+        const mock: A = createMock<A>();
+        expect(mock()).toBe('');
+        expect(mock.prop).toBe(0);
+    });
+
+    it('should return the correct type for objects intersections', () => {
+        type A = ({a: string} & {b: number});
+
+        const mock: A = createMock<A>();
+
+        expect(mock.a).toBe('');
+        expect(mock.b).toBe(0);
+    });
+});

test/transformer/descriptor/parenthesized/type.test.ts

@@ -0,0 +1,19 @@
+import { createMock } from 'ts-auto-mock';
+
+describe('parenthesized type ', () => {
+    it('should return the correct type for functions', () => {
+        type A = (() => string);
+
+        const mock: A = createMock<A>();
+
+        expect(mock()).toBe('');
+    });
+
+    it('should return the correct type for objects', () => {
+        type A = ({a: string});
+
+        const mock: A = createMock<A>();
+
+        expect(mock.a).toBe('');
+    });
+});