a_mock 2.0.2 → 2.0.4

package/partialMock/simple/newPartialMockSpec/testWithMultiArgs.js

@@ -1,6 +1,6 @@
 var newSut = require('../newPartialMock');
 var assert = require('assert');
-var test = require('../../../test');
+var test = require('node:test');
 
 		var originalReturnValue = {};
 		var originalReturnValue2 = {};
@@ -18,10 +18,8 @@ var test = require('../../../test');
 
 
 (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) {
@@ -51,4 +49,4 @@ var test = require('../../../test');
 			assert.equal(1,callBackCount);
     	});
 	})();	
-})();
+})();

package/partialMock/simple/newPartialMockSpec/testWithSingleArg.js

@@ -1,6 +1,6 @@
 var newSut = require('../newPartialMock');
 var assert = require('assert');
-var test = require('../../../test');
+var test = require('node:test');
 
 		var originalReturnValue = {};
 		function original() {
@@ -13,10 +13,8 @@ var test = require('../../../test');
 
 
 (function(){
-	console.log('partialMockSpec');
 
 	(function() {		
-		console.log('expect return foo once.');		
 		var sut = newSut(original);
 		require('../newPartialMock')(function() {});
 		sut.expect(arg1).return(foo);
@@ -40,7 +38,6 @@ var test = require('../../../test');
 	})();
 
 	(function() {		
-		console.log('expect return foo twice.');
 		
 		var sut = newSut(original);
 		sut.expect(arg1).return(foo);
@@ -66,7 +63,6 @@ var test = require('../../../test');
 
 
 	(function() {		
-		console.log('expect return foo then baz');	
 		var sut = newSut(original);
 		sut.expect().return(foo);
 		sut.expect(arg1).return(baz);
@@ -90,7 +86,6 @@ var test = require('../../../test');
 	})();
 
 	(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);
@@ -113,4 +108,4 @@ var test = require('../../../test');
 
 	})();
 
-})();
+})();

package/partialMock/simple/newRequireMockSpec/test.js

@@ -1,5 +1,5 @@
 var assert = require('assert');
-var test = require('../../../test');
+var test = require('node:test');
 var newMock = require('../newMock');
 var expectRequire = require('../expectRequire');
 
@@ -10,7 +10,6 @@ expectRequire('./newMock').return(newMockMock);
 expectRequire('./expectRequire').return(expectRequireMock);
 
 (function() {
-	console.log('newRequireMock');
 	var didExpectRequireReturnMock = false;
 	var mock = {};
 	var moduleName = {};
@@ -36,4 +35,4 @@ expectRequire('./expectRequire').return(expectRequireMock);
 		assert.ok(didExpectRequireReturnMock);
 	});
 
-})();
+})();

package/partialMock/verifySpec/test.js

@@ -1,13 +1,11 @@
 var assert = require('assert');
