a_mock 1.0.5 → 2.0.1

package/partialMock/simple/newPartialMockSpec/testWithMultiArgs.js

@@ -1,54 +1,54 @@
-var newSut = require('../newPartialMock');
-var assert = require('assert');
-var test = require('../../../test');
-
-		var originalReturnValue = {};
-		var originalReturnValue2 = {};
-		function original(actualArg1,actualArg2) {
-			if (actualArg1 === arg1 && actualArg2 === arg2)
-				return originalReturnValue2;
-			if (actualArg1 === arg1)
-				return originalReturnValue;
-		}
-
-		var foo ={};
-		var baz = {};
-		var arg1 = {};		
-		var arg2 = {};
-
-
-(function(){
-	console.log('partialMockSpec multiple args.2');
-
-	(function() {		
-		console.log('expect arg1,arg2 return foo once.');	
-		var sut = newSut(original);
-		var callBackCount = 0;
-		function onCalled(actualArg1,actualArg2) {
-			if ((actualArg1 === arg1) && (actualArg2 === arg2))
-				callBackCount++;
-		}
-
-		sut.expect(arg1).expect(arg2).whenCalled(onCalled).return(foo);
-
-		var firstReturned = sut(arg1);
-		var secondReturned = sut(arg1,arg2);
-		var thirdReturned = sut(arg1,arg2);
-
-		test('it should execute returns original when second arg is wrong ', function(){
-			assert.equal(originalReturnValue,firstReturned);
-    	});
-
-		test('it should execute returns foo when correct arguments', function(){
-			assert.equal(foo,secondReturned);
-    	});
-
-		test('it should execute returns original when correct argument second time', function(){
-			assert.equal(originalReturnValue2,thirdReturned);
-    	});
-
-		test('it should calls callBack once', function(){
-			assert.equal(1,callBackCount);
-    	});
-	})();	
-})();
+var newSut = require('../newPartialMock');
+var assert = require('assert');
+var test = require('../../../test');
+
+		var originalReturnValue = {};
+		var originalReturnValue2 = {};
+		function original(actualArg1,actualArg2) {
+			if (actualArg1 === arg1 && actualArg2 === arg2)
+				return originalReturnValue2;
+			if (actualArg1 === arg1)
+				return originalReturnValue;
+		}
+
+		var foo ={};
+		var baz = {};
+		var arg1 = {};		
+		var arg2 = {};
+
+
+(function(){
+	console.log('partialMockSpec multiple args.2');
+
+	(function() {		
+		console.log('expect arg1,arg2 return foo once.');	
+		var sut = newSut(original);
+		var callBackCount = 0;
+		function onCalled(actualArg1,actualArg2) {
+			if ((actualArg1 === arg1) && (actualArg2 === arg2))
+				callBackCount++;
+		}
+
+		sut.expect(arg1).expect(arg2).whenCalled(onCalled).return(foo);
+
+		var firstReturned = sut(arg1);
+		var secondReturned = sut(arg1,arg2);
+		var thirdReturned = sut(arg1,arg2);
+
+		test('it should execute returns original when second arg is wrong ', function(){
+			assert.equal(originalReturnValue,firstReturned);
+    	});
+
+		test('it should execute returns foo when correct arguments', function(){
+			assert.equal(foo,secondReturned);
+    	});
+
+		test('it should execute returns original when correct argument second time', function(){
+			assert.equal(originalReturnValue2,thirdReturned);
+    	});
+
+		test('it should calls callBack once', function(){
+			assert.equal(1,callBackCount);
+    	});
+	})();	
+})();

package/partialMock/simple/newPartialMockSpec/testWithSingleArg.js

