a_mock 2.0.2 → 2.0.4

package/.github/workflows/ci.yml

@@ -0,0 +1,19 @@
+name: CI
+
+on:
+  push:
+  pull_request:
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Use Node.js 24
+        uses: actions/setup-node@v4
+        with:
+          node-version: 24
+      - name: Install dependencies
+        run: npm install
+      - name: Run tests
+        run: npm test

package/README.md

@@ -1 +1,450 @@
-This is a sub package of a.
+_a_mock_
+===
+_Mocking framework_ 
+
+
+The mocking framework can be used in any JavaScript testing framework.
+
+
+__To install:__
+
+```
+npm install a_mock
+```
+
+
+_Mocking_
+===================
+
+Mocking a function
+------------------
+
+__Partial mock__
+
+```js
+var original = function() {
+	return 'realValue';
+}
+
+var mock = require('a_mock').mock(original);
+original = mock;
+mock.expect().return('fake');
+
+original(); //returns 'fake'
+original(); //returns 'realValue'
+```
+
+Note: Consumers do not need to provide a `thisArg`. It is optional and only used to force a specific `this` when the original fallback is called (low-level partial mock usage).
+
+
+
+__Strict mock__
+
+```js
+var mock = require('a_mock').mock();
+mock.expect().return('fake');
+
+mock(); //returns 'fake'
+mock(); //throws unexpected arguments
+```
+
+
+
+__Expecting arguments__
+
+```js
+var mock = require('a_mock').mock();
+mock.expect('testValue1').return('fake1');
+mock.expect('testValue2').return('fake2');
+
+mock('testValue1'); //returns 'fake1'
+mock('testValue2'); //returns 'fake2'
+mock(); //throws unexpected arguments
+mock('foo'); //throws unexpected arguments
+```
+
+
+
+__Expecting multiple arguments__
+
+```js
+var mock = require('a_mock').mock();
+mock.expect('firstArg1', 'secondArg1').return('fake1');
+mock.expect('firstArg2', 'secondArg2').return('fake2');
+
+
+mock('firstArg1', 'secondArg1'); //returns 'fake1'
+mock('firstArg2', 'secondArg2'); //returns 'fake2'
+mock('foo'); //throws unexpected arguments
+mock('foo', 'bar'); //throws unexpected arguments
+```
+
+__Expecting array__
+
+```js
+var mock = require('a_mock').mock();
+mock.expect(['a','b']).return('fake1');
+mock.expect(['a','b']).return('fake2');
+mock.expect(['c','d').return('fake3');
+
+mock(['a','b']); //returns 'fake1'
+mock(['a','b']); //returns 'fake2'
+mock(['c','d']); //returns 'fake3'
+mock(['a','b']); //throws unexpected arguments
+mock(['foo', 'bar']); //throws unexpected arguments
+```
+
+__Expecting struct__
+
+```js
+var mock = require('a_mock').mock();
+var 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');
+
+mock({a : 'x'}); //throws unexpected arguments
+mock({a : 1}); //returns 'fake1'
+mock({a : 2}); //returns 'fake2'
+mock({a : 2, b : {c : 'foo', d : ['me', 'too']}}); //returns 'fake3'
+mock(obj);  //returns 'fake4'
+mock({});  //throws unexpected arguments
+```
+
+__Repeats__
+
+```js
+var mock = require('a_mock').mock();
+mock.expect().return('fake').repeat(2);
+
+mock(); //returns 'fake'
+mock(); //returns 'fake'
+mock(); //throws unexpected arguments
+```
+
+__Infinite repeats__
+
+```js
+var mock = require('a_mock').mock();
+mock.expect().return('fake').repeatAny();
+
+mock(); //returns 'fake'
+mock(); //returns 'fake'
+mock(); //returns 'fake'...
+```
+
+
+__Ignoring a single argument__
+
+```js
+var mock = require('a_mock').mock();
+mock.ignore().expect('foo').return('fake1');
+
+mock('ignore me', 'foo'); //returns 'fake1'
+mock(); //throws unexpected arguments
+```
+
+__Ignoring all arguments__
+
+```js
+var mock = require('a_mock').mock();
+mock.ignoreAll().return('fake1'); //same as expectAnything
+
+mock('someRandomValue', 'whatever'); //returns 'fake1'
+mock(); //throws unexpected arguments
+```
+
+
+__Throwing exceptions__
+
+```js
+var mock = require('a_mock').mock();
+var error = new Error('invalid operation');
+mock.expect().throw(error);
+mock.expect().return('fake');
+
+mock(); //throws error
+mock(); //returns 'fake'
+```
+
+__Intercepting__
+
+```js
+var mock = require('a_mock').mock();
+mock.expect('testValue').whenCalled(onCalled).return('fake1');
+
+function onCalled(arg) {
+	//arg == 'testValue'
+}
+
+mock('testValue'); //returns 'fake1'
+mock(); //throws unexpected arguments
+```
+
+__Verify (fail)__
+
+```js
+var mock = require('a_mock').mock();
+mock.expect('testValue1').return('fake1');
+mock.expect('testValue2').return('fake2');
+
+mock('testValue1'); //returns 'fake1'
+mock.verify(); //throws mock has 1 pending functions
+```
+
+__Verify (success)__
+
+```js
+var mock = require('a_mock').mock();
+mock.expect('testValue1').return('fake1');
+mock.expect('testValue2').return('fake2');
+
+mock('testValue1'); //returns 'fake1'
+mock('testValue2'); //returns 'fake2'
+mock.verify(); //returns true
+```
+
+__returning void (compact syntax)__
+
+```js
+var mock = require('a_mock').mock();
+mock.expect('testValue1');
+mock.expect('testValue2').repeat(2);
+
+mock('testValue1'); //returns undefined
+mock('testValue2'); //returns undefined
+mock('testValue2'); //returns undefined
+mock.verify(); //returns true
+```
+
+__..is equivalent to ..__
+```js
+var mock = require('a_mock').mock();
+mock.expect('testValue1').return();
+mock.expect('testValue2').return().repeat(2);
+
+mock('testValue1'); //returns undefined
+mock('testValue2'); //returns undefined
+mock('testValue2'); //returns undefined
+mock.verify(); //returns true
+```
+
+__Reset mock__
+```js
+var original = function() {
+	return 'realValue';
+}
+
+var mock = require('a_mock').mock(original);
+original = mock;
+mock.expect().return('fake');
+mock.reset();
+
+original(); //returns 'realValue'
+```
+
+__Returning resolved promise__
+```js
+var mock = require('a_mock').mock();
+mock.expect('foo').resolve('fake');
+
+mock('foo').then(function(returned){
+	//returned == 'fake'
+}); 
+```
+
+__Returning rejected promise__
+```js
+var mock = require('a_mock').mock();
+mock.expect('foo').reject('fake');
+
+mock('foo').then(null, function(returned){
+	//returned == 'fake'
+}); 
+```
+
+__Strict mock - advanced scenario__
+
+```js
+var mock = require('a_mock').mock();
+mock.expect('testValue').ignore().whenCalled(onCalled).return('fake1');
+
+function onCalled(arg,callback) {
+	//arg == 'testValue'
+	//callback == foo
+}
+
+function foo() {
+}
+
+
+mock('testValue', foo); //returns 'fake1'
+mock.verify() //returns true
+mock('testValue',foo); //throws unexpected arguments
+```
+
+Mocking require
+----------------
+
+__expectRequire__
+
+```js
+var fakeDep = {};
+
+var expectRequire = require('a_mock').expectRequire;
+expectRequire('./realDep').return(fakeDep);
+
+require('./realDep'); //returns fakeDep
+require('./realDep'); //returns realDep (behaves like a partial mock)
+```
+
+__requireMock (compact syntax)__
+
+```js
+var requireMock = require('a_mock').requireMock;
+var fakeDep = requireMock('./realDep'); //returns a strict mock
+
+require('./realDep'); //returns fakeDep
+require('./realDep'); //returns realDep
+```
+
+__..is equivalent to ..__
+
+```js
+var mock = require('a_mock').mock();
+var expectRequire = require('a_mock').expectRequire;
+
+var fakeDep = mock;
+expectRequire('./realDep').return(fakeDep);
+
+require('./realDep'); //returns fakeDep
+require('./realDep'); //returns realDep
+```
+
+__Reset mocks for require__
+
+```js
+var fakeDep = {};
+
+var expectRequire = require('a_mock').expectRequire;
+expectRequire('./realDep').return(fakeDep);
+expectRequire.reset();
+
+require('./realDep'); //returns realDep
+```
+
+__..is equivalent to ..__
+
+```js
+var requireMock = require('a_mock').requireMock;
+var fakeDep = requireMock('./realDep'); //returns a strict mock
+requireMock.reset(); //is an alias for expectRequire.reset()
+
+require('./realDep'); //returns realDep
+
+```
+Mocking an object
+-----------------
+__Partial object mock__
+
+```js
+function newCustomer(_name) {
+	var c = {};
+
+	c.getName = function ()
+	{
+		return _name;
+	};
+
+	return c;
+}
+
+var customer = newCustomer('Alfonzo The Real');
+var customerMock = mock(customer);
+
+customerMock.getName.expect().return('Johnny Fake');
+
+customer.getName(); //returns Johnny Fake
+customer.getName(); //returns Alfonzo The Real
+customerMock.verify(); //returns true
+```
+
+Mocking promises
+-----------------
+__Mocking resolve__
+
+```js
+var a = require('a_mock');
+
+var promise = a.promise(); //mocked promise
+
+promise.then(success,error);
+promise.resolve('success');
+
+function success(arg) {
+	console.log(arg);//success
+}
+
+function error(e) {
+	//will not happen
+}
+```
+
+__Mocking resolve (alternative syntax)__
+
+```js
+var a = require('a_mock');
+
+var promise = a.promise(); //mocked promise
+
+promise.then(success,error);
+promise('success');
+
+function success(arg) {
+	console.log(arg);//success
+}
+
+function error(e) {
+	//will not happen
+}
+```
+
+__Mocking reject__
+
+```js
+var a = require('a_mock');
+
+var promise = a.promise();
+
+promise.then(success,error);
+promise.reject(new Error('error'));
+
+function success(arg) {
+	//will not happen
+}
+
+function error(e) {
+	console.log(e.stack);//will happen
+}
+```
+
+__Mocking reject (alternative syntax)__
+
+```js
+var a = require('a_mock');
+
+var promise = a.promise();
+
+promise.then(success,error);
+promise(null,new Error('error'));
+
+function success(arg) {
+	//will not happen
+}
+
+function error(e) {
+	console.log(e.stack);//will happen
+}
+```

