a_mock 1.0.5 → 2.0.1

package/expectRequireSpec/test.js

@@ -1,67 +1,67 @@
-var sut = require('../expectRequire');
-var test = require('../test');
-var assert = require('assert');
-
-var fooFake = {};
-var bazFake = {};
-	
-
-(function(){
-	console.log('expectRequire');
-	
-	(function() {		
-		console.log('require');
-		sut('./foo').return(fooFake);
-			sut('./baz').return(bazFake);
-
-		var firstReturned = require('./foo');
-		var secondReturned = require('./baz');
-		var thirdReturned = require('./foo')
-		var fourthReturned = require('./baz');
-		
-		test('it should execute returns fooFake first time', function(){
-			assert.equal(fooFake,firstReturned);
-    	});
-
-		test('it should execute returns bazFake second time', function(){
-			assert.equal(bazFake,secondReturned);
-    	});
-
-    	test('it should execute returns real foo third time', function(){
-			assert.notEqual(bazFake,thirdReturned);
-			assert.notEqual(fooFake,thirdReturned);
-    	});
-
-    	test('it should execute returns real foo fourth time', function(){
-			assert.notEqual(bazFake,fourthReturned);
-			assert.notEqual(fooFake,fourthReturned);
-    	});
-
-	})();
-
-})();
-
-(function(){
-	console.log('expectRequire reset');
-	
-	(function() {		
-		console.log('require');
-		sut('./foo').return(fooFake);
-		sut.reset();
-		var returned = require('./foo');
-		sut('./foo').return(fooFake);
-		var returnedSecond = require('./foo');
-
-
-		
-		test('it should execute returns real foo', function(){
-			assert.notEqual(fooFake,returned);
-    	});
-
-		test('it should execute returns fake foo second time', function(){
-			assert.equal(fooFake,returnedSecond);
-    	});
-
-	})();
-
-})();
+var sut = require('../expectRequire');
+var test = require('../test');
+var assert = require('assert');
+
+var fooFake = {};
+var bazFake = {};
+	
+
+(function(){
+	console.log('expectRequire');
+	
+	(function() {		
+		console.log('require');
+		sut('./foo').return(fooFake);
+			sut('./baz').return(bazFake);
+
+		var firstReturned = require('./foo');
+		var secondReturned = require('./baz');
+		var thirdReturned = require('./foo')
+		var fourthReturned = require('./baz');
+		
+		test('it should execute returns fooFake first time', function(){
+			assert.equal(fooFake,firstReturned);
+    	});
+
+		test('it should execute returns bazFake second time', function(){
+			assert.equal(bazFake,secondReturned);
+    	});
+
+    	test('it should execute returns real foo third time', function(){
+			assert.notEqual(bazFake,thirdReturned);
+			assert.notEqual(fooFake,thirdReturned);
+    	});
+
+    	test('it should execute returns real foo fourth time', function(){
+			assert.notEqual(bazFake,fourthReturned);
+			assert.notEqual(fooFake,fourthReturned);
+    	});
+
+	})();
+
+})();
+
+(function(){
+	console.log('expectRequire reset');
+	
+	(function() {		
+		console.log('require');
+		sut('./foo').return(fooFake);
+		sut.reset();
+		var returned = require('./foo');
+		sut('./foo').return(fooFake);
+		var returnedSecond = require('./foo');
+
+
+		
+		test('it should execute returns real foo', function(){
+			assert.notEqual(fooFake,returned);
+    	});
+
+		test('it should execute returns fake foo second time', function(){
+			assert.equal(fooFake,returnedSecond);
+    	});
+
+	})();
+
+})();

package/index.d.ts

@@ -0,0 +1,96 @@
+type AnyFunction = (...args: any[]) => any;
+type Tail<T extends any[]> = T extends [any, ...infer R] ? R : [];
+
+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;
+  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>;
+  verify(): true;
+  reset(): void;
+}
+
+type Mocked<T> = T extends (...args: infer A) => infer R
+  ? MockFunction<A, R>
+  : 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
+): MockFunction<Parameters<T>, ReturnType<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/index.js

@@ -1,10 +1,9 @@
-require('./util');
-require('./buffer');
-
-module.exports = {
-	mock: require('./mock'),
-	expectRequire: require('./expectRequire'),
-	requireMock: require('./requireMock'),
-	then: require('./newThen')
-};
-
+require('./util');
+require('./buffer');
+
+module.exports = {
+	mock: require('./mock'),
+	expectRequire: require('./expectRequire'),
+	requireMock: require('./requireMock'),
+	promise: require('./newThen')
+};

package/mock/mockContext.js

@@ -1,10 +1,10 @@
-function _new(context) {
-	if (context)
-		return context;
-	var verify = require('../newMutableAnd')();
-	c = {};
-	c.verify = verify;
-	return c;
-}
-
+function _new(context) {
+	if (context)
+		return context;
+	var verify = require('../newMutableAnd')();
+	c = {};
+	c.verify = verify;
+	return c;
+}
+
 module.exports = _new;

package/mock/mockContextSpec/test.js

