a_mock 1.0.5 → 2.0.1

package/partialMock/newFallbackWrapperSpec/test.js

@@ -1,70 +1,70 @@
-var assert = require('assert');
-var test = require('../../test');
-var newMock = require('../simple/newMock');
-var newRequireMock = require('../simple/newRequireMock');
-var getStackTrace = newRequireMock('./fallbackWrapper/getStackTrace');
-var newSut = require('../newFallbackWrapper');
-
-(function() {
-	console.log('newFallbackWrapper');
-	
-	var originalFallback = newMock();
-	var sut = newSut(originalFallback);
-	var didIncrementStackTrace
-	var originalStackTraceLimit = Error.stackTraceLimit;
-
-	(function() {
-		console.log('execute');
-		var arg = {};		
-		var expected = {};
-			
-		originalFallback.expect(arg).whenCalled(onFallback).return(expected);
-		var returned = sut(arg);
-
-		test('it increments stack trace limit by two before executing fallback', function() {
-			assert.ok(didIncrementStackTrace,expected);
-		});
-
-		test('it should result from originalFallback',function() {
-			assert.equal(returned,expected);
-		});
-
-		test('it resets stack trace limit', function() {
-			assert.equal(Error.stackTraceLimit,originalStackTraceLimit);
-		});
-
-
-		(function() {
-			console.log('setFallback');
-			var fallback = newMock();			
-			sut.setFallback(fallback);
-
-			(function() {
-				console.log('execute');
-				didIncrementStackTrace = false;
-				var expected = {};
-				fallback.expect(arg).whenCalled(onFallback).return(expected);
-				var returned = sut(arg);
-				
-
-				test('it increments stack trace limit by two before executing fallback', function() {
-					assert.ok(didIncrementStackTrace);
-				});
-
-				test('it should return result from new fallback',function() {
-					assert.equal(returned,expected);
-				});
-
-				test('it resets stack trace limit', function() {
-					assert.equal(Error.stackTraceLimit,originalStackTraceLimit);
-				});
-			})();
-		})();
-	})();
-
-	function onFallback() {
-		didIncrementStackTrace = (Error.stackTraceLimit == originalStackTraceLimit + 2);
-	}
-
-
-})();
+var assert = require('assert');
+var test = require('../../test');
+var newMock = require('../simple/newMock');
+var newRequireMock = require('../simple/newRequireMock');
+var getStackTrace = newRequireMock('./fallbackWrapper/getStackTrace');
+var newSut = require('../newFallbackWrapper');
+
+(function() {
+	console.log('newFallbackWrapper');
+	
+	var originalFallback = newMock();
+	var sut = newSut(originalFallback);
+	var didIncrementStackTrace
+	var originalStackTraceLimit = Error.stackTraceLimit;
+
+	(function() {
+		console.log('execute');
+		var arg = {};		
+		var expected = {};
+			
+		originalFallback.expect(arg).whenCalled(onFallback).return(expected);
+		var returned = sut(arg);
+
+		test('it increments stack trace limit by two before executing fallback', function() {
+			assert.ok(didIncrementStackTrace,expected);
+		});
+
+		test('it should result from originalFallback',function() {
+			assert.equal(returned,expected);
+		});
+
+		test('it resets stack trace limit', function() {
+			assert.equal(Error.stackTraceLimit,originalStackTraceLimit);
+		});
+
+
+		(function() {
+			console.log('setFallback');
+			var fallback = newMock();			
+			sut.setFallback(fallback);
+
+			(function() {
+				console.log('execute');
+				didIncrementStackTrace = false;
+				var expected = {};
+				fallback.expect(arg).whenCalled(onFallback).return(expected);
+				var returned = sut(arg);
+				
+
+				test('it increments stack trace limit by two before executing fallback', function() {
+					assert.ok(didIncrementStackTrace);
+				});
+
+				test('it should return result from new fallback',function() {
+					assert.equal(returned,expected);
+				});
+
+				test('it resets stack trace limit', function() {
+					assert.equal(Error.stackTraceLimit,originalStackTraceLimit);
+				});
+			})();
+		})();
+	})();
+
+	function onFallback() {
+		didIncrementStackTrace = (Error.stackTraceLimit == originalStackTraceLimit + 2);
+	}
+
+
+})();

package/partialMock/newFallbackWrapperSpec/testWithMockError.js

