add support for multiple declarations functions for types and values

config/test/webpack.js

@@ -25,7 +25,7 @@ module.exports = function (debug, disableCache) {
                     options: {
                         getCustomTransformers: (program) => ({
                             before: [transformer.default(program, {
-                                debug: debug ? 'file' : false,
+                                debug: debug ? debug : false,
                                 cacheBetweenTests: disableCache !== 'true'
                             })]
                         })

src/transformer/descriptor/descriptor.ts

@@ -117,6 +117,8 @@ export function GetDescriptor(node: ts.Node, scope: Scope): ts.Expression {
         case ts.SyntaxKind.IndexedAccessType:
             return GetIndexedAccessTypeDescriptor(node as ts.IndexedAccessTypeNode, scope);
         case ts.SyntaxKind.BooleanKeyword:
+        case ts.SyntaxKind.TypePredicate:
+        case ts.SyntaxKind.FirstTypeNode:
             return GetBooleanDescriptor();
         case ts.SyntaxKind.ObjectKeyword:
             return GetMockPropertiesFromSymbol([], [], scope);

src/transformer/descriptor/helper/helper.ts

@@ -29,6 +29,16 @@ export namespace TypescriptHelper {
         return declaration;
     }
 
+    export function GetConcreteDeclarationFromSymbol(symbol: ts.Symbol): ts.Declaration {
+        const declaration: ts.Declaration = symbol.declarations[0];
+
+        if (ts.isImportSpecifier(declaration) || ts.isImportEqualsDeclaration(declaration)) {
+            return GetConcreteDeclarationForImport(declaration);
+        }
+
+        return declaration;
+    }
+
     export function GetDeclarationForImport(node: ts.ImportClause | ts.ImportSpecifier | ts.ImportEqualsDeclaration): ts.Declaration {
         const typeChecker: ts.TypeChecker = TypeChecker();
         const symbol: ts.Symbol = typeChecker.getSymbolAtLocation(node.name);
@@ -37,6 +47,14 @@ export namespace TypescriptHelper {
         return GetFirstValidDeclaration(originalSymbol.declarations);
     }
 
+    export function GetConcreteDeclarationForImport(node: ts.ImportClause | ts.ImportSpecifier | ts.ImportEqualsDeclaration): ts.Declaration {
+        const typeChecker: ts.TypeChecker = TypeChecker();
+        const symbol: ts.Symbol = typeChecker.getSymbolAtLocation(node.name);
+        const originalSymbol: ts.Symbol = typeChecker.getAliasedSymbol(symbol);
+
+        return originalSymbol.declarations[0];
+    }
+
     export function GetParameterOfNode(node: ts.EntityName): ts.NodeArray<ts.TypeParameterDeclaration> {
         const declaration: ts.Declaration = GetDeclarationFromNode(node);
 
@@ -73,7 +91,7 @@ export namespace TypescriptHelper {
 
     function GetFirstValidDeclaration(declarations: ts.Declaration[]): ts.Declaration {
         return declarations.find((declaration: ts.Declaration) => {
-            return !ts.isVariableDeclaration(declaration);
+            return !ts.isVariableDeclaration(declaration) && !ts.isFunctionDeclaration(declaration);
         }) || declarations[0];
     }
 

src/transformer/descriptor/mock/mockCall.ts

@@ -1,15 +1,13 @@
 import * as ts from 'typescript';
 import { TypescriptCreator } from '../../helper/creator';
-import { GetMockInternalValuesName, GetMockObjectReturnValueName } from './mockDeclarationName';
+import { MockIdentifierInternalValues, MockIdentifierObjectReturnValue } from '../../mockIdentifier/mockIdentifier';
 import { GetMockMarkerProperty, Property } from './mockMarker';
 
 export function GetMockCall(properties: ts.PropertyAssignment[], signature: ts.Expression): ts.CallExpression {
-    const mockObjectReturnValueName: ts.Identifier = GetMockObjectReturnValueName();
-    const mockInternalValuesName: ts.Identifier = GetMockInternalValuesName();
-
+    const mockObjectReturnValueName: ts.Identifier = MockIdentifierObjectReturnValue;
     const statements: ts.Statement[] = [
         ts.createVariableStatement([], [
-            TypescriptCreator.createVariableDeclaration(mockInternalValuesName, ts.createObjectLiteral()),
+            TypescriptCreator.createVariableDeclaration(MockIdentifierInternalValues, ts.createObjectLiteral()),
             TypescriptCreator.createVariableDeclaration(mockObjectReturnValueName, ts.createObjectLiteral()),
         ]),
     ];

src/transformer/descriptor/mock/mockProperty.ts

@@ -1,20 +1,18 @@
 import * as ts from 'typescript';
 import { TypescriptCreator } from '../../helper/creator';
+import { MockIdentifierInternalValues, MockIdentifierSetParameterName } from '../../mockIdentifier/mockIdentifier';
 import { Scope } from '../../scope/scope';
 import { GetDescriptor } from '../descriptor';
 import { TypescriptHelper } from '../helper/helper';
-import { GetMockInternalValuesName, GetMockSetParameterName } from './mockDeclarationName';
 import { PropertyLike } from './propertyLike';
 
 export function GetMockProperty(member: PropertyLike, scope: Scope): ts.PropertyAssignment {
     const descriptor: ts.Expression = GetDescriptor(member, scope);
 
     const propertyName: string = TypescriptHelper.GetStringPropertyName(member.name);
 
-    const declarations: ts.Identifier = GetMockInternalValuesName();
-
-    const variableDeclarationName: ts.ElementAccessExpression = ts.createElementAccess(declarations, ts.createStringLiteral(propertyName));
-    const setVariableParameterName: ts.Identifier = GetMockSetParameterName();
+    const variableDeclarationName: ts.ElementAccessExpression = ts.createElementAccess(MockIdentifierInternalValues, ts.createStringLiteral(propertyName));
+    const setVariableParameterName: ts.Identifier = MockIdentifierSetParameterName;
 
     const expressionGetAssignment: ts.BinaryExpression = ts.createBinary(variableDeclarationName, ts.SyntaxKind.EqualsToken, descriptor);
 

src/transformer/descriptor/typeParameter/typeParameter.ts

@@ -1,7 +1,7 @@
 import * as ts from 'typescript';
 import { TypescriptCreator } from '../../helper/creator';
 import { MockDefiner } from '../../mockDefiner/mockDefiner';
-import { MockGenericParameter, MockGenericParameterIds, MockGenericParameterValue } from '../../mockGeneric/mockGenericParameter';
+import { MockIdentifierGenericParameter, MockIdentifierGenericParameterIds, MockIdentifierGenericParameterValue } from '../../mockIdentifier/mockIdentifier';
 import { Scope } from '../../scope/scope';
 import { TypeChecker } from '../../typeChecker/typeChecker';
 import { GetDescriptor } from '../descriptor';
@@ -43,7 +43,7 @@ function createFunctionToAccessToGenericValue(key: string, descriptor: ts.Expres
 function createFindGeneric(genericKey: string): ts.CallExpression {
     return ts.createCall(
         ts.createPropertyAccess(
-            MockGenericParameter,
+            MockIdentifierGenericParameter,
             ts.createIdentifier('find'),
         ),
         undefined,
@@ -53,7 +53,7 @@ function createFindGeneric(genericKey: string): ts.CallExpression {
                     ts.createPropertyAccess(
                         ts.createPropertyAccess(
                             ts.createIdentifier('generic'),
-                            MockGenericParameterIds,
+                            MockIdentifierGenericParameterIds,
                         ),
                         ts.createIdentifier('indexOf'),
                     ),
@@ -89,7 +89,7 @@ function getValueFromGenericIfExist(): ts.IfStatement {
             [ts.createReturn(ts.createCall(
                 ts.createPropertyAccess(
                     ts.createIdentifier('generic'),
-                    MockGenericParameterValue,
+                    MockIdentifierGenericParameterValue,
                 ),
                 undefined,
                 [],

src/transformer/descriptor/typeQuery/typeQuery.ts

@@ -93,5 +93,5 @@ function getTypeQueryDeclarationFromSymbol(symbol: ts.Symbol): ts.NamedDeclarati
         return declaration;
     }
 
-    return TypescriptHelper.GetDeclarationFromSymbol(symbol);
+    return TypescriptHelper.GetConcreteDeclarationFromSymbol(symbol);
 }

src/transformer/genericDeclaration/genericDeclaration.ts

@@ -2,7 +2,7 @@ import * as ts from 'typescript';
 import { GetDescriptor } from '../descriptor/descriptor';
 import { TypescriptHelper } from '../descriptor/helper/helper';
 import { TypescriptCreator } from '../helper/creator';
-import { MockGenericParameterIds, MockGenericParameterValue } from '../mockGeneric/mockGenericParameter';
+import { MockIdentifierGenericParameterIds, MockIdentifierGenericParameterValue } from '../mockIdentifier/mockIdentifier';
 import { Scope } from '../scope/scope';
 import { IGenericDeclaration } from './genericDeclaration.interface';
 import { GenericDeclarationSupported } from './genericDeclarationSupported';
@@ -110,7 +110,7 @@ export function GenericDeclaration(scope: Scope): IGenericDeclaration {
                 return ts.createObjectLiteral(
                     [
                         ts.createPropertyAssignment(
-                            MockGenericParameterIds,
+                            MockIdentifierGenericParameterIds,
                             ts.createArrayLiteral(
                                 s.ids.map((arr: string) => {
                                     return ts.createStringLiteral(arr);
@@ -119,7 +119,7 @@ export function GenericDeclaration(scope: Scope): IGenericDeclaration {
                             ),
                         ),
                         ts.createPropertyAssignment(
-                            MockGenericParameterValue,
+                            MockIdentifierGenericParameterValue,
                             s.value,
                         ),
                     ],

src/transformer/mock/mock.ts

@@ -3,7 +3,6 @@ import { Logger } from '../../logger/logger';
 import { ArrayHelper } from '../array/array';
 import { GetDescriptor } from '../descriptor/descriptor';
 import { TypescriptHelper } from '../descriptor/helper/helper';
-import { TypescriptCreator } from '../helper/creator';
 import { getMockMergeExpression, getMockMergeIteratorExpression } from '../mergeExpression/mergeExpression';
 import { MockDefiner } from '../mockDefiner/mockDefiner';
 import { Scope } from '../scope/scope';

src/transformer/mockDefiner/mockDefiner.ts

@@ -5,7 +5,7 @@ import { GetProperties } from '../descriptor/properties/properties';
 import { GetTypeofEnumDescriptor } from '../descriptor/typeQuery/enumTypeQuery';
 import { TypescriptCreator } from '../helper/creator';
 import { createImportOnIdentifier } from '../helper/import';
-import { MockGenericParameter } from '../mockGeneric/mockGenericParameter';
+import { MockIdentifierGenericParameter } from '../mockIdentifier/mockIdentifier';
 import { Scope } from '../scope/scope';
 import { DeclarationCache } from './cache/declarationCache';
 import { DeclarationListCache } from './cache/declarationListCache';
@@ -312,6 +312,6 @@ export class MockDefiner {
     }
 
     private _getMockGenericParameter(): ts.ParameterDeclaration {
-        return ts.createParameter([], [], undefined, MockGenericParameter);
+        return ts.createParameter([], [], undefined, MockIdentifierGenericParameter);
     }
 }

src/transformer/mockFactoryCall/mockFactoryCall.ts

@@ -4,7 +4,7 @@ import { GenericDeclaration } from '../genericDeclaration/genericDeclaration';
 import { IGenericDeclaration } from '../genericDeclaration/genericDeclaration.interface';
 import { GenericDeclarationSupported } from '../genericDeclaration/genericDeclarationSupported';
 import { MockDefiner } from '../mockDefiner/mockDefiner';
-import { MockGenericParameter } from '../mockGeneric/mockGenericParameter';
+import { MockIdentifierGenericParameter } from '../mockIdentifier/mockIdentifier';
 import { Scope } from '../scope/scope';
 
 export function GetMockFactoryCall(typeReferenceNode: ts.TypeReferenceNode, scope: Scope): ts.Expression {
@@ -63,7 +63,7 @@ export function GetMockFactoryCallForThis(mockKey: string): ts.Expression {
     return ts.createCall(
       mockFactoryCall,
       [],
-      [MockGenericParameter],
+      [MockIdentifierGenericParameter],
     );
 }
 

src/transformer/mockIdentifier/mockIdentifier.ts

@@ -0,0 +1,8 @@
+import * as ts from 'typescript';
+
+export const MockIdentifierGenericParameter: ts.Identifier = ts.createIdentifier('t');
+export const MockIdentifierGenericParameterIds: ts.Identifier = ts.createIdentifier('i');
+export const MockIdentifierGenericParameterValue: ts.Identifier = ts.createIdentifier('w');
+export const MockIdentifierInternalValues: ts.Identifier = ts.createIdentifier('d');
+export const MockIdentifierObjectReturnValue: ts.Identifier = ts.createIdentifier('m');
+export const MockIdentifierSetParameterName: ts.Identifier = ts.createIdentifier('v');

src/transformer/printNode.ts

@@ -0,0 +1,18 @@
+import * as ts from 'typescript';
+import { Logger } from '../logger/logger';
+import { ILogger } from '../logger/logger.interface';
+
+export function PrintNode(node: ts.Node): void {
+    const PrintNodeLogger: ILogger = Logger('PrintNode');
+
+    const resultFile: ts.SourceFile = ts.createSourceFile('someFileName.ts', '', ts.ScriptTarget.Latest, /*setParentNodes*/ false, ts.ScriptKind.TS);
+    const printer: ts.Printer = ts.createPrinter({ newLine: ts.NewLineKind.LineFeed });
+
+    try {
+        const result: string = printer.printNode(ts.EmitHint.Unspecified, node, resultFile);
+        PrintNodeLogger.info(result);
+    } catch (e) {
+        PrintNodeLogger.warning('There was an error printing the node');
+    }
+
+}

test/playground/playground.test.ts

@@ -1,5 +1,4 @@
-import { createMock, registerMock } from 'ts-auto-mock';
-import { MyEnum } from './enums';
+import { createMock } from 'ts-auto-mock';
 
 /*
  USE THIS FILE ONLY FOR TESTING NEW IMPLEMENTATION
@@ -10,13 +9,10 @@ import { MyEnum } from './enums';
  */
 
 it('should work', () => {
-  interface A {
-    a: string;
-  }
-  const enumm2: typeof MyEnum = createMock<typeof MyEnum>();
-  expect(createMock<A>().a).toBe("ok");
+    interface A {
+        a: string;
+    }
 
-  expect(enumm2.A).toEqual(0);
-
-  expect(createMock<A>().a).toBe("ok");
+    const type: A = createMock<A>();
+    expect(type).toBeDefined();
 });

test/transformer/descriptor/declarations/declarations.test.ts

@@ -135,6 +135,23 @@ describe('declarations', () => {
             });
         });
 
+        describe('function and interface', () => {
+            // @ts-ignore
+            interface AAA {
+                b: number
+            }
+
+            function AAA(): AAA {
+                // @ts-ignore
+                return { a: 'ss' };
+            }
+
+            it('should return the properties from the interface', () => {
+                const properties: AAA = createMock<AAA>();
+                expect(properties.b).toBe(0);
+            });
+        });
+
         describe('interface imported', () => {
             it('should ignore variables declaration', () => {
                 const properties: MultipleInterfaceDeclaration = createMock<MultipleInterfaceDeclaration>();

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

@@ -58,6 +58,24 @@ describe('typeQuery', () => {
 
             expect(functionMock).toBeUndefined();
         });
+
+        it('should return correct properties with multiple declarations', () => {
+            function MultipleDeclaration(): MultipleDeclaration {
+                // @ts-ignore
+                return { a: 's'};
+            }
+
+            interface MultipleDeclaration {
+                b: string;
+            }
+
+            const functionMock: typeof MultipleDeclaration = createMock<typeof MultipleDeclaration>();
+
+            // @ts-ignore
+            expect(functionMock()).toEqual({
+                b: '',
+            });
+        });
     });
 
     describe('for class', () => {
@@ -102,7 +120,7 @@ describe('typeQuery', () => {
         it('should assign the enum to the mock', () => {
             enum Enum {
                 A,
-                B = 'some'
+                B = 'some',
             }
 
             const enumMock: typeof Enum = createMock<typeof Enum>();