@@ -1,116 +1,116 @@
-var newSut = require('../newPartialMock');
-var assert = require('assert');
-var test = require('../../../test');
-
-		var originalReturnValue = {};
-		function original() {
-			return originalReturnValue;
-		}
-
-		var foo ={};
-		var baz = {};
-		var arg1 = {};		
-
-
-(function(){
-	console.log('partialMockSpec');
-
-	(function() {		
-		console.log('expect return foo once.');		
-		var sut = newSut(original);
-		require('../newPartialMock')(function() {});
-		sut.expect(arg1).return(foo);
-		var s = require('../newPartialMock')(function() {});
-		var firstReturned = sut({});
-		var secondReturned = sut(arg1);
-		var thirdReturned = sut(arg1);
-
-		test('it should execute returns original when wrong argument', function(){
-			assert.equal(originalReturnValue,firstReturned);
-    	});
-
-		test('it should execute returns foo when correct argument', function(){
-			assert.equal(foo,secondReturned);
-    	});
-
-		test('it should execute returns original when correct argument second time', function(){
-			assert.equal(originalReturnValue,thirdReturned);
-    	});
-
-	})();
-
-	(function() {		
-		console.log('expect return foo twice.');
-		
-		var sut = newSut(original);
-		sut.expect(arg1).return(foo);
-		sut.expect(arg1).return(foo);
-
-		var firstReturned = sut(arg1);
-		var secondReturned = sut(arg1);
-		var thirdReturned = sut(arg1);
-
-		test('it should execute returns foo first time', function(){
-			assert.equal(foo,firstReturned);
-    	});
-
-		test('it should execute returns foo second time', function(){
-			assert.equal(foo,secondReturned);
-    	});
-
-		test('it should execute returns original third time', function(){
-			assert.equal(originalReturnValue,thirdReturned);
-    	});
-
-	})();
-
-
-	(function() {		
-		console.log('expect return foo then baz');	
-		var sut = newSut(original);
-		sut.expect().return(foo);
-		sut.expect(arg1).return(baz);
-
-		var firstReturned = sut();
-		var secondReturned = sut(arg1);
-		var thirdReturned = sut(arg1);
-
-		test('it should execute returns foo first time', function(){
-			assert.equal(foo,firstReturned);
-    	});
-
-		test('it should execute returns baz second time', function(){
-			assert.equal(baz,secondReturned);
-    	});
-
-		test('it should execute returns original third time', function(){
-			assert.equal(originalReturnValue,thirdReturned);
-    	});
-
-	})();
-
-	(function() {		
-		console.log('expect anything return foo, then expect arg1 return baz.');
-		var sut = newSut(original);
-		sut.expectAnything().return(foo);
-		sut.expect(arg1).return(baz);
-
-		var firstReturned = sut('abc');
-		var secondReturned = sut('abc');
-		var thirdReturned = sut(arg1);
-
-		test('it should execute returns foo first time', function(){
-			assert.equal(foo,firstReturned);
-    	});
-
-		test('it should execute returns original second time', function(){
-			assert.equal(originalReturnValue,secondReturned);
-    	});
-
-		test('it should execute returns baz third time', function(){
-			assert.equal(baz,thirdReturned);
-    	});
-
-	})();
-
-})();
+var newSut = require('../newPartialMock');
+var assert = require('assert');
+var test = require('../../../test');
+
+		var originalReturnValue = {};
+		function original() {
+			return originalReturnValue;
+		}
+
+		var foo ={};
+		var baz = {};
+		var arg1 = {};		
+
+
+(function(){
+	console.log('partialMockSpec');
+
+	(function() {		
+		console.log('expect return foo once.');		
+		var sut = newSut(original);
+		require('../newPartialMock')(function() {});
+		sut.expect(arg1).return(foo);
+		var s = require('../newPartialMock')(function() {});
+		var firstReturned = sut({});
+		var secondReturned = sut(arg1);
+		var thirdReturned = sut(arg1);
+
+		test('it should execute returns original when wrong argument', function(){
+			assert.equal(originalReturnValue,firstReturned);
+    	});
+
+		test('it should execute returns foo when correct argument', function(){
+			assert.equal(foo,secondReturned);
+    	});
+
+		test('it should execute returns original when correct argument second time', function(){
+			assert.equal(originalReturnValue,thirdReturned);
+    	});
+
+	})();
+
+	(function() {		
+		console.log('expect return foo twice.');
+		
+		var sut = newSut(original);
+		sut.expect(arg1).return(foo);
+		sut.expect(arg1).return(foo);
+
+		var firstReturned = sut(arg1);
+		var secondReturned = sut(arg1);
+		var thirdReturned = sut(arg1);
+
+		test('it should execute returns foo first time', function(){
+			assert.equal(foo,firstReturned);
+    	});
+
+		test('it should execute returns foo second time', function(){
+			assert.equal(foo,secondReturned);
+    	});
+
+		test('it should execute returns original third time', function(){
+			assert.equal(originalReturnValue,thirdReturned);
+    	});
+
+	})();
+
+
+	(function() {		
+		console.log('expect return foo then baz');	
+		var sut = newSut(original);
+		sut.expect().return(foo);
+		sut.expect(arg1).return(baz);
+
+		var firstReturned = sut();
+		var secondReturned = sut(arg1);
+		var thirdReturned = sut(arg1);
+
+		test('it should execute returns foo first time', function(){
+			assert.equal(foo,firstReturned);
+    	});
+
+		test('it should execute returns baz second time', function(){
+			assert.equal(baz,secondReturned);
+    	});
+
+		test('it should execute returns original third time', function(){
+			assert.equal(originalReturnValue,thirdReturned);
+    	});
+
+	})();
+
+	(function() {		
+		console.log('expect anything return foo, then expect arg1 return baz.');
+		var sut = newSut(original);
+		sut.expectAnything().return(foo);
+		sut.expect(arg1).return(baz);
+
+		var firstReturned = sut('abc');
+		var secondReturned = sut('abc');
+		var thirdReturned = sut(arg1);
+
+		test('it should execute returns foo first time', function(){
+			assert.equal(foo,firstReturned);
+    	});
+
+		test('it should execute returns original second time', function(){
+			assert.equal(originalReturnValue,secondReturned);
+    	});
+
+		test('it should execute returns baz third time', function(){
+			assert.equal(baz,thirdReturned);
+    	});
+
+	})();
+
+})();