package/and/newBinaryAndSpec/test.js

@@ -1,5 +1,5 @@
 var assert = require('assert');
-var test = require('../../test');
+var test = require('node:test');
 var newRequireMock = require('../../partialMock/simple/newRequireMock');
 var newMock = require('../../partialMock/simple/newMock');
 
@@ -8,13 +8,11 @@ var newSut = require('../newBinaryAnd');
 
 
 (function(){
-	console.log('newBinaryAnd');
 	var predicate = newMock();
 	var predicate2 = newMock();
 	var sut = newSut(predicate,predicate2);
 
 	(function() {
-		console.log('execute when predicate1 returns false');
 		var arg = {};
 		predicate.expect(arg).return(false);		
 		var returned = sut(arg);
@@ -25,7 +23,6 @@ var newSut = require('../newBinaryAnd');
 	})();
 
 	(function() {
-		console.log('execute when predicate1 returns true, predicate2 returns false');
 		var arg = {};
 		predicate.expect(arg).return(true);		
 		predicate2.expect(arg).return(false);		
@@ -37,7 +34,6 @@ var newSut = require('../newBinaryAnd');
 	})();
 
 	(function() {
-		console.log('execute when predicate1 returns true, predicate2 returns true');
 		var arg = {};
 		predicate.expect(arg).return(true);		
 		predicate2.expect(arg).return(true);		
@@ -49,7 +45,6 @@ var newSut = require('../newBinaryAnd');
 	})();
 
 	(function() {
-		console.log('add');		
 		var binaryAnd = {};
 		var predicate = {};
 		var predicate2 = {};
@@ -64,4 +59,3 @@ var newSut = require('../newBinaryAnd');
 		});
 	})();
 });