@@ -1,59 +1,59 @@
-var assert = require('assert');
-var test = require('../../test');
-var newMock = require('../simple/newMock');
-var newRequireMock = require('../simple/newRequireMock');
-var getStackTrace = newRequireMock('./fallbackWrapper/getStackTrace');
-var newSut = require('../newFallbackWrapper');
-
-(function() {
-	console.log('newFallbackWrapper');	
-	var sut = newSut(originalFallback);
-	var didIncrementStackTrace
-	var originalStackTraceLimit = Error.stackTraceLimit;
-
-	function originalFallback() {
-			didIncrementStackTrace = (Error.stackTraceLimit == originalStackTraceLimit + 2);
-			var e = new Error();
-			e.name = 'Mock Error';
-			e.message = 'message';
-			throw e;
-	}
-
-	(function() {
-		console.log('execute with mock error');
-		var arg = {};				
-		var error;
-		var stackTrace = 'stackTrace';
-		var expectedTrace = 'Mock Error: message\nstackTrace';
-		
-		getStackTrace.expect().return(stackTrace);
-		try {
-			sut(arg);
-		}
-		catch(e) {
-			error = e;
-		}
-		
-
-		function onFallback() {
-			didIncrementStackTrace = (Error.stackTraceLimit == originalStackTraceLimit + 2);
-			var e = new Error();
-			e.name = 'Mock Error';
-			e.message = 'message';
-			throw e;
-		}
-
-
-		test('it increments stack trace limit by two before executing fallback', function() {
-			assert.ok(didIncrementStackTrace);
-		});
-
-		test('it should set stack on error',function() {
-			assert.equal(error.stack,expectedTrace);
-		});
-
-		test('it resets stack trace limit', function() {
-			assert.equal(Error.stackTraceLimit,originalStackTraceLimit);
-		});
-	})();
-})();
+var assert = require('assert');
+var test = require('../../test');
+var newMock = require('../simple/newMock');
+var newRequireMock = require('../simple/newRequireMock');
+var getStackTrace = newRequireMock('./fallbackWrapper/getStackTrace');
+var newSut = require('../newFallbackWrapper');
+
+(function() {
+	console.log('newFallbackWrapper');	
+	var sut = newSut(originalFallback);
+	var didIncrementStackTrace
+	var originalStackTraceLimit = Error.stackTraceLimit;
+
+	function originalFallback() {
+			didIncrementStackTrace = (Error.stackTraceLimit == originalStackTraceLimit + 2);
+			var e = new Error();
+			e.name = 'Mock Error';
+			e.message = 'message';
+			throw e;
+	}
+
+	(function() {
+		console.log('execute with mock error');
+		var arg = {};				
+		var error;
+		var stackTrace = 'stackTrace';
+		var expectedTrace = 'Mock Error: message\nstackTrace';
+		
+		getStackTrace.expect().return(stackTrace);
+		try {
+			sut(arg);
+		}
+		catch(e) {
+			error = e;
+		}
+		
+
+		function onFallback() {
+			didIncrementStackTrace = (Error.stackTraceLimit == originalStackTraceLimit + 2);
+			var e = new Error();
+			e.name = 'Mock Error';
+			e.message = 'message';
+			throw e;
+		}
+
+
+		test('it increments stack trace limit by two before executing fallback', function() {
+			assert.ok(didIncrementStackTrace);
+		});
+
+		test('it should set stack on error',function() {
+			assert.equal(error.stack,expectedTrace);
+		});
+
+		test('it resets stack trace limit', function() {
+			assert.equal(Error.stackTraceLimit,originalStackTraceLimit);
+		});
+	})();
+})();

package/partialMock/newFallbackWrapperSpec/testWithOtherError.js