-var test = require('../../test');
+var test = require('node: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);
@@ -18,7 +16,6 @@ var sut = require('../verify');
 	})();
 	
 	(function(){
-		console.log('expectCount is above zero.execute');
 		var mockContext = {};
 		mockContext.expectCount = 2;
 		var msg;

package/partialMock.js

@@ -1,5 +1,5 @@
-function create(originalFunc, thisArg) {
-	var newMockContext = require('./partialMock/newMockContext');
+function create(originalFunc, thisArg) {
+	var newMockContext = require('./partialMock/newMockContext');
 	var expect = require('./partialMock/expect');
 	var expectAnything = require('./partialMock/expectAnything');
 	var ignore = require('./partialMock/ignore');
@@ -7,14 +7,14 @@ function create(originalFunc, thisArg) {
 	var verify = require('./partialMock/verify');
 	var expectEmpty = require('./partialMock/expectEmpty');
 	var newEmptyAnd = require('./newMutableAnd');		
-	var mockContext = newMockContext(originalFunc, thisArg);
-	var _negotiateEnd = require('./partialMock/negotiateEnd');	
-
-	function mock() {		
-		negotiateEnd();
-		mockContext.arguments = arguments;		
-		return mockContext.execute.apply(this,arguments);
-	}
+	var mockContext = newMockContext(originalFunc, thisArg);
+	var _negotiateEnd = require('./partialMock/negotiateEnd');	
+
+	function mock() {		
+		negotiateEnd();
+		mockContext.arguments = arguments;		
+		return mockContext.execute.apply(this,arguments);
+	}
 
 	mock.expect = function() {				
 		negotiateEnd();
@@ -35,6 +35,8 @@ function create(originalFunc, thisArg) {
 		return expectAnything.apply(null,args);
 	};
 
+	mock.ignoreAll = mock.expectAnything;
+
 	mock.ignore = function() {
 		negotiateEnd();
 		mockContext.compositeAreCorrectArguments = newEmptyAnd();

package/partialMockSpec/test.js

@@ -1,4 +1,4 @@
-var test = require('../test');
+var test = require('node:test');
 var assert = require('assert');
 var newMock = require('../partialMock/simple/newMock');
 var newRequireMock = require('../partialMock/simple/newRequireMock');
@@ -18,7 +18,6 @@ var mutableAnd = {};
 function fallback() {}
 
 (function () {
-	console.log('partialMock');	
 	var sut;
 	var fallbackMock;
 	var mockContext;
@@ -28,7 +27,8 @@ function fallback() {}
 		function stubMockContext() {
 			mockContext = {};
 			mockContext.reset = {};
-			newMockContext.expect(fallback).return(mockContext);
+			// Allow optional thisArg without changing public usage.
+			newMockContext.expect(fallback).expectAnything().return(mockContext);
 		}
 
 		sut = newSut(fallback);
@@ -41,7 +41,6 @@ function fallback() {}
 	});	
 
 	(function() {		
-		console.log('when execute ');		
 		var arg = {};
 		var expected = {};		
 		var execute = newMock();
@@ -67,7 +66,6 @@ function fallback() {}
 	
 
 	(function() {
-		console.log('when execute');
 		var expected = {};
 		mockContext.compositeAreCorrectArguments = null;
 		var arg = 'arg';
@@ -98,7 +96,6 @@ function fallback() {}
 	})();
 
 	(function() {
-		console.log('when expect empty');
 		var expected = {};
 		var didNegotiateEnd;
 		mockContext.compositeAreCorrectArguments = null;
@@ -128,7 +125,6 @@ function fallback() {}
 
 
 	(function() {
-		console.log('when expectAnything');
 		var expected = {};
 		var didNegotiateEnd;
 		mockContext.compositeAreCorrectArguments = null;
@@ -155,7 +151,6 @@ function fallback() {}
 	})();
 
 	(function() {
-		console.log('when ignore');
 		var expected = {};
 		var didNegotiateEnd;
 		mockContext.compositeAreCorrectArguments = null;
@@ -182,7 +177,6 @@ function fallback() {}
 	})();
 
 	(function() {
-		console.log('when verify');
 		var expected = {};
 		var didNegotiateEnd;
 		verify.expect(mockContext).return(expected);
@@ -203,7 +197,6 @@ function fallback() {}
 	})();
 
 	(function() {
-		console.log('when expectArray');
 		var expected = {};		
 		var didNegotiateEnd;
 		mockContext.compositeAreCorrectArguments = null;

package/partialMockSpec/testIntegration.js

@@ -1,5 +1,5 @@
 var assert = require('assert');
-var test = require('../test');
+var test = require('node:test');
 var newMock = require('../partialMock/simple/newMock');
 var newSut = require('../partialMock');
 
@@ -11,7 +11,6 @@ function fallback(arg, arg2) {
 }
 
 (function() {
-    console.log('partialMock');
 
     test('it should return expected given stubbed twice with repeat', function() {
         var arg = 'a';

package/readmeSpec/testREADME.js

@@ -0,0 +1,199 @@
+const assert = require('assert');
+const { describe, it } = require('node:test');
+const aMock = require('..');
+
+describe('README examples', () => {
+  it('partial mock returns fake then real', () => {
+    let original = function () {
+      return 'realValue';
+    };
+
+    const mock = aMock.mock(original);
+    original = mock;
+    mock.expect().return('fake');
+
+    assert.equal(original(), 'fake');
+    assert.equal(original(), 'realValue');
+  });
+
+  it('strict mock throws on unexpected call', () => {
+    const mock = aMock.mock();
+    mock.expect().return('fake');
+
+    assert.equal(mock(), 'fake');
+    assert.throws(() => mock(), /Unexpected arguments/);
+  });
+
+  it('expecting arguments', () => {
+    const mock = aMock.mock();
+    mock.expect('testValue1').return('fake1');
+    mock.expect('testValue2').return('fake2');
+
+    assert.equal(mock('testValue1'), 'fake1');
+    assert.equal(mock('testValue2'), 'fake2');
+    assert.throws(() => mock(), /Unexpected arguments/);
+    assert.throws(() => mock('foo'), /Unexpected arguments/);
+  });
+
+  it('expecting multiple arguments', () => {
+    const mock = aMock.mock();
+    mock.expect('firstArg1', 'secondArg1').return('fake1');
+    mock.expect('firstArg2', 'secondArg2').return('fake2');
+
+    assert.equal(mock('firstArg1', 'secondArg1'), 'fake1');
+    assert.equal(mock('firstArg2', 'secondArg2'), 'fake2');
+    assert.throws(() => mock('foo'), /Unexpected arguments/);
+    assert.throws(() => mock('foo', 'bar'), /Unexpected arguments/);
+  });
+
+  it('expecting array', () => {
+    const mock = aMock.mock();
+    mock.expect(['a', 'b']).return('fake1');
+    mock.expect(['a', 'b']).return('fake2');
+    mock.expect(['c', 'd']).return('fake3');
+
+    assert.equal(mock(['a', 'b']), 'fake1');
+    assert.equal(mock(['a', 'b']), 'fake2');
+    assert.equal(mock(['c', 'd']), 'fake3');
+    assert.throws(() => mock(['a', 'b']), /Unexpected arguments/);
+    assert.throws(() => mock(['foo', 'bar']), /Unexpected arguments/);
+  });
+
+  it('expecting struct', () => {
+    const mock = aMock.mock();
+    const obj = {};
+    mock.expect({ a: 1 }).return('fake1');
+    mock.expect({ a: 2 }).return('fake2');
+    mock.expect({ a: 2, b: { c: 'foo', d: ['me', 'too'] } }).return('fake3');
+    mock.expect(obj).return('fake4');
+    mock.expect({}).return('will never happen');
+
+    assert.equal(mock({ a: 1 }), 'fake1');
+    assert.equal(mock({ a: 2 }), 'fake2');
+    assert.equal(mock({ a: 2, b: { c: 'foo', d: ['me', 'too'] } }), 'fake3');
+    assert.equal(mock(obj), 'fake4');
+    assert.throws(() => mock({}), /Unexpected arguments/);
+  });
+
+  it('repeats', () => {
+    const mock = aMock.mock();
+    mock.expect().return('fake').repeat(2);
+
+    assert.equal(mock(), 'fake');
+    assert.equal(mock(), 'fake');
+    assert.throws(() => mock(), /Unexpected arguments/);
+  });
+
+  it('repeatAny', () => {
+    const mock = aMock.mock();
+    mock.expect().return('fake').repeatAny();
+
+    assert.equal(mock(), 'fake');
+    assert.equal(mock(), 'fake');
+    assert.equal(mock(), 'fake');
+  });
+
+  it('ignoring a single argument', () => {
+    const mock = aMock.mock();
+    mock.ignore().expect('foo').return('fake1');
+
+    assert.equal(mock('ignore me', 'foo'), 'fake1');
+    assert.throws(() => mock(), /Unexpected arguments/);
+  });
+
+  it('ignoring all arguments', () => {
+    const mock = aMock.mock();
+    mock.ignoreAll().return('fake1');
+
+    assert.equal(mock('someRandomValue', 'whatever'), 'fake1');
+    assert.throws(() => mock(), /Unexpected arguments/);
+  });
+
+  it('throwing exceptions', () => {
+    const mock = aMock.mock();
+    const error = new Error('invalid operation');
+    mock.expect().throw(error);
+    mock.expect().return('fake');
+
+    assert.throws(() => mock(), /invalid operation/);
+    assert.equal(mock(), 'fake');
+  });
+
+  it('intercepting whenCalled', () => {
+    const mock = aMock.mock();
+    let calledArg;
+    mock.expect('testValue').whenCalled(function (arg) {
+      calledArg = arg;
+    }).return('fake1');
+
+    assert.equal(mock('testValue'), 'fake1');
+    assert.equal(calledArg, 'testValue');
+    assert.throws(() => mock(), /Unexpected arguments/);
+  });
+
+  it('verify (fail)', () => {
+    const mock = aMock.mock();
+    mock.expect('testValue1').return('fake1');
+    mock.expect('testValue2').return('fake2');
+
+    assert.equal(mock('testValue1'), 'fake1');
+    assert.throws(() => mock.verify(), /mock has 1 pending functions/);
+  });
+
+  it('verify (success)', () => {
+    const mock = aMock.mock();
+    mock.expect('testValue1').return('fake1');
+    mock.expect('testValue2').return('fake2');
+
+    assert.equal(mock('testValue1'), 'fake1');
+    assert.equal(mock('testValue2'), 'fake2');
+    assert.equal(mock.verify(), true);
+  });
+
+  it('returning void (compact syntax)', () => {
+    const mock = aMock.mock();
+    mock.expect('testValue1');
+    mock.expect('testValue2').repeat(2);
+
+    assert.equal(mock('testValue1'), undefined);
+    assert.equal(mock('testValue2'), undefined);
+    assert.equal(mock('testValue2'), undefined);
+    assert.equal(mock.verify(), true);
+  });
+
+  it('reset mock', () => {
+    let original = function () {
+      return 'realValue';
+    };
+
+    const mock = aMock.mock(original);
+    original = mock;
+    mock.expect().return('fake');
+    mock.reset();
+
+    assert.equal(original(), 'realValue');
+  });
+
+  it('returning resolved promise', () => {
+    const mock = aMock.mock();
+    mock.expect('foo').resolve('fake');
+
+    return mock('foo').then(function (returned) {
+      assert.equal(returned, 'fake');
+    });
+  });
+
+  it('returning rejected promise', () => {
+    const mock = aMock.mock();
+    mock.expect('foo').reject('fake');
+
+    return mock('foo').then(
+      function () {
+        assert.fail('expected rejection');
+      },
+      function (returned) {
+        assert.equal(returned, 'fake');
+      }
+    );
+  });
+});

package/requireMockSpec/test.js

@@ -1,5 +1,5 @@
 var assert = require('assert');
-var test = require('../test');
+var test = require('node:test');
 var newMock = require('../partialMock/simple/newMock');
 var expectRequire = require('../partialMock/simple/expectRequire');
 
@@ -11,7 +11,6 @@ expectRequire('./mock').return(newMockMock);
 expectRequire('./expectRequire').return(expectRequireMock);
 
 (function() {
-	console.log('newRequireMock');
 	var didExpectRequireReturnMock = false;
 	var mock = {};
 	var moduleName = {};

package/strictMockSpec/test.js

@@ -1,5 +1,5 @@
 var assert = require('assert');
-var test = require('../test');
+var test = require('node:test');
 var expectRequire = require('../partialMock/simple/expectRequire');
 var newMockCore = require('../partialMock/simple/newPartialMock');
 
@@ -16,7 +16,6 @@ expectRequire('./partialMock').return(newPartialMock);
 expectRequire('./mock/throwUnexpectedArguments').return(throwUnexpectedArguments);
 
 (function(){
-	console.log('newMock');
 	var partialMock = {};
 	newPartialMock.expect(throwUnexpectedArguments).return(partialMock);
 	var returned = require('../strictMock')();

package/util.js

@@ -1,7 +1,7 @@
-function isDate(x) {
-    return Object.prototype.toString.call(x) === '[object Date]';
-}
-
-module.exports = {
-    isDate: isDate
-};
+function isDate(x) {
+    return Object.prototype.toString.call(x) === '[object Date]';
+}
+
+module.exports = {
+    isDate: isDate
+};

package/test.js

@@ -1,17 +0,0 @@
-var red, green, reset;
-red   = '\u001b[31m';
-green = '\u001b[32m';
-reset = '\u001b[0m';
-
-function test(message, fn) {
-	try {
-		fn();
-		console.log(green + '  OK   ' + reset + message);
-	}
-	catch(err) {
-		console.log(red + '  FAIL ' + reset + message);
-		console.log(err);
-	}
-}
-
-module.exports = test;