package/partialMock/simple/newRequireMock.js

@@ -1,12 +1,12 @@
-var newMock = require('./newMock');
-var expectRequire = require('./expectRequire');
-
-function create(moduleName) {
-	var mock = newMock();
-	expectRequire(moduleName).return(mock);
-	return mock;
-}
-
-module.exports  = create;
-
-
+var newMock = require('./newMock');
+var expectRequire = require('./expectRequire');
+
+function create(moduleName) {
+	var mock = newMock();
+	expectRequire(moduleName).return(mock);
+	return mock;
+}
+
+module.exports  = create;
+
+

package/partialMock/simple/newRequireMockSpec/test.js

@@ -1,39 +1,39 @@
-var assert = require('assert');
-var test = require('../../../test');
-var newMock = require('../newMock');
-var expectRequire = require('../expectRequire');
-
-var newMockMock = newMock();
-var expectRequireMock = newMock();
-
-expectRequire('./newMock').return(newMockMock);
-expectRequire('./expectRequire').return(expectRequireMock);
-
-(function() {
-	console.log('newRequireMock');
-	var didExpectRequireReturnMock = false;
-	var mock = {};
-	var moduleName = {};
-	var expectation = {};
-	var returnMock = newMock();
-	
-	newMockMock.expect().return(mock);
-	expectRequireMock.expect(moduleName).return(expectation);
-	expectation.return = returnMock;
-	returnMock.expect(mock).whenCalled(onReturnMock).return(null);
-
-	var returned = require('../newRequireMock')(moduleName);
-
-	function onReturnMock() {
-		didExpectRequireReturnMock = true;
-	}
-
-	test('it should return mock', function() {
-		assert.equal(mock,returned);
-	});
-
-	test('it should expectRequire to return mock',function(){
-		assert.ok(didExpectRequireReturnMock);
-	});
-
-})();
+var assert = require('assert');
+var test = require('../../../test');
+var newMock = require('../newMock');
+var expectRequire = require('../expectRequire');
+
+var newMockMock = newMock();
+var expectRequireMock = newMock();
+
+expectRequire('./newMock').return(newMockMock);
+expectRequire('./expectRequire').return(expectRequireMock);
+
+(function() {
+	console.log('newRequireMock');
+	var didExpectRequireReturnMock = false;
+	var mock = {};
+	var moduleName = {};
+	var expectation = {};
+	var returnMock = newMock();
+	
+	newMockMock.expect().return(mock);
+	expectRequireMock.expect(moduleName).return(expectation);
+	expectation.return = returnMock;
+	returnMock.expect(mock).whenCalled(onReturnMock).return(null);
+
+	var returned = require('../newRequireMock')(moduleName);
+
+	function onReturnMock() {
+		didExpectRequireReturnMock = true;
+	}
+
+	test('it should return mock', function() {
+		assert.equal(mock,returned);
+	});
+
+	test('it should expectRequire to return mock',function(){
+		assert.ok(didExpectRequireReturnMock);
+	});
+
+})();

package/partialMock/verify.js

@@ -1,8 +1,8 @@
-function verify(mockContext) {	
-	var count = mockContext.expectCount;
-	if (count > 0)
-		throw new Error('mock has ' + count + ' pending functions');
-	return true;
-}
-
+function verify(mockContext) {	
+	var count = mockContext.expectCount;
+	if (count > 0)
+		throw new Error('mock has ' + count + ' pending functions');
+	return true;
+}
+
 module.exports = verify;

package/partialMock/verifySpec/test.js