@@ -1,30 +1,30 @@
-var assert = require('assert');
-var test = require('../../test');
-var newRequireMock = require('../../partialMock/simple/newRequireMock');
-
-(function(){
-	console.log('mockContext');
-	var newVerify = newRequireMock('../newMutableAnd');
-	var sut = require('../mockContext');
-
-	(function() {
-		console.log('empty input.new');
-		var verify = {};
-		newVerify.expect().return(verify);	
-		var returned = sut();
-
-		test('it should set verify', function(){
-			assert.equal(returned.verify,verify);
-    	});
-	})();
-
-	(function() {		
-		console.log('nonEmpty input.new');
-		var input = {};		
-		var returned = sut(input);
-
-		test('it should return same', function(){
-			assert.equal(returned,input);
-    	});
-	})();
-})();
+var assert = require('assert');
+var test = require('../../test');
+var newRequireMock = require('../../partialMock/simple/newRequireMock');
+
+(function(){
+	console.log('mockContext');
+	var newVerify = newRequireMock('../newMutableAnd');
+	var sut = require('../mockContext');
+
+	(function() {
+		console.log('empty input.new');
+		var verify = {};
+		newVerify.expect().return(verify);	
+		var returned = sut();
+
+		test('it should set verify', function(){
+			assert.equal(returned.verify,verify);
+    	});
+	})();
+
+	(function() {		
+		console.log('nonEmpty input.new');
+		var input = {};		
+		var returned = sut(input);
+
+		test('it should return same', function(){
+			assert.equal(returned,input);
+    	});
+	})();
+})();

package/mock/mockFuncProperties.js

@@ -1,16 +1,16 @@
-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);
-	}
-}
-
-module.exports  = execute;
+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);
+	}
+}
+
+module.exports  = execute;

package/mock/mockFuncPropertiesSpec/test.js

@@ -1,67 +1,67 @@
-var assert = require('assert');
-var test = require('../../test');
-var newRequireMock = require('../../partialMock/simple/newRequireMock');
-var newMock = require('../../partialMock/simple/newMock');
-
-(function(){
-	console.log('mockFuncProperties');
-	var newPropertyMock = newRequireMock('./propertyMock');
-	var mockFuncProperties = newRequireMock('./mockFuncProperties');
-	var sut = require('../mockFuncProperties');
-
-	(function() {
-		console.log('subject is non-primitive');
-		var subject = {};
-		var a2 = {};
-		var a = function() {};
-		var b = {};
-		subject.a = a;
-		subject.b = b;
-
-		var mockObject = {};
-		var aMock  = {};
-		var b2Mock = {};
-		var bMock  = {};
-		mockObject.a = aMock;
-		mockObject.b = bMock;
-
-		var expectedA = {};
-		newPropertyMock.expect(subject).expect('a').expect(aMock).return(expectedA);
-		mockFuncProperties.expect(a).expect(aMock).whenCalled(onMockSubProperties).return();
-		mockFuncProperties.expect(b).expect(bMock).whenCalled(onMockSubProperties).return();
-
-		var mockSubPropertiesCount = 0;
-		var didMockSubProperties = false;
-
-		function onMockSubProperties() {
-			mockSubPropertiesCount++;		
-			didMockSubProperties = (mockSubPropertiesCount == 2);
-		}
-
-		sut(subject,mockObject);
-		
-		test('it should mock property a',function() {
-			assert.equal(subject.a,expectedA);
-		});
-	
-		test('it should mock subProperties',function() {
-			assert.ok(didMockSubProperties);
-		});
-
-		test('it should not change property b',function() {
-			assert.equal(subject.b,b);
-		});
-	})();
-
-	(function() {
-		console.log('subject is primitive');
-		var subject = 'a';
-		var mockObject = 'a';
-
-		sut(subject,mockObject);
-		
-		test('it should not throw',function() {
-			assert(true);
-		});	
-	})();
-})();
+var assert = require('assert');
+var test = require('../../test');
+var newRequireMock = require('../../partialMock/simple/newRequireMock');
+var newMock = require('../../partialMock/simple/newMock');
+
+(function(){
+	console.log('mockFuncProperties');
+	var newPropertyMock = newRequireMock('./propertyMock');
+	var mockFuncProperties = newRequireMock('./mockFuncProperties');
+	var sut = require('../mockFuncProperties');
+
+	(function() {
+		console.log('subject is non-primitive');
+		var subject = {};
+		var a2 = {};
+		var a = function() {};
+		var b = {};
+		subject.a = a;
+		subject.b = b;
+
+		var mockObject = {};
+		var aMock  = {};
+		var b2Mock = {};
+		var bMock  = {};
+		mockObject.a = aMock;
+		mockObject.b = bMock;
+
+		var expectedA = {};
+		newPropertyMock.expect(subject).expect('a').expect(aMock).return(expectedA);
+		mockFuncProperties.expect(a).expect(aMock).whenCalled(onMockSubProperties).return();
+		mockFuncProperties.expect(b).expect(bMock).whenCalled(onMockSubProperties).return();
+
+		var mockSubPropertiesCount = 0;
+		var didMockSubProperties = false;
+
+		function onMockSubProperties() {
+			mockSubPropertiesCount++;		
+			didMockSubProperties = (mockSubPropertiesCount == 2);
+		}
+
+		sut(subject,mockObject);
+		
+		test('it should mock property a',function() {
+			assert.equal(subject.a,expectedA);
+		});
+	
+		test('it should mock subProperties',function() {
+			assert.ok(didMockSubProperties);
+		});
+
+		test('it should not change property b',function() {
+			assert.equal(subject.b,b);
+		});
+	})();
+
+	(function() {
+		console.log('subject is primitive');
+		var subject = 'a';
+		var mockObject = 'a';
+
+		sut(subject,mockObject);
+		
+		test('it should not throw',function() {
+			assert(true);
+		});	
+	})();
+})();

package/mock/objectMock.js

@@ -1,23 +1,23 @@
-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;
-}
-
-module.exports  = _new
+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;
+}
+
+module.exports  = _new