-

package/and/newMonadicAndSpec/test.js

@@ -1,5 +1,5 @@
 var assert = require('assert');
-var test = require('../../test');
+var test = require('node:test');
 var newRequireMock = require('../../partialMock/simple/newRequireMock');
 var newMock = require('../../partialMock/simple/newMock');
 
@@ -8,12 +8,10 @@ var newSut = require('../newMonadicAnd');
 
 
 (function(){
-	console.log('newMonadicAnd');
 	var predicate = newMock();	
 	var sut = newSut(predicate);
 
 	(function() {
-		console.log('execute');
 		var arg = {};
 		var expected = {};
 		predicate.expect(arg).return(expected);
@@ -27,7 +25,6 @@ var newSut = require('../newMonadicAnd');
 
 
 	(function() {
-		console.log('add');
 		var binaryAnd = {};
 		var predicate = {};
 		var predicate2 = {};
@@ -42,4 +39,4 @@ var newSut = require('../newMonadicAnd');
 		});
 	})();
 
-})();
+})();

package/andSpec/test.js

@@ -1,15 +1,13 @@
 var assert = require('assert');
-var test = require('../test');
+var test = require('node:test');
 var newRequireMock = require('../partialMock/simple/newRequireMock');
 var newMock = require('../partialMock/simple/newMock');
 
 
 (function(){
-	console.log('and');
 	var sut = require('../and');
 
 	(function() {
-		console.log('execute');
 		var returned = sut();
 
 		test('it returns true',function() {
@@ -18,7 +16,6 @@ var newMock = require('../partialMock/simple/newMock');
 	})();
 
 	(function() {
-		console.log('add');
 		var newMonadicAnd = newRequireMock('./and/newMonadicAnd');
 		var monadicAnd = {};
 		var predicate = {};

package/andSpec/testIntegration.js

@@ -1,12 +1,11 @@
 var assert = require('assert');
-var test = require('../test');
+var test = require('node:test');
 var newRequireMock = require('../partialMock/simple/newRequireMock');
 var newMock = require('../partialMock/simple/newMock');
 
 var and = require('../and');
 
 (function(){
-	console.log('and');
 	var arg = {};
 	var arg2 = {};
 	var predicate1 = newMock();

package/eventEmitter/addSpec/test.js

@@ -1,12 +1,10 @@
 var assert = require('assert');
-var test = require('../../test');
+var test = require('node:test');
 var sut = require('../add');
 
 (function(){
-	console.log('addSpec');
 
 	(function() {
-		console.log('execute');
 		var context = {};
 		var callbacks = [{}];
 		context.callbacks = callbacks;
@@ -19,4 +17,4 @@ var sut = require('../add');
 		});
 	})();
 
-})();
+})();

package/eventEmitter/emitterContextSpec/test.js

@@ -1,12 +1,11 @@
 var assert = require('assert');
-var test = require('../../test');
+var test = require('node:test');
 var newSut = require('../emitterContext');
 
 (function(){
-	console.log('newEmitterContext');
 	var returned = newSut();
 
 	test('it should set callbacks to empty array',function() {
 		assert.equal(returned.callbacks.length,0);
 	});
-})();
+})();

package/eventEmitter/removeSpec/test.js

@@ -1,12 +1,10 @@
 var assert = require('assert');
-var test = require('../../test');
+var test = require('node:test');
 var sut = require('../remove');
 
 (function(){
-	console.log('removeSpec');
 
 	(function() {
-		console.log('execute');
 		var context = {};
 		var callback = {};
 		var callback0 = {};
@@ -24,4 +22,4 @@ var sut = require('../remove');
 		});
 	})();
 
-})();
+})();

