a_mock 2.0.0 → 2.0.2

package/index.d.ts

@@ -0,0 +1,109 @@
+type AnyFunction = (...args: any[]) => any;
+type Tail<T extends any[]> = T extends [any, ...infer R] ? R : [];
+type FunctionProps<T> = T extends (...args: any[]) => any
+  ? { [K in Exclude<keyof T, keyof Function>]: Mocked<T[K]> }
+  : {};
+type MockedFunction<T extends AnyFunction> = MockFunction<
+  Parameters<T>,
+  ReturnType<T>
+> &
+  T &
+  FunctionProps<T>;
+
+interface RepeatControl {
+  repeat(times: number): RepeatControl;
+  repeatAny(): RepeatControl;
+}
+
+interface ExpectationTerminal<R, TArgs extends any[]> {
+  return(value?: R): RepeatControl;
+  whenCalled(callback: (...args: TArgs) => void): ExpectationTerminal<R, TArgs>;
+  repeat(times: number): RepeatControl;
+  repeatAny(): RepeatControl;
+  throw(error: unknown): ExpectationTerminal<R, TArgs>;
+  resolve(value: any): RepeatControl;
+  reject(value: any): RepeatControl;
+}
+
+interface ExpectationChain<TArgs extends any[], R>
+  extends ExpectationTerminal<R, TArgs> {
+  expect(arg: TArgs[0]): ExpectationChain<Tail<TArgs>, R>;
+  expectAnything(): ExpectationChain<Tail<TArgs>, R>;
+  ignore(): ExpectationChain<Tail<TArgs>, R>;
+  expectArray(
+    value: TArgs[0] extends any[] ? TArgs[0] : any[]
+  ): ExpectationChain<Tail<TArgs>, R>;
+}
+
+interface MockFunction<TArgs extends any[], R> {
+  (...args: TArgs): R;
+  // Allow any-args calls in addition to the original signature.
+  (...args: any[]): any;
+  expect(): ExpectationTerminal<R, TArgs>;
+  expect(...args: TArgs): ExpectationTerminal<R, TArgs>;
+  expect(arg: TArgs[0]): ExpectationChain<Tail<TArgs>, R>;
+  expectAnything(): ExpectationChain<Tail<TArgs>, R>;
+  ignore(): ExpectationChain<Tail<TArgs>, R>;
+  expectArray(
+    value: TArgs[0] extends any[] ? TArgs[0] : any[]
+  ): ExpectationChain<Tail<TArgs>, R>;
+  // Allow any-args expectations in addition to typed expectations.
+  expect(...args: any[]): ExpectationTerminal<any, any[]>;
+  verify(): true;
+  reset(): void;
+}
+
+type Mocked<T> = T extends AnyFunction
+  ? MockedFunction<T>
+  : T extends object
+  ? { [K in keyof T]: Mocked<T[K]> } & { verify: () => true }
+  : T;
+
+interface RequireExpectation {
+  return(value: any): RequireExpectation;
+  repeat(times: number): RequireExpectation;
+  repeatAny(): RequireExpectation;
+  whenCalled(callback: (...args: any[]) => void): RequireExpectation;
+}
+
+interface ThenableMock<T = any> {
+  (valueToResolveWith?: T | null, errorToFailWith?: any): ThenableMock<T>;
+  then<U = T>(
+    success?: (value: T) => U | ThenableMock<U> | PromiseLike<U>,
+    fail?: (error: any) => U | ThenableMock<U> | PromiseLike<U>
+  ): ThenableMock<U>;
+  resolve(value?: T): ThenableMock<T>;
+  reject(error: any): ThenableMock<never>;
+}
+
+declare function mock<TArgs extends any[] = any[], R = any>(): MockFunction<
+  TArgs,
+  R
+>;
+declare function mock<T extends AnyFunction>(
+  original: T
+): MockedFunction<T>;
+declare function mock<T extends object>(subject: T): Mocked<T>;
+
+declare function expectRequire(moduleName: string): RequireExpectation;
+declare namespace expectRequire {
+  function reset(): void;
+}
+
+declare function requireMock<TArgs extends any[] = any[], R = any>(
+  moduleName: string
+): MockFunction<TArgs, R>;
+declare namespace requireMock {
+  function reset(): void;
+}
+
+declare function promise<T = any>(): ThenableMock<T>;
+
+declare const aMock: {
+  mock: typeof mock;
+  expectRequire: typeof expectRequire;
+  requireMock: typeof requireMock;
+  promise: typeof promise;
+};
+
+export = aMock;

