Merge pull request #22 from uittorio/#20-handle-method-without-return…

…-value

make sure methods without return value will not fail the compilation

config/karma/karma.config.transformer.js

@@ -4,4 +4,4 @@ module.exports = function(config) {
     const karmaConfig = karmaBaseConfig(config, '../../test/transformer/**/*.test.ts');
 
     config.set(karmaConfig);
-};
+};

index.ts

@@ -4,4 +4,4 @@ export { MockMarker } from "./src/mockMarker/mockMarker";
 export { MockMethod } from "./src/mockMethod/mockMethod";
 export { On, AutoMockExtensionHandler } from "./src/framework/framework";
 export { createMock } from "./src/transformer/create-mock";
-export {method} from "./src/framework/methodExtension";
+export { method } from "./src/framework/methodExtension";

src/transformer/descriptor/descriptor.ts

@@ -110,4 +110,4 @@ export function GetDescriptor(node: ts.Node): ts.Expression {
 			console.log("NOT IMPLEMENTED "+ ts.SyntaxKind[node.kind]);
 			return GetNullDescriptor();
 	}
-}
+}

src/transformer/descriptor/method/method.ts

@@ -22,4 +22,4 @@ export function GetMethodDescriptor(propertyName: ts.PropertyName, returnValue:
 
     const parenthesizedExpression = ts.createParen(functionExpression);
     return ts.createCall(parenthesizedExpression, [], []);
-}
+}

src/transformer/descriptor/method/methodDeclaration.ts

@@ -13,4 +13,4 @@ export function GetMethodDeclarationDescriptor(node: ts.MethodDeclaration): ts.E
     }
 
     return GetMethodDescriptor(node.name, returnType);
-}
+}

src/transformer/descriptor/method/methodSignature.ts

@@ -1,10 +1,16 @@
 import * as ts from "typescript";
-import {GetDescriptor} from "../descriptor";
 import {GetMethodDescriptor} from "./method";
+import { GetNullDescriptor } from "../null/null";
+import { GetDescriptor } from "../descriptor";
 
-type Methods = ts.MethodSignature | ts.MethodDeclaration;
-
-export function GetMethodSignatureDescriptor(node: Methods): ts.Expression {
-    const returnType: ts.Expression = GetDescriptor(node.type);
+export function GetMethodSignatureDescriptor(node: ts.MethodSignature): ts.Expression {
+	let returnType: ts.Expression;
+
+	if (node.type) {
+		returnType = GetDescriptor(node.type);
+	} else {
+		returnType = GetNullDescriptor();
+	}
+
     return GetMethodDescriptor(node.name, returnType);
-}
+}

src/transformer/descriptor/property/cache.ts

@@ -17,4 +17,4 @@ export class PropertySignatureCache {
     public get(): ts.PropertyName {
         return this._cache || TypescriptHelper.createEmptyProperty().name;
     }
-}
+}

src/transformer/typeValidator/typeValidator.ts

@@ -15,4 +15,4 @@ export function isTypeReusable(node: ts.Node): boolean {
 
 function hasTypeArguments(node: ts.Node): boolean {
     return ts.isTypeReferenceNode(node) && !!node.typeArguments && node.typeArguments.length > 0;
-}
+}

test/framework/context.ts

@@ -5,4 +5,4 @@ MockFactory.instance.registerFactory((name: string, value: any) => {
 });
 
 const frameworkContext = require.context('./', true, /\.test\.ts$/);
-frameworkContext.keys().map(frameworkContext);
+frameworkContext.keys().map(frameworkContext);

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

@@ -4,8 +4,8 @@ describe('for methods', () => {
 	interface InterfaceReturnMethod {
 		a: string;
 	}
-
-	interface Interface {
+	
+		interface Interface {
 		a(): void;
 		b(): number;
 		c(): string;
@@ -25,14 +25,14 @@ describe('for methods', () => {
 	describe('for interface declaration', () => {
         interface Interface {
             method: () => number
-        }
-
+		}
+		
         it('should set the functions', () => {
             const properties: Interface = createMock<Interface>();
             expect(properties.method()).toBe(0);
         });
 	});
-
+	
 	describe('for declaration', () => {
 		class MyClass {
 			method(): number {
@@ -44,7 +44,7 @@ describe('for methods', () => {
 			const properties: MyClass = createMock<MyClass>();
 			expect(properties.method()).toBe(0);
 		});
-	});
+});
 
 	describe('for undeclared return value', () => {
 		class MyClass {
@@ -66,4 +66,16 @@ describe('for methods', () => {
 			expect(properties()).toBe("");
 		});
 	});
-});
+
+	describe('for an interface without return value', () => {
+		interface Interface {
+			method();
+		}
+
+		it('should return null', () => {
+			const a: Interface = createMock<Interface>();
+
+			expect(a.method()).toBeNull();
+		});
+	})
+});