How to spyOn NodeJS module singleton with Jasmine - node.js

Question

I want to use Jasmine to spyOn a module which exports a method directly:
myModule
module.exports = (arg, arg) => {
//do something...
callAMethod();
//return
}
Jasmine
spyOn(myModule);
// since I don't have any method to use spyOn(myModule, <method>)
I found I could use this:
//describe..
var myModule = require('./myModule');
it...
myModule = jasmine.createSpy().and.callFake(function() {
return false;
}); // <-this should work
functionBeingTested(..args);
expect(myModule).toHaveBeenCalled(); /*I get false, even if
it is actually called
in the functionBeingTested*/
Another solution i found was to spyOn myModule.prototype or set jasmine.createSpy().and.returnValue(false) but I have no success with both either.
How can I use spyOn like I said above?

Answer 1

I've created a simple snippet which mimics the require js
functionality to load the library and call the method.
I've listed three spies each with a different scenario explaining how
to spy
Note:
I've not used the require.js in itself but mimicked its functionality
however
Because the require.js exports the module.exports, we have no
control over the functionality of the require call and hence we might
not be able to install a spy on that method.
Please follow the each it case to for the description.
Hope this helps!
var callAMethod = function() {
return "Hello";
}
var myModule = {};
myModule.exports = function(name, title) {
return callAMethod() + " " + title + "." + name;
}
// Note that this require mimics the actual require.js require methodology, bascially returns the instantiated version of the library to be used.
var require = function() {
return myModule.exports;
}
// some function that uses the require library to load the js and then does something with it.
var testFunc = function() {
var myMod = require('abc');
return myMod("Bruce", "Mr");
}
describe('test mymodule', function() {
// This test fails because though you are mocking the instance here and not the actual call.
it('test that fails', function() {
var myModuleTest = require('abc');
myModuleTest = jasmine.createSpy().and.callFake(function() {
return false;
});
var result = testFunc();
console.log(result);
expect(result).toBe(false);
});
// this test passes since we have hijacked the require attribute itself and then routed its call to return the Boolean true which means that myModule now return the true statement
it('test that passes', function() {
require = jasmine.createSpy().and.callFake(function() {
return function() {
return true;
};
});
var result = testFunc();
console.log(result);
expect(result).toBe(true);
});
//callAMethod method call from module.exports may not tested since its the require js that does this call and you have no hook into it, however you can directly test the method like this
it('test callAMethod', function() {
console.log(myModule.exports("Bruce", "Mr"));
spyOn(myModule, 'exports').and.returnValue("Hello Mr.Wayne!");
var testVal = myModule.exports("Bruce", "Mr");
expect(testVal).toEqual("Hello Mr.Wayne!");
})
});