package/mock/mockFuncProperties.js

@@ -1,16 +1,39 @@
-var propertyMock = require('./propertyMock');
-
-function execute(subject,mockObject) {
-	if (!(subject instanceof Object))
-		return;
-	var mockFuncProperties = require('./mockFuncProperties');
-	for(var propertyName in subject) {
-		var property = subject[propertyName];
-		var mockProperty = mockObject[propertyName];
-		if (property instanceof Function)
-			subject[propertyName] = propertyMock(subject,propertyName,mockProperty);
-		mockFuncProperties(property,mockProperty);
-	}
-}
+var propertyMock = require('./propertyMock');
+
+function collectPropertyNames(subject) {
+	var names = {};
+	for (var name in subject) {
+		names[name] = true;
+	}
+	var proto = Object.getPrototypeOf(subject);
+	while (proto && proto !== Object.prototype && proto !== Function.prototype) {
+		var props = Object.getOwnPropertyNames(proto);
+		for (var i = 0; i < props.length; i++) {
+			var prop = props[i];
+			if (prop === 'constructor' || names[prop])
+				continue;
+			var desc = Object.getOwnPropertyDescriptor(proto, prop);
+			if (desc && typeof desc.value === 'function')
+				names[prop] = true;
+		}
+		proto = Object.getPrototypeOf(proto);
+	}
+	return Object.keys(names);
+}
+
+function execute(subject,mockObject) {
+	if (!(subject instanceof Object))
+		return;
+	var mockFuncProperties = require('./mockFuncProperties');
+	var propertyNames = collectPropertyNames(subject);
+	for(var i = 0; i < propertyNames.length; i++) {
+		var propertyName = propertyNames[i];
+		var property = subject[propertyName];
+		var mockProperty = mockObject[propertyName];
+		if (property instanceof Function)
+			subject[propertyName] = propertyMock(subject,propertyName,mockProperty);
+		mockFuncProperties(property,mockProperty);
+	}
+}
 
 module.exports  = execute;

package/mock/objectMock.js

@@ -1,23 +1,48 @@
-var newMockContext = require('./mockContext');
-var newPartialMock = require('../partialMock');
-
-function _new(subject,mockContext) {
-	var newObjectMock = require('./objectMock');
-
-	var mockContext = newMockContext(mockContext);
-	var mock = {};
-	mock.verify = mockContext.verify;
-	if (subject instanceof Function) {
-		mock = newPartialMock(subject);		
-		mockContext.verify.add(mock.verify);
-	}
-	if (!(subject instanceof Object))
-		return mock;
-	for(var propertyName in subject) {
-		var property = subject[propertyName];
-		mock[propertyName] = newObjectMock(property,mockContext);
-	}
-	return mock;
-}
+var newMockContext = require('./mockContext');
+var newPartialMock = require('../partialMock');
+
+function collectPropertyNames(subject) {
+	var names = {};
+	for (var name in subject) {
+		names[name] = true;
+	}
+	var proto = Object.getPrototypeOf(subject);
+	while (proto && proto !== Object.prototype && proto !== Function.prototype) {
+		var props = Object.getOwnPropertyNames(proto);
+		for (var i = 0; i < props.length; i++) {
+			var prop = props[i];
+			if (prop === 'constructor' || names[prop])
+				continue;
+			var desc = Object.getOwnPropertyDescriptor(proto, prop);
+			if (desc && typeof desc.value === 'function')
+				names[prop] = true;
+		}
+		proto = Object.getPrototypeOf(proto);
+	}
+	return Object.keys(names);
+}
+
+function _new(subject,mockContext,parent) {
+	var newObjectMock = require('./objectMock');
+
+	var mockContext = newMockContext(mockContext);
+	var mock = {};
+	mock.verify = mockContext.verify;
+	if (subject instanceof Function) {
+		mock = newPartialMock(subject, parent);		
+		mockContext.verify.add(mock.verify);
+	}
+	if (!(subject instanceof Object))
+		return mock;
+	var propertyNames = collectPropertyNames(subject);
+	for(var i = 0; i < propertyNames.length; i++) {
+		var propertyName = propertyNames[i];
+		if (Object.prototype.hasOwnProperty.call(mock, propertyName))
+			continue;
+		var property = subject[propertyName];
+		mock[propertyName] = newObjectMock(property,mockContext,subject);
+	}
+	return mock;
+}
 
 module.exports  = _new

