a_mock 1.0.4 → 2.0.0

package/partialMock/expectAnything.js

@@ -1,52 +1,52 @@
-function expectAnything(index,mockContext) {
-	var expect = require('./expect');
-	var expectAnything = require('./expectAnything');
-	var expectArray = require('./expectArray');
-	var _return = require('./return');
-	var newThrow = require('./newThrow');
-	var hasCorrectArgument = require('../and');
-	mockContext.whenCalledEmitter = require('../eventEmitter')();
-
-	var c = {};
-	mockContext.compositeAreCorrectArguments.add(hasCorrectArgument);
-	mockContext.expectAnything = true;
-	mockContext.numberOfArgs = index+1;
-
-	c.expect = function() {
-		var args = [index+1,mockContext];
-		for (var i = 0; i < arguments.length; i++) {
-			args.push(arguments[i]);
-		};
-		return expect.apply(null,args);
-	};
-
-	c.expectAnything = function() {
-		return c;
-	}
-
-	c.return = function(arg) {
-		return _return(arg,index+1,mockContext);
-	};
-
-	c.whenCalled = function(callback) {
-		mockContext.whenCalledEmitter.add(callback);
-		return c;
-	};
-
-	c.repeat = function(times) {
-		return _return(undefined,index+1,mockContext).repeat(times);
-	};
-
-	c.throw = function(error) {
-		var _throw = newThrow(error);
-		return c.whenCalled(_throw);	
-	};
-
-	c.repeatAny = function() {
-		return _return(undefined,index+1,mockContext).repeatAny();
-	};
-
-	return c;
-}
-
+function expectAnything(index,mockContext) {
+	var expect = require('./expect');
+	var expectAnything = require('./expectAnything');
+	var expectArray = require('./expectArray');
+	var _return = require('./return');
+	var newThrow = require('./newThrow');
+	var hasCorrectArgument = require('../and');
+	mockContext.whenCalledEmitter = require('../eventEmitter')();
+
+	var c = {};
+	mockContext.compositeAreCorrectArguments.add(hasCorrectArgument);
+	mockContext.expectAnything = true;
+	mockContext.numberOfArgs = index+1;
+
+	c.expect = function() {
+		var args = [index+1,mockContext];
+		for (var i = 0; i < arguments.length; i++) {
+			args.push(arguments[i]);
+		};
+		return expect.apply(null,args);
+	};
+
+	c.expectAnything = function() {
+		return c;
+	}
+
+	c.return = function(arg) {
+		return _return(arg,index+1,mockContext);
+	};
+
+	c.whenCalled = function(callback) {
+		mockContext.whenCalledEmitter.add(callback);
+		return c;
+	};
+
+	c.repeat = function(times) {
+		return _return(undefined,index+1,mockContext).repeat(times);
+	};
+
+	c.throw = function(error) {
+		var _throw = newThrow(error);
+		return c.whenCalled(_throw);	
+	};
+
+	c.repeatAny = function() {
+		return _return(undefined,index+1,mockContext).repeatAny();
+	};
+
+	return c;
+}
+
 module.exports = expectAnything;

package/partialMock/expectAnythingSpec/test.js

