a_mock 1.0.4 → 2.0.0

package/partialMock/simple/newPartialMock.js

@@ -1,124 +1,124 @@
-function create(originalFunc) {
-	
-	var candidateMock;
-	var mockArray  = [];
-	var curMock = {};
-	var expectedArguments = [];
-	curMock.whenCalledEmitter = emitter();
-	var _arguments;
-
-	function emitter() {
-		var callback = function() {};
-		var c = {};
-		
-		c.setSubscriber = function(subscriber) {
-			callback = subscriber;
-		}
-
-		c.emit = function() {
-			callback.apply(null,_arguments);	
-		}
-		return c;
-	}
-
-	function mock() {
-		_arguments = arguments;
-		for(var index = 0;index < mockArray.length;index++) {		
-			candidateMock = mockArray[index];
-			if (correctArgs()) {
-				candidateMock.whenCalledEmitter.emit();
-				negotiateRemove(index);
-				return candidateMock.returnValue;
-			}
-		}
-		return originalFunc.apply(null,_arguments);
-	};
-
-	function negotiateRemove(indexOfMock) {
-		if (candidateMock.repeatAny)
-			return;
-		candidateMock.repeat--;
-		if (candidateMock.repeat == 0)
-			mockArray.splice(indexOfMock,1);
-	}
-
-	function correctArgs() {
-		var expectedArguments = candidateMock.args;
-
-		var length = expectedArguments.length;
-		if (_arguments.length !== length)
-			return false;
-		for(var index = 0; index < length; index++) {
-			if (!expectedArguments[index](_arguments[index])) {
-				return false;
-			}
-		}
-		return true;
-	}
-		
-	mock.expect = function(argument) { 	
-		if (typeof argument === 'undefined')
-			return mock;
- 		var argumentVerifier = sameArgumentVerifier(argument);		
-		expectedArguments.push(argumentVerifier);
-		return mock;
-	};
-
-	function sameArgumentVerifier(argument) {
-		function verifyArgument(actualArgument) 
-		{
-			return actualArgument === argument;
-		}
-		return verifyArgument;
-	}
-
-	mock.expectAnything = function() {
-		expectedArguments.push(verifyAnyArgument);
-		return mock;
-	}
-
-	function verifyAnyArgument(arg) 
-	{
-		return true;
-	}	
-
-	mock.return = function(returnValue) {
-		curMock.returnValue = returnValue;
-		curMock.args = expectedArguments;
-		curMock.repeat = 1;
-		mockArray.push(curMock);
-		curMock = {};		
-		curMock.whenCalledEmitter = emitter();
-		expectedArguments = [];
-
-		return mock;		
-	};
-
-	mock.repeat = function(times) {
-		lastMock().repeat = times-1;
-	}
-
-	mock.repeatAny = function() {
-		lastMock().repeatAny = true;
-	}
-
-	mock.whenCalled = function(subscriber) {
-		curMock.whenCalledEmitter.setSubscriber(subscriber);
-		return mock;
-	}
-
-	function lastMock() {
-		var length = mockArray.length;
-		return mockArray[length-1];
-	}
-
-	mock.reset = function() {
-		mockArray = [];
-	};
-
-	return mock;
-}
-
-module.exports = create;
-
-
+function create(originalFunc) {
+	
+	var candidateMock;
+	var mockArray  = [];
+	var curMock = {};
+	var expectedArguments = [];
+	curMock.whenCalledEmitter = emitter();
+	var _arguments;
+
+	function emitter() {
+		var callback = function() {};
+		var c = {};
+		
+		c.setSubscriber = function(subscriber) {
+			callback = subscriber;
+		}
+
+		c.emit = function() {
+			callback.apply(null,_arguments);	
+		}
+		return c;
+	}
+
+	function mock() {
+		_arguments = arguments;
+		for(var index = 0;index < mockArray.length;index++) {		
+			candidateMock = mockArray[index];
+			if (correctArgs()) {
+				candidateMock.whenCalledEmitter.emit();
+				negotiateRemove(index);
+				return candidateMock.returnValue;
+			}
+		}
+		return originalFunc.apply(null,_arguments);
+	};
+
+	function negotiateRemove(indexOfMock) {
+		if (candidateMock.repeatAny)
+			return;
+		candidateMock.repeat--;
+		if (candidateMock.repeat == 0)
+			mockArray.splice(indexOfMock,1);
+	}
+
+	function correctArgs() {
+		var expectedArguments = candidateMock.args;
+
+		var length = expectedArguments.length;
+		if (_arguments.length !== length)
+			return false;
+		for(var index = 0; index < length; index++) {
+			if (!expectedArguments[index](_arguments[index])) {
+				return false;
+			}
+		}
+		return true;
+	}
+		
+	mock.expect = function(argument) { 	
+		if (typeof argument === 'undefined')
+			return mock;
+ 		var argumentVerifier = sameArgumentVerifier(argument);		
+		expectedArguments.push(argumentVerifier);
+		return mock;
+	};
+
+	function sameArgumentVerifier(argument) {
+		function verifyArgument(actualArgument) 
+		{
+			return actualArgument === argument;
+		}
+		return verifyArgument;
+	}
+
+	mock.expectAnything = function() {
+		expectedArguments.push(verifyAnyArgument);
+		return mock;
+	}
+
+	function verifyAnyArgument(arg) 
+	{
+		return true;
+	}	
+
+	mock.return = function(returnValue) {
+		curMock.returnValue = returnValue;
+		curMock.args = expectedArguments;
+		curMock.repeat = 1;
+		mockArray.push(curMock);
+		curMock = {};		
+		curMock.whenCalledEmitter = emitter();
+		expectedArguments = [];
+
+		return mock;		
+	};
+
+	mock.repeat = function(times) {
+		lastMock().repeat = times-1;
+	}
+
+	mock.repeatAny = function() {
+		lastMock().repeatAny = true;
+	}
+
+	mock.whenCalled = function(subscriber) {
+		curMock.whenCalledEmitter.setSubscriber(subscriber);
+		return mock;
+	}
+
+	function lastMock() {
+		var length = mockArray.length;
+		return mockArray[length-1];
+	}
+
+	mock.reset = function() {
+		mockArray = [];
+	};
+
+	return mock;
+}
+
+module.exports = create;
+
+