@@ -1,38 +1,38 @@
-var assert = require('assert');
-var test = require('../../test');
-
-var sut = require('../verify');
-
-(function() {
-	console.log('verifySpec');
-
-	(function(){
-		console.log('expectCount is zero.execute');
-		var mockContext = {};
-		mockContext.expectCount = 0;
-		var returned = sut(mockContext);
-
-		test('it should return true',function() {
-			assert.ok(returned);
-		});
-	})();
-	
-	(function(){
-		console.log('expectCount is above zero.execute');
-		var mockContext = {};
-		mockContext.expectCount = 2;
-		var msg;
-		try	{
-			var returned = sut(mockContext);	
-		}
-		catch(err) {
-			msg = err.message;
-		}
-		
-
-		test('it should throw mock has 2 pending functions',function() {
-			assert.equal(msg,'mock has 2 pending functions');
-		});
-	})();
-
+var assert = require('assert');
+var test = require('../../test');
+
+var sut = require('../verify');
+
+(function() {
+	console.log('verifySpec');
+
+	(function(){
+		console.log('expectCount is zero.execute');
+		var mockContext = {};
+		mockContext.expectCount = 0;
+		var returned = sut(mockContext);
+
+		test('it should return true',function() {
+			assert.ok(returned);
+		});
+	})();
+	
+	(function(){
+		console.log('expectCount is above zero.execute');
+		var mockContext = {};
+		mockContext.expectCount = 2;
+		var msg;
+		try	{
+			var returned = sut(mockContext);	
+		}
+		catch(err) {
+			msg = err.message;
+		}
+		
+
+		test('it should throw mock has 2 pending functions',function() {
+			assert.equal(msg,'mock has 2 pending functions');
+		});
+	})();
+
 })();

package/partialMock.js

@@ -1,70 +1,70 @@
-function create(originalFunc) {
-	var newMockContext = require('./partialMock/newMockContext');
-	var expect = require('./partialMock/expect');
-	var expectAnything = require('./partialMock/expectAnything');
-	var ignore = require('./partialMock/ignore');
-	var expectArray = require('./partialMock/expectArray');
-	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);
-	}
-
-	mock.expect = function() {				
-		negotiateEnd();
-		mockContext.compositeAreCorrectArguments = newEmptyAnd();
-		if (arguments.length == 0)
-			return expectEmpty(mockContext);
-		var args = [0,mockContext];
-		for (var i = 0 ; i < arguments.length; i++) {
-			args.push(arguments[i]);
-		};
-		return expect.apply(null,args);
-	};
-
-	mock.expectAnything = function() {
-		negotiateEnd();
-		mockContext.compositeAreCorrectArguments = newEmptyAnd();
-		var args  = [0,mockContext];
-		return expectAnything.apply(null,args);
-	};
-
-	mock.ignore = function() {
-		negotiateEnd();
-		mockContext.compositeAreCorrectArguments = newEmptyAnd();
-		var args  = [0,mockContext];
-		return ignore.apply(null,args);
-	};
-
-	mock.reset = mockContext.reset;
-
-	mock.verify = function() {		
-		negotiateEnd();
-		var args = [mockContext];
-		return verify.apply(null,args);
-	};
-
-	mock.expectArray = function(array) {
-		negotiateEnd();
-		mockContext.compositeAreCorrectArguments = newEmptyAnd();
-		var args = [0,mockContext,array];
-		return expectArray.apply(null,args);
-	}
-
-
-	function negotiateEnd() {
-		_negotiateEnd(mockContext);
-	}
-	
-	return mock;
-}
-
-module.exports  = create;
-
-
+function create(originalFunc) {
+	var newMockContext = require('./partialMock/newMockContext');
+	var expect = require('./partialMock/expect');
+	var expectAnything = require('./partialMock/expectAnything');
+	var ignore = require('./partialMock/ignore');
+	var expectArray = require('./partialMock/expectArray');
+	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);
+	}
+
+	mock.expect = function() {				
+		negotiateEnd();
+		mockContext.compositeAreCorrectArguments = newEmptyAnd();
+		if (arguments.length == 0)
+			return expectEmpty(mockContext);
+		var args = [0,mockContext];
+		for (var i = 0 ; i < arguments.length; i++) {
+			args.push(arguments[i]);
+		};
+		return expect.apply(null,args);
+	};
+
+	mock.expectAnything = function() {
+		negotiateEnd();
+		mockContext.compositeAreCorrectArguments = newEmptyAnd();
+		var args  = [0,mockContext];
+		return expectAnything.apply(null,args);
+	};
+
+	mock.ignore = function() {
+		negotiateEnd();
+		mockContext.compositeAreCorrectArguments = newEmptyAnd();
+		var args  = [0,mockContext];
+		return ignore.apply(null,args);
+	};
+
+	mock.reset = mockContext.reset;
+
+	mock.verify = function() {		
+		negotiateEnd();
+		var args = [mockContext];
+		return verify.apply(null,args);
+	};
+
+	mock.expectArray = function(array) {
+		negotiateEnd();
+		mockContext.compositeAreCorrectArguments = newEmptyAnd();
+		var args = [0,mockContext,array];
+		return expectArray.apply(null,args);
+	}
+
+
+	function negotiateEnd() {
+		_negotiateEnd(mockContext);
+	}
+	
+	return mock;
+}
+
+module.exports  = create;
+
+