package/eventEmitter/tryAddSpec/test.js

@@ -1,14 +1,12 @@
 var assert = require('assert');
-var test = require('../../test');
+var test = require('node:test');
 var newRequireMock = require('../../partialMock/simple/newRequireMock');
-
+var context = {};
 var sut = require('../tryAdd');
 
 (function(){
-	console.log('tryAddSpec');
 	
 	(function() {
-		console.log('execute');
 		var add = newRequireMock('./add');
 		var didAdd;
 		var callback = {};
@@ -25,7 +23,6 @@ var sut = require('../tryAdd');
 	});
 
 	(function() {
-		console.log('execute with missing callback');
 		var add = newRequireMock('./add');		
 		var didAdd;
 		var callback;
@@ -40,4 +37,4 @@ var sut = require('../tryAdd');
 			assert.ok(true);
 		});
 	})();
-})();
+})();

package/eventEmitter/tryRemoveSpec/test.js

@@ -1,14 +1,12 @@
 var assert = require('assert');
-var test = require('../../test');
+var test = require('node:test');
 var newRequireMock = require('../../partialMock/simple/newRequireMock');
 var context = {};
 var sut = require('../tryRemove');
 
 (function(){
-	console.log('tryRemoveSpec');
 
 	(function() {
-		console.log('execute');
 		var remove = newRequireMock('./remove');
 		var didremove;
 		var callback = {};
@@ -25,7 +23,6 @@ var sut = require('../tryRemove');
 	})();
 
 	(function() {
-		console.log('execute with missing callback');
 		var remove = newRequireMock('./remove');		
 		var didremove;
 		var callback;
@@ -40,4 +37,4 @@ var sut = require('../tryRemove');
 			assert.ok(true);
 		});
 	})();
-})();
+})();