package/partialMock/simple/newPartialMockSpec/test.js

@@ -1,141 +1,141 @@
-var newSut = require('../newPartialMock');
-var assert = require('assert');
-var test = require('../../../test');
-
-		var originalReturnValue = {orig:''};
-		function original() {
-			return originalReturnValue;
-		}
-
-		var foo ={foo:''};
-		var baz = {baz:''};		
-
-
-(function(){
-	console.log('partialMockSpec');
-
-	(function() {		
-		console.log('expect return foo once');
-		
-		var sut = newSut(original);
-
-		sut.expect().return(foo);
-
-		var firstReturned = sut();
-		var secondReturned = sut();
-		var thirdReturned = sut();
-
-		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 original third time', function(){
-			assert.equal(originalReturnValue,thirdReturned);
-    	});
-
-	})();
-
-	(function() {		
-		console.log('expect return foo twice');		
-		var sut = newSut(original);
-		sut.expect().return(foo);
-		sut.expect().return(foo);
-
-		var firstReturned = sut();
-		var secondReturned = sut();
-		var thirdReturned = sut();
-
-		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 after reset');		
-		var sut = newSut(original);
-		sut.expect().return(foo);
-		sut.expect().return(foo);
-
-		var firstReturned = sut();
-		sut.reset();
-		var secondReturned = sut();
-		sut.expect().return(foo);
-		var thirdReturned = sut();
-
-		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 foo third time', function(){
-			assert.equal(foo,thirdReturned);
-    	});
-
-	})();
-
-	(function() {		
-		console.log('expect return foo then baz');		
-		var sut = newSut(original);
-		sut.expect().return(foo);
-		sut.expect().return(baz);
-
-		var firstReturned = sut();
-		var secondReturned = sut();
-		var thirdReturned = sut();
-
-		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 return when argument is undefined.');	
-		var sut = newSut(original);
-		var arg = {};
-		var someUndefined;
-		sut.expect(arg).expectAnything().return(foo);
-		sut.expect().return(baz);
-
-		var firstReturned = sut(arg);
-		var secondReturned = sut(arg,someUndefined);
-		var thirdReturned = sut(arg,someUndefined);
-
-		test('it should execute returns original first time', function(){
-			assert.equal(originalReturnValue,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);
-    	});
-
-	})();
-})();
+var newSut = require('../newPartialMock');
+var assert = require('assert');
+var test = require('../../../test');
+
+		var originalReturnValue = {orig:''};
+		function original() {
+			return originalReturnValue;
+		}
+
+		var foo ={foo:''};
+		var baz = {baz:''};		
+
+
+(function(){
+	console.log('partialMockSpec');
+
+	(function() {		
+		console.log('expect return foo once');
+		
+		var sut = newSut(original);
+
+		sut.expect().return(foo);
+
+		var firstReturned = sut();
+		var secondReturned = sut();
+		var thirdReturned = sut();
+
+		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 original third time', function(){
+			assert.equal(originalReturnValue,thirdReturned);
+    	});
+
+	})();
+
+	(function() {		
+		console.log('expect return foo twice');		
+		var sut = newSut(original);
+		sut.expect().return(foo);
+		sut.expect().return(foo);
+
+		var firstReturned = sut();
+		var secondReturned = sut();
+		var thirdReturned = sut();
+
+		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 after reset');		
+		var sut = newSut(original);
+		sut.expect().return(foo);
+		sut.expect().return(foo);
+
+		var firstReturned = sut();
+		sut.reset();
+		var secondReturned = sut();
+		sut.expect().return(foo);
+		var thirdReturned = sut();
+
+		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 foo third time', function(){
+			assert.equal(foo,thirdReturned);
+    	});
+
+	})();
+
+	(function() {		
+		console.log('expect return foo then baz');		
+		var sut = newSut(original);
+		sut.expect().return(foo);
+		sut.expect().return(baz);
+
+		var firstReturned = sut();
+		var secondReturned = sut();
+		var thirdReturned = sut();
+
+		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 return when argument is undefined.');	
+		var sut = newSut(original);
+		var arg = {};
+		var someUndefined;
+		sut.expect(arg).expectAnything().return(foo);
+		sut.expect().return(baz);
+
+		var firstReturned = sut(arg);
+		var secondReturned = sut(arg,someUndefined);
+		var thirdReturned = sut(arg,someUndefined);
+
+		test('it should execute returns original first time', function(){
+			assert.equal(originalReturnValue,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);
+    	});
+
+	})();
+})();