@@ -1,48 +1,48 @@
-var assert = require('assert');
-var test = require('../../test');
-var newMock = require('../simple/newMock');
-var newRequireMock = require('../simple/newRequireMock');
-var getStackTrace = newRequireMock('./fallbackWrapper/getStackTrace');
-var newSut = require('../newFallbackWrapper');
-
-(function() {
-	console.log('newFallbackWrapper');	
-	var sut = newSut(originalFallback);
-	var didIncrementStackTrace
-	var originalStackTraceLimit = Error.stackTraceLimit;
-	var originalTrace = 'origTrace';
-	
-	function originalFallback() {
-		didIncrementStackTrace = (Error.stackTraceLimit == originalStackTraceLimit + 2);
-		
-		var e =  new Error('other');
-		e.stack = originalTrace;
-		throw e;
-	}
-
-	(function() {
-		console.log('execute with mock error');
-		var arg = {};				
-		var error;		
-			
-		try {
-			sut(arg);
-		}
-		catch(e) {
-			console.log('foo: ' + e.stack);
-			error = e;
-		}		
-
-		test('it increments stack trace limit by two before executing fallback', function() {
-			assert.ok(didIncrementStackTrace);
-		});
-
-		test('it should not change stack on error',function() {
-			assert.equal(error.stack,originalTrace);
-		});
-
-		test('it resets stack trace limit', function() {
-			assert.equal(Error.stackTraceLimit,originalStackTraceLimit);
-		});
-	})();
-})();
+var assert = require('assert');
+var test = require('../../test');
+var newMock = require('../simple/newMock');
+var newRequireMock = require('../simple/newRequireMock');
+var getStackTrace = newRequireMock('./fallbackWrapper/getStackTrace');
+var newSut = require('../newFallbackWrapper');
+
+(function() {
+	console.log('newFallbackWrapper');	
+	var sut = newSut(originalFallback);
+	var didIncrementStackTrace
+	var originalStackTraceLimit = Error.stackTraceLimit;
+	var originalTrace = 'origTrace';
+	
+	function originalFallback() {
+		didIncrementStackTrace = (Error.stackTraceLimit == originalStackTraceLimit + 2);
+		
+		var e =  new Error('other');
+		e.stack = originalTrace;
+		throw e;
+	}
+
+	(function() {
+		console.log('execute with mock error');
+		var arg = {};				
+		var error;		
+			
+		try {
+			sut(arg);
+		}
+		catch(e) {
+			console.log('foo: ' + e.stack);
+			error = e;
+		}		
+
+		test('it increments stack trace limit by two before executing fallback', function() {
+			assert.ok(didIncrementStackTrace);
+		});
+
+		test('it should not change stack on error',function() {
+			assert.equal(error.stack,originalTrace);
+		});
+
+		test('it resets stack trace limit', function() {
+			assert.equal(Error.stackTraceLimit,originalStackTraceLimit);
+		});
+	})();
+})();

package/partialMock/newHasArgument.js

@@ -1,10 +1,10 @@
-function _new(index) {
-	
-	function hasArgument(){
-		return arguments.length-1 >= index;
-	}
-
-	return hasArgument;
-}
-
+function _new(index) {
+	
+	function hasArgument(){
+		return arguments.length-1 >= index;
+	}
+
+	return hasArgument;
+}
+
 module.exports = _new;

package/partialMock/newHasArgumentSpec/test.js

@@ -1,36 +1,36 @@
-var assert = require('assert');
-var test = require('../../test');
-var newMock = require('../simple/newMock');
-var newRequireMock = require('../simple/newRequireMock');
-
-var newSut = require('../newHasArgument');
-
-
-(function() {
-	console.log('newHasArgument');
-	var index = 1;
-	
-	var sut = newSut(index);
-
-	(function() {
-		console.log('no arg.execute');
-		var returned = sut('a');
-
-		test('it should return false',function() {
-			assert.equal(false,returned);
-		});
-		
-	})();
-
-
-	(function() {
-		console.log('correct argument.execute');
-		var returned = sut('a','b');
-
-		test('it should return true',function() {
-			assert.equal(true,returned);
-		});
-
-	})();
-
-})();
+var assert = require('assert');
+var test = require('../../test');
+var newMock = require('../simple/newMock');
+var newRequireMock = require('../simple/newRequireMock');
+
+var newSut = require('../newHasArgument');
+
+
+(function() {
+	console.log('newHasArgument');
+	var index = 1;
+	
+	var sut = newSut(index);
+
+	(function() {
+		console.log('no arg.execute');
+		var returned = sut('a');
+
+		test('it should return false',function() {
+			assert.equal(false,returned);
+		});
+		
+	})();
+
+
+	(function() {
+		console.log('correct argument.execute');
+		var returned = sut('a','b');
+
+		test('it should return true',function() {
+			assert.equal(true,returned);
+		});
+
+	})();
+
+})();

package/partialMock/newHasEqualArgumentArray.js