package/mock.js

@@ -3,16 +3,14 @@ var newObjectMock = require('./mock/objectMock');
 var newPartialMock = require('./partialMock')
 var mockFuncProperties = require('./mock/mockFuncProperties')
 
-function create(subject) {
-	if (subject == undefined)
-		return newStrictMock();
-	if (subject instanceof Function)
-		return newPartialMock(subject);
-	var mock = newObjectMock(subject);
-	mockFuncProperties(subject,mock);
-	return mock;
-
-}
+function create(subject) {
+	if (subject == undefined)
+		return newStrictMock();
+	var mock = newObjectMock(subject);
+	mockFuncProperties(subject,mock);
+	return mock;
+
+}
 
 module.exports  = create;
 

package/package.json

@@ -1,7 +1,8 @@
 {
   "name": "a_mock",
-  "version": "2.0.0",
+  "version": "2.0.2",
   "main": "index.js",
+  "types": "index.d.ts",
   "title": "a_mock",
   "description": "Sub package of a. Mocking framework",
   "keywords": ["mock","mocking","partial mock","strict mock","tdd","stub","stubbing","mock require","verify"],

package/partialMock/execute.js

@@ -7,13 +7,14 @@ function execute(returnValue,fallback,hasCorrectArguments,mockContext,shouldDecr
 		args.push(arguments[index]);
 		index++;
 	}
-	if (hasCorrectArguments.apply(null,args)) {
-		negotiateDecrementExpectCount(shouldDecrementExpectCount,mockContext);
-		whenCalledEmitter.emit.apply(null,args);
-		return returnValue;
-	}
-		
-	return fallback.apply(null,args);
-}
+	if (hasCorrectArguments.apply(null,args)) {
+		negotiateDecrementExpectCount(shouldDecrementExpectCount,mockContext);
+		whenCalledEmitter.emit.apply(null,args);
+		return returnValue;
+	}
+		
+	var receiver = mockContext && mockContext.thisArg != null ? mockContext.thisArg : this;
+	return fallback.apply(receiver,args);
+}
 
-module.exports = execute;
+module.exports = execute;

package/partialMock/mockContext/reset.js

@@ -1,15 +1,16 @@
-var newFallbackWrapper = require('../newFallbackWrapper');
-var newAnd = require('../../newMutableAnd')
+var newFallbackWrapper = require('../newFallbackWrapper');
+var newAnd = require('../../newMutableAnd')
+
+function _new(mockContext,originalFallback,thisArg) {
+	var and = newAnd();	
+	mockContext.execute = newFallbackWrapper(originalFallback, thisArg);
+	mockContext.originalFallback = originalFallback;
+	mockContext.thisArg = thisArg;
+	mockContext.lastExecute = mockContext.execute;
+	mockContext.compositeAreCorrectArguments = and;
+	mockContext.expectCount = 0;
+	
+	return mockContext;
+}
 
-function _new(mockContext,originalFallback) {
-	var and = newAnd();	
-	mockContext.execute = newFallbackWrapper(originalFallback);
-	mockContext.originalFallback = originalFallback;
-	mockContext.lastExecute = mockContext.execute;
-	mockContext.compositeAreCorrectArguments = and;
-	mockContext.expectCount = 0;
-	
-	return mockContext;
-}
-
-module.exports = _new;
+module.exports = _new;

package/partialMock/newExecute.js

