a_mock 2.0.1 → 2.0.3

package/partialMock.js

@@ -1,4 +1,4 @@
-function create(originalFunc) {
+function create(originalFunc, thisArg) {
 	var newMockContext = require('./partialMock/newMockContext');
 	var expect = require('./partialMock/expect');
 	var expectAnything = require('./partialMock/expectAnything');
@@ -7,13 +7,13 @@ function create(originalFunc) {
 	var verify = require('./partialMock/verify');
 	var expectEmpty = require('./partialMock/expectEmpty');
 	var newEmptyAnd = require('./newMutableAnd');		
-	var mockContext = newMockContext(originalFunc);
+	var mockContext = newMockContext(originalFunc, thisArg);
 	var _negotiateEnd = require('./partialMock/negotiateEnd');	
 
 	function mock() {		
 		negotiateEnd();
 		mockContext.arguments = arguments;		
-		return mockContext.execute.apply(null,arguments);
+		return mockContext.execute.apply(this,arguments);
 	}
 
 	mock.expect = function() {				
@@ -35,6 +35,8 @@ function create(originalFunc) {
 		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;