@@ -1,24 +1,24 @@
-function _new(expectedArray,index) {
-	var array;
-	function hasEqualArgumentArray(){
-		array = arguments[index];		
-		return (array instanceof Array) && equalArrayLength() && equalElements();
-	}
-
-	function equalArrayLength() {
-		return (expectedArray.length == array.length);
-	}
-
-
-	function equalElements() {
-		for(var i = 0; i < expectedArray.length; i++) {
-			if (expectedArray[i] !== array[i])
-				return false;
-		}
-		return true;
-	}
-
-	return hasEqualArgumentArray;
-}
-
+function _new(expectedArray,index) {
+	var array;
+	function hasEqualArgumentArray(){
+		array = arguments[index];		
+		return (array instanceof Array) && equalArrayLength() && equalElements();
+	}
+
+	function equalArrayLength() {
+		return (expectedArray.length == array.length);
+	}
+
+
+	function equalElements() {
+		for(var i = 0; i < expectedArray.length; i++) {
+			if (expectedArray[i] !== array[i])
+				return false;
+		}
+		return true;
+	}
+
+	return hasEqualArgumentArray;
+}
+
 module.exports = _new;

package/partialMock/newHasEqualArgumentArraySpec/test.js

@@ -1,59 +1,59 @@
-var assert = require('assert');
-var test = require('../../test');
-var newMock = require('../simple/newMock');
-var newRequireMock = require('../simple/newRequireMock');
-
-var newSut = require('../newHasEqualArgumentArray');
-
-
-(function() {
-	console.log('newHasEqualArgumentArray');
-	var expectedElement1 = {};
-	var expectedElement2 = {};
-	var expectedArg = [expectedElement1,expectedElement2];
-	var index = 1;
-	
-	var sut = newSut(expectedArg,index);
-
-	(function() {
-		console.log('too few arguments.execute');
-		var returned = sut('arg');
-
-		test('it should return false',function() {
-			assert.equal(false,returned);
-		});
-		
-	})();
-
-	(function() {
-		console.log('incorrect argument.execute');
-		var returned = sut('arg',[expectedElement1,'wrongElement']);
-
-		test('it should return false',function() {
-			assert.equal(false,returned);
-		});
-
-	})();
-
-	(function() {
-		console.log('incorrect arrayLength.execute');
-		var returned = sut('arg',[expectedElement1,expectedElement2,'off-by-one']);
-
-		test('it should return false',function() {
-			assert.equal(false,returned);
-		});
-
-	})();
-
-
-	(function() {
-		console.log('correct argument.execute');
-		var returned = sut('arg',[expectedElement1,expectedElement2]);
-
-		test('it should return true',function() {
-			assert.equal(true,returned);
-		});
-
-	})();
-	
-})();
+var assert = require('assert');
+var test = require('../../test');
+var newMock = require('../simple/newMock');
+var newRequireMock = require('../simple/newRequireMock');
+
+var newSut = require('../newHasEqualArgumentArray');
+
+
+(function() {
+	console.log('newHasEqualArgumentArray');
+	var expectedElement1 = {};
+	var expectedElement2 = {};
+	var expectedArg = [expectedElement1,expectedElement2];
+	var index = 1;
+	
+	var sut = newSut(expectedArg,index);
+
+	(function() {
+		console.log('too few arguments.execute');
+		var returned = sut('arg');
+
+		test('it should return false',function() {
+			assert.equal(false,returned);
+		});
+		
+	})();
+
+	(function() {
+		console.log('incorrect argument.execute');
+		var returned = sut('arg',[expectedElement1,'wrongElement']);
+
+		test('it should return false',function() {
+			assert.equal(false,returned);
+		});
+
+	})();
+
+	(function() {
+		console.log('incorrect arrayLength.execute');
+		var returned = sut('arg',[expectedElement1,expectedElement2,'off-by-one']);
+
+		test('it should return false',function() {
+			assert.equal(false,returned);
+		});
+
+	})();
+
+
+	(function() {
+		console.log('correct argument.execute');
+		var returned = sut('arg',[expectedElement1,expectedElement2]);
+
+		test('it should return true',function() {
+			assert.equal(true,returned);
+		});
+
+	})();
+	
+})();

package/partialMock/newHasNoMoreArguments.js

@@ -1,16 +1,16 @@
-var empty = require('../and');
-
-function _new(maxLength, context) {
-	if (context.expectAnything) {
-		context.expectAnything = false;
-		return empty;	
-	}
-
-	function hasNoMoreArguments(){		
-		return (arguments.length == maxLength);
-	}
-
-	return hasNoMoreArguments;
-}
-
+var empty = require('../and');
+
+function _new(maxLength, context) {
+	if (context.expectAnything) {
+		context.expectAnything = false;
+		return empty;	
+	}
+
+	function hasNoMoreArguments(){		
+		return (arguments.length == maxLength);
+	}
+
+	return hasNoMoreArguments;
+}
+
 module.exports = _new;