package/partialMock/simple/newPartialMockSpec/testRepeat.js

@@ -1,63 +1,63 @@
-var newSut = require('../newPartialMock');
-var assert = require('assert');
-var test = require('../../../test');
-		var originalReturnValue = {orig:''};
-		function original() {
-			return originalReturnValue;
-		}
-
-		var foo ={foo:''};
-		var baz = {baz:''};		
-
-
-(function(){
-	console.log('partialMockSpec.repeat.');
-
-	(function() {		
-		console.log('expect return foo three times.');
-		var sut = newSut(original);
-
-		sut.expect().return(foo).repeat(3);
-
-		var firstReturned = sut();
-		var secondReturned = sut();
-		var thirdReturned = sut();
-
-		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 any.');
-		var sut = newSut(original);
-
-		sut.expect().return(foo).repeatAny();
-
-		var firstReturned = sut();
-		var secondReturned = sut();
-		var thirdReturned = sut();
-
-		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 foo third time', function(){
-			assert.equal(foo,thirdReturned);
-    	});
-
-	})();
-})();
+var newSut = require('../newPartialMock');
+var assert = require('assert');
+var test = require('../../../test');
+		var originalReturnValue = {orig:''};
+		function original() {
+			return originalReturnValue;
+		}
+
+		var foo ={foo:''};
+		var baz = {baz:''};		
+
+
+(function(){
+	console.log('partialMockSpec.repeat.');
+
+	(function() {		
+		console.log('expect return foo three times.');
+		var sut = newSut(original);
+
+		sut.expect().return(foo).repeat(3);
+
+		var firstReturned = sut();
+		var secondReturned = sut();
+		var thirdReturned = sut();
+
+		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 any.');
+		var sut = newSut(original);
+
+		sut.expect().return(foo).repeatAny();
+
+		var firstReturned = sut();
+		var secondReturned = sut();
+		var thirdReturned = sut();
+
+		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 foo third time', function(){
+			assert.equal(foo,thirdReturned);
+    	});
+
+	})();
+})();