@@ -3,14 +3,14 @@ function newExecute(returnValue,hasCorrectArguments,mockContext,shouldDecrementE
 	var _fallback = mockContext.originalFallback;
 	var whenCalledEmitter = mockContext.whenCalledEmitter;
 
-	function execute() {
-		var args = [returnValue,_fallback,hasCorrectArguments,mockContext,shouldDecrementExpectCount,whenCalledEmitter];
-		for(var index = 0; index < arguments.length; index++) {
-			args.push(arguments[index]);
-		}
-		return _execute.apply(null,args);
-		returnValue,fallback,hasCorrectArguments
-	}
+	function execute() {
+		var args = [returnValue,_fallback,hasCorrectArguments,mockContext,shouldDecrementExpectCount,whenCalledEmitter];
+		for(var index = 0; index < arguments.length; index++) {
+			args.push(arguments[index]);
+		}
+		return _execute.apply(this,args);
+		returnValue,fallback,hasCorrectArguments
+	}
 
 	execute.setFallback = function(fallback) {
 		_fallback = fallback;
@@ -19,4 +19,4 @@ function newExecute(returnValue,hasCorrectArguments,mockContext,shouldDecrementE
 	return execute;
 }
 
-module.exports = newExecute;
+module.exports = newExecute;

package/partialMock/newFallbackWrapper.js

@@ -1,31 +1,35 @@
-var getStackTrace = require('./fallbackWrapper/getStackTrace');
-
-function _new(originalFallback) {
-
-	var fallback = originalFallback;
-
-	function execute() {
-		Error.stackTraceLimit = Error.stackTraceLimit + 2;
-		try {
-			return fallback.apply(null,arguments);	
-		}
-		catch (e) {			
-			if (e.name == 'Mock Error') {
-  				e.stack = e.name + ': ' + e.message + '\n' + getStackTrace();
-			}
+var getStackTrace = require('./fallbackWrapper/getStackTrace');
+
+function _new(originalFallback, thisArg) {
+
+	var fallback = originalFallback;
+	var fallbackThis = thisArg;
+
+	function execute() {
+		Error.stackTraceLimit = Error.stackTraceLimit + 2;
+		try {
+			var receiver = fallbackThis != null ? fallbackThis : this;
+			return fallback.apply(receiver,arguments);	
+		}
+		catch (e) {			
+			if (e.name == 'Mock Error') {
+  				e.stack = e.name + ': ' + e.message + '\n' + getStackTrace();
+			}
 			throw e;
 		}
 		finally {
 			Error.stackTraceLimit = Error.stackTraceLimit - 2;
 		}
-		
-	}
-
-	execute.setFallback = function(fallback2) {
-		fallback = fallback2;
-	};
-
-	return execute;
-}
+
+	}
+
+	execute.setFallback = function(fallback2, thisArg2) {
+		fallback = fallback2;
+		if (arguments.length > 1)
+			fallbackThis = thisArg2;
+	};
+
+	return execute;
+}
 
-module.exports = _new;
+module.exports = _new;

package/partialMock/newMockContext.js

@@ -1,13 +1,13 @@
-var newObject = require('../newObject')
-var reset = require('./mockContext/reset');
+var newObject = require('../newObject')
+var reset = require('./mockContext/reset');
+
+function _new(originalFallback, thisArg) {
+	var c = newObject();
+	c = reset(c,originalFallback,thisArg);
+	c.reset = function() {
+		return reset(c, originalFallback, thisArg);
+	};
+	return c;	
+}
 
-function _new(originalFallback) {
-	var c = newObject();
-	c = reset(c,originalFallback);
-	c.reset = function() {
-		return reset(c, originalFallback);
-	};
-	return c;	
-}
-
-module.exports = _new;
+module.exports = _new;

package/partialMock.js

@@ -1,5 +1,5 @@
-function create(originalFunc) {
-	var newMockContext = require('./partialMock/newMockContext');
+function create(originalFunc, thisArg) {
+	var newMockContext = require('./partialMock/newMockContext');
 	var expect = require('./partialMock/expect');
 	var expectAnything = require('./partialMock/expectAnything');
 	var ignore = require('./partialMock/ignore');
@@ -7,14 +7,14 @@ function create(originalFunc) {
 	var verify = require('./partialMock/verify');
 	var expectEmpty = require('./partialMock/expectEmpty');
 	var newEmptyAnd = require('./newMutableAnd');		
-	var mockContext = newMockContext(originalFunc);
-	var _negotiateEnd = require('./partialMock/negotiateEnd');	
-
-	function mock() {		
-		negotiateEnd();
-		mockContext.arguments = arguments;		
-		return mockContext.execute.apply(null,arguments);
-	}
+	var mockContext = newMockContext(originalFunc, thisArg);
+	var _negotiateEnd = require('./partialMock/negotiateEnd');	
+
+	function mock() {		
+		negotiateEnd();
+		mockContext.arguments = arguments;		
+		return mockContext.execute.apply(this,arguments);
+	}
 
 	mock.expect = function() {				
 		negotiateEnd();

package/util.js

@@ -1 +1,7 @@
-module.exports = require('util');
+function isDate(x) {
+    return Object.prototype.toString.call(x) === '[object Date]';
+}
+
+module.exports = {
+    isDate: isDate
+};