@@ -1,167 +1,167 @@
-var assert = require('assert');
-var test = require('../../test');
-var newMock = require('../simple/newMock');
-var newRequireMock = require('../simple/newRequireMock');
-
-var _return = newRequireMock('./return');
-var newWhenCalledEmitter = newRequireMock('../eventEmitter');
-var newThrow = newRequireMock('./newThrow');
-var hasCorrectArgument = newRequireMock('../and');
-
-var sut = require('../expectAnything');
-
-
-(function(){
-	console.log('expectAnything');
-	var mockContext = {};
-	var compositeAreCorrectArguments = newMock();
-	var whenCalledEmitter = {}	;
-	var index = 1;
-	var didAdd;
-
-	stubWhenCalledEmitter();
-	stubMockContext();
-	stubCompositeAreCorrectArguments();
-
-	function stubWhenCalledEmitter() {
-		newWhenCalledEmitter.expect().return(whenCalledEmitter);		
-	}
-
-	function stubMockContext() {
-		mockContext.compositeAreCorrectArguments = compositeAreCorrectArguments;		
-	}
-
-	function stubCompositeAreCorrectArguments() {
-		var add = newMock();
-		add.expect(hasCorrectArgument).whenCalled(onAdd).return(null);
-		compositeAreCorrectArguments.add = add;		
-	}
-
-	function onAdd() {
-		didAdd = true;
-	}
-
-	var sut2 = sut(index,mockContext);
-
-	test('it should set mockContext.NumberOfArgs to index+1',function() {
-		assert.equal(mockContext.numberOfArgs,index+1); 
-	});
-
-	test('it should set mockContext.expectAnything',function() {
-		assert(mockContext.expectAnything); 
-	});
-
-	test('it should add areSameArgument to compositeAreCorrectArguments',function() {
-		assert.ok(didAdd);
-	});
-
-	test('it should set mockContext.whenCalledEmitter',function() {
-		assert.equal(mockContext.whenCalledEmitter,whenCalledEmitter);
-	});
-
-	test('expectAnything should return self',function() {
-		assert.equal(sut2, sut2.expectAnything());
-	});
-
-
-
-	(function() {
-		console.log('return');
-		var expected = {};
-		var arg = {};
-		_return.expect(arg).expect(index+1).expect(mockContext).return(expected);
-		var returned = sut2.return(arg); 
-
-		test('should return expected',function() {
-			assert.equal(returned,expected)
-		});
-	})();
-
-	(function() {
-		console.log('whenCalled');
-		var callback = {};
-		var expected;
-		var add = newMock();
-		whenCalledEmitter.add = add;
-		var didAddCallback;
-		add.expect(callback).whenCalled(onAddCallback).return();
-
-		function onAddCallback() {
-			didAddCallback = true;
-		}
-
-		mockContext.whenCalledEmitter = whenCalledEmitter;
-				
-		var returned = sut2.whenCalled(callback); 
-
-		test('should add callback to whenCalledEmitter',function() {
-			assert.ok(didAddCallback)
-		});
-
-		test('should return self',function() {
-			assert.equal(returned,sut2);
-		});
-	})();
-
-	(function() {
-		console.log('throw');
-		var error = {};
-		var _throw = {};
-		var expected = {};
-		newThrow.expect(error).return(_throw);				
-		sut2.whenCalled = newMock();
-		sut2.whenCalled.expect(_throw).return(expected);
-		var returned = sut2.throw(error); 
-
-		test('should return expected',function() {
-			assert.equal(expected,returned);
-		});
-	})();
-
-
-	(function() {
-		console.log('repeat');
-		var expected = {};
-		var times = 2;
-		var returnContext = {};
-		var repeatMock = newMock();
-		_return.expectAnything().expect(index+1).expect(mockContext).whenCalled(onReturn).return(returnContext);
-		
-		function onReturn(returnValue) {
-			if (returnValue !== undefined)
-				throw new Error('unexpected argument');
-		}
-
-		returnContext.repeat = repeatMock;
-		repeatMock.expect(times).return(expected);
-
-		var returned = sut2.repeat(times); 
-
-		test('should return expected',function() {
-			assert.equal(returned,expected)
-		});
-	})();
-
-	(function() {
-		console.log('repeatAny');
-		var expected = {};
-		var returnContext = {};
-		var repeatMock = newMock();
-		_return.expectAnything().expect(index+1).expect(mockContext).whenCalled(onReturn).return(returnContext);
-		
-		function onReturn(returnValue) {
-			if (returnValue !== undefined)
-				throw new Error('unexpected argument');
-		}
-
-		returnContext.repeatAny = repeatMock;
-		repeatMock.expect().return(expected);
-
-		var returned = sut2.repeatAny(); 
-
-		test('should return expected',function() {
-			assert.equal(returned,expected)
-		});
-	})();
-
-})();
+var assert = require('assert');
+var test = require('../../test');
+var newMock = require('../simple/newMock');
+var newRequireMock = require('../simple/newRequireMock');
+
+var _return = newRequireMock('./return');
+var newWhenCalledEmitter = newRequireMock('../eventEmitter');
+var newThrow = newRequireMock('./newThrow');
+var hasCorrectArgument = newRequireMock('../and');
+
+var sut = require('../expectAnything');
+
+
+(function(){
+	console.log('expectAnything');
+	var mockContext = {};
+	var compositeAreCorrectArguments = newMock();
+	var whenCalledEmitter = {}	;
+	var index = 1;
+	var didAdd;
+
+	stubWhenCalledEmitter();
+	stubMockContext();
+	stubCompositeAreCorrectArguments();
+
+	function stubWhenCalledEmitter() {
+		newWhenCalledEmitter.expect().return(whenCalledEmitter);		
+	}
+
+	function stubMockContext() {
+		mockContext.compositeAreCorrectArguments = compositeAreCorrectArguments;		
+	}
+
+	function stubCompositeAreCorrectArguments() {
+		var add = newMock();
+		add.expect(hasCorrectArgument).whenCalled(onAdd).return(null);
+		compositeAreCorrectArguments.add = add;		
+	}
+
+	function onAdd() {
+		didAdd = true;
+	}
+
+	var sut2 = sut(index,mockContext);
+
+	test('it should set mockContext.NumberOfArgs to index+1',function() {
+		assert.equal(mockContext.numberOfArgs,index+1); 
+	});
+
+	test('it should set mockContext.expectAnything',function() {
+		assert(mockContext.expectAnything); 
+	});
+
+	test('it should add areSameArgument to compositeAreCorrectArguments',function() {
+		assert.ok(didAdd);
+	});
+
+	test('it should set mockContext.whenCalledEmitter',function() {
+		assert.equal(mockContext.whenCalledEmitter,whenCalledEmitter);
+	});
+
+	test('expectAnything should return self',function() {
+		assert.equal(sut2, sut2.expectAnything());
+	});
+
+
+
+	(function() {
+		console.log('return');
+		var expected = {};
+		var arg = {};
+		_return.expect(arg).expect(index+1).expect(mockContext).return(expected);
+		var returned = sut2.return(arg); 
+
+		test('should return expected',function() {
+			assert.equal(returned,expected)
+		});
+	})();
+
+	(function() {
+		console.log('whenCalled');
+		var callback = {};
+		var expected;
+		var add = newMock();
+		whenCalledEmitter.add = add;
+		var didAddCallback;
+		add.expect(callback).whenCalled(onAddCallback).return();
+
+		function onAddCallback() {
+			didAddCallback = true;
+		}
+
+		mockContext.whenCalledEmitter = whenCalledEmitter;
+				
+		var returned = sut2.whenCalled(callback); 
+
+		test('should add callback to whenCalledEmitter',function() {
+			assert.ok(didAddCallback)
+		});
+
+		test('should return self',function() {
+			assert.equal(returned,sut2);
+		});
+	})();
+
+	(function() {
+		console.log('throw');
+		var error = {};
+		var _throw = {};
+		var expected = {};
+		newThrow.expect(error).return(_throw);				
+		sut2.whenCalled = newMock();
+		sut2.whenCalled.expect(_throw).return(expected);
+		var returned = sut2.throw(error); 
+
+		test('should return expected',function() {
+			assert.equal(expected,returned);
+		});
+	})();
+
+
+	(function() {
+		console.log('repeat');
+		var expected = {};
+		var times = 2;
+		var returnContext = {};
+		var repeatMock = newMock();
+		_return.expectAnything().expect(index+1).expect(mockContext).whenCalled(onReturn).return(returnContext);
+		
+		function onReturn(returnValue) {
+			if (returnValue !== undefined)
+				throw new Error('unexpected argument');
+		}
+
+		returnContext.repeat = repeatMock;
+		repeatMock.expect(times).return(expected);
+
+		var returned = sut2.repeat(times); 
+
+		test('should return expected',function() {
+			assert.equal(returned,expected)
+		});
+	})();
+
+	(function() {
+		console.log('repeatAny');
+		var expected = {};
+		var returnContext = {};
+		var repeatMock = newMock();
+		_return.expectAnything().expect(index+1).expect(mockContext).whenCalled(onReturn).return(returnContext);
+		
+		function onReturn(returnValue) {
+			if (returnValue !== undefined)
+				throw new Error('unexpected argument');
+		}
+
+		returnContext.repeatAny = repeatMock;
+		repeatMock.expect().return(expected);
+
+		var returned = sut2.repeatAny(); 
+
+		test('should return expected',function() {
+			assert.equal(returned,expected)
+		});
+	})();
+
+})();

package/partialMock/expectArray.js

@@ -1,12 +1,12 @@
-yellow = '\u001b[33m',
-reset = '\u001b[0m';
-
-function expectArray(index,mockContext,array) {
-	console.log('\n%s%s%s', yellow, 'expectArray is deprecated, use expect instead.', reset);	
-	var newHasEqualArgumentArray = require('./newHasEqualArgumentArray');
-	var expectCore = require('./expectCore');
-	var isCorrectArgument = newHasEqualArgumentArray(array,index);	
-	return expectCore(isCorrectArgument,index,mockContext);
-}
-
+yellow = '\u001b[33m',
+reset = '\u001b[0m';
+
+function expectArray(index,mockContext,array) {
+	console.log('\n%s%s%s', yellow, 'expectArray is deprecated, use expect instead.', reset);	
+	var newHasEqualArgumentArray = require('./newHasEqualArgumentArray');
+	var expectCore = require('./expectCore');
+	var isCorrectArgument = newHasEqualArgumentArray(array,index);	
+	return expectCore(isCorrectArgument,index,mockContext);
+}
+
 module.exports = expectArray;

package/partialMock/expectArraySpec/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 expectCore  = newRequireMock('./expectCore');
-var newHasEqualArgumentArray = newRequireMock('./newHasEqualArgumentArray');
-
-var sut = require('../expectArray');
-
-(function() {
-	console.log('expect');
-	var mockContext = {};
-	var isCorrectArgument = newMock();	
-	var argArray = []; 
-	var index = 0;
-	var expected = {};
-
-	stubHasEqualArgumentArray();
-	stubExpectCore();
-
-	function stubHasEqualArgumentArray() {
-		newHasEqualArgumentArray.expect(argArray).expect(index).return(isCorrectArgument);
-	}
-
-	function stubExpectCore() {
-		expectCore.expect(isCorrectArgument).expect(index).expect(mockContext).return(expected);
-	}
-
-	var returned = sut(index,mockContext,argArray);
-
-	test('it should return expected',function() {
-		assert.equal(expected,returned);
-	});
-
-})();
+var assert = require('assert');
+var test = require('../../test');
+var newMock = require('../simple/newMock');
+var newRequireMock = require('../simple/newRequireMock');
+
+var expectCore  = newRequireMock('./expectCore');
+var newHasEqualArgumentArray = newRequireMock('./newHasEqualArgumentArray');
+
+var sut = require('../expectArray');
+
+(function() {
+	console.log('expect');
+	var mockContext = {};
+	var isCorrectArgument = newMock();	
+	var argArray = []; 
+	var index = 0;
+	var expected = {};
+
+	stubHasEqualArgumentArray();
+	stubExpectCore();
+
+	function stubHasEqualArgumentArray() {
+		newHasEqualArgumentArray.expect(argArray).expect(index).return(isCorrectArgument);
+	}
+
+	function stubExpectCore() {
+		expectCore.expect(isCorrectArgument).expect(index).expect(mockContext).return(expected);
+	}
+
+	var returned = sut(index,mockContext,argArray);
+
+	test('it should return expected',function() {
+		assert.equal(expected,returned);
+	});
+
+})();

package/partialMock/expectCore.js

@@ -1,60 +1,71 @@
-function expect(hasCorrectArgument,index,mockContext) {
-	var expect = require('./expect');
-	var expectAnything = require('./expectAnything');
-	var ignore = require('./ignore');
-	var expectArray = require('./expectArray');
-	var _return = require('./return');
-	var newThrow = require('./newThrow');
-	mockContext.whenCalledEmitter = require('../eventEmitter')();
-
-
-	var c = {};
-	mockContext.compositeAreCorrectArguments.add(hasCorrectArgument);
-	mockContext.numberOfArgs = index+1;
-
-	c.expect = function() {
-		var args = [index+1,mockContext];
-		for (var i = 0; i < arguments.length; i++) {
-			args.push(arguments[i]);
-		};
-		return expect.apply(null,args);
-	};
-
-	c.expectAnything = function() {
-		return expectAnything(index+1,mockContext);
-	};
-
-	c.ignore = function() {
-		return ignore(index+1,mockContext);
-	}
-
-	c.expectArray = function(array) {
-		return expectArray(index+1,mockContext,array);
-	}
-
-	c.return = function(arg) {
-		return _return(arg,index+1,mockContext);
-	};
-
-	c.whenCalled = function(callback) {
-		mockContext.whenCalledEmitter.add(callback);
-		return c;
-	};
-
-	c.repeat = function(times) {
-		return _return(undefined,index+1,mockContext).repeat(times);
-	};
-
-	c.throw = function(error) {
-		var _throw = newThrow(error);
-		return c.whenCalled(_throw);	
-	};
-
-	c.repeatAny = function() {
-		return _return(undefined,index+1,mockContext).repeatAny();
-	};
-
-	return c;
-}
-
+function expect(hasCorrectArgument,index,mockContext) {
+	var expect = require('./expect');
+	var expectAnything = require('./expectAnything');
+	var ignore = require('./ignore');
+	var expectArray = require('./expectArray');
+	var _return = require('./return');
+	var newThrow = require('./newThrow');
+	var newThen = require('../newThen');
+	mockContext.whenCalledEmitter = require('../eventEmitter')();
+
+
+	var c = {};
+	mockContext.compositeAreCorrectArguments.add(hasCorrectArgument);
+	mockContext.numberOfArgs = index+1;
+
+	c.expect = function() {
+		var args = [index+1,mockContext];
+		for (var i = 0; i < arguments.length; i++) {
+			args.push(arguments[i]);
+		};
+		return expect.apply(null,args);
+	};
+
+	c.expectAnything = function() {
+		return expectAnything(index+1,mockContext);
+	};
+
+	c.ignore = function() {
+		return ignore(index+1,mockContext);
+	}
+
+	c.expectArray = function(array) {
+		return expectArray(index+1,mockContext,array);
+	}
+
+	c.return = function(arg) {
+		return _return(arg,index+1,mockContext);
+	};
+
+	c.whenCalled = function(callback) {
+		mockContext.whenCalledEmitter.add(callback);
+		return c;
+	};
+
+	c.repeat = function(times) {
+		return _return(undefined,index+1,mockContext).repeat(times);
+	};
+
+	c.throw = function(error) {
+		var _throw = newThrow(error);
+		return c.whenCalled(_throw);	
+	};
+
+	c.repeatAny = function() {
+		return _return(undefined,index+1,mockContext).repeatAny();
+	};
+
+	c.resolve = function(value) {
+		var promise = newThen.resolve(value);
+		return c.return(promise);
+	};
+
+	c.reject = function(value) {
+		var promise = newThen.reject(value);
+		return c.return(promise);
+	};
+
+	return c;
+}
+
 module.exports = expect;