Unit test with sinon fake does not resolve promise

Question

I'm learning nodejs and wrote this wrapper for a shelljs function, which in practice seems to work as intended.

/**
 * Wrapper for Shelljs.exec to always return a promise
 *
 * @param  {String} cmd - bash-compliant command string
 * @param  {String} path - working directory of the process
 * @param {Object} _shell - alternative exec function for testing.
 * @returns {String}
 * @throws {TypeError}
 */
function shellExec(cmd, path, _shell = shelljs){
    if( typeof _shell.exec !== "function") throw new TypeError('_shell.exec must be a function');
    return new Promise((resolve, reject) => {
        let options =  { cwd: path, silent: true, asyc: true }
        // eslint-disable-next-line no-unused-vars
        return _shell.exec(cmd, options, (code, stdout, stderr) => {
            // shelljs.exec does not always return a code
            if(stderr) {
                return reject(stderr);
            }
            return resolve(stdout);
        });
    });
}

However when I attempt to unit test it, the function times out. I have read the mochajs docs about async code, promises or async/await in tests. I want to use a sinon fake that returns a promise which I know works. Mocha tells me the error is that the function is not returning a promise via the error Error: Timeout of 2000ms exceeded. For async tests and hooks, ensure "done()" is called; if returning a Promise, ensure it resolves. I imagine I have constructed the fake improperly but I cannot see how else I should have done this.

const { expect, use } = require('chai');
const sinon = require('sinon');
const sinonChai = require("sinon-chai");
const utils = require('../utility/exec');

use(sinonChai);

it('sinon fake should resolve', async () =>{
    const fake = sinon.fake.resolves('resolved');

    const result = await fake();
    expect(result).to.equal('resolved');
});
describe('Utility Functions', () =>{
    describe('shellExec', () =>{
        it('should accept an alternate execute function', async () =>{
            const fakeShell = { exec: sinon.fake.resolves('pass') };
            const result = await utils.shellExec('pwd', 'xyz', fakeShell);
            expect(result).to.equal('pass');
            expect(fakeShell.exec).to.have.been.calledOnce;
        });
    });
});

I found both the answers from Peter and Dat Tran were both quite helpful, but Peter's was more on point about the actual test. — Todd, Aug 13 '18 at 13:57

Dat Tran · Answer 1 · 2018-08-09T15:36:48.727

1

your _shell.exec is just a callback function, It's not a Promise. That's why when you fake shell.exec to be a promise, your resolve will never been called. I think you need to fake your fakeShell to something like this:

const fakeShell = { 
   exec: (cmd, options, cb) => {
      cb(true, 'pass', null);
   }
};

edited Aug 09 '18 at 15:36

answered Aug 09 '18 at 15:27

Dat Tran

1,576
1
12
16

You are saying that I don't need to use any sinon objects here, I just pass the new fakeShell in and test the result? I didn't see that `_shell` was a callback, though when I use the function it responds to `.then`/`.catch`. – Todd Aug 10 '18 at 11:03
1

shell.exec is a call back function. when It finish, it use the resolve from The outer promise to resolve it. That's the meaning of the function. Wrap a callback into a promise. – Dat Tran Aug 10 '18 at 14:19
`_shell.exec(cmd, options, (code, stdout, stderr) => {` => `cmd` is the 1st parameter, `options` is the 2nd, `(code, stdout, stderr) => {}` is the 3rd parameter, It's actually the callback function which is called after the _shell.exec is finished. – Dat Tran Aug 10 '18 at 14:21
I see now that I don't need shelljs at all in this instance as utilities `promisfy()` method of `exec` achieves the same effect. The parameters are the same! – Todd Aug 13 '18 at 13:54

score 1 · Accepted Answer · answered Aug 09 '18 at 15:40

You function is a little complex but nothing sinon can't handle with stubs. See https://sinonjs.org/releases/v1.17.7/stubs/ for more info but what you should use is callsArgOnWith before the function.

Instead of setting exec to return a promise you need to set it as a stub. This way you can call the callback using the callsArgOnWith function when it is encountered.

I've changed your test so it now passes by changing the fake exec function to return a stub const fakeShell = { exec: sinon.stub() }; and adding the line fakeShell.exec.callsArgOnWith(2, null, null, 'pass', null) before running your function

const { expect, use } = require('chai');
const sinon = require('sinon');
const sinonChai = require("sinon-chai");
const utils = require('./main');


use(sinonChai);

it('sinon fake should resolve', async () =>{
    const fake = sinon.fake.resolves('resolved');

    const result = await fake();
    expect(result).to.equal('resolved');
});
describe('Utility Functions', () =>{
    describe('shellExec', () =>{
        it('should accept an alternate execute function', async () =>{
            const fakeShell = { exec: sinon.stub() };
            fakeShell.exec.callsArgOnWith(2, null, null, 'pass', null)
            const result = await utils.shellExec('pwd', 'xyz', fakeShell);            
            expect(result).to.equal('pass');
            expect(fakeShell.exec).to.have.been.calledOnce;
        });
    });
});

I read the docs at link you provided but clear as mud to me. Could you explain the parameters in `callsArgOnWith(2, null, null, 'pass', null)`? — Todd, Aug 10 '18 at 10:50
`stub.callsArgOnWith(index, context, arg1, arg2, ...);` Index - which argument of the exec function the callback. 0 indexed, context - any scope you want to pass through, then the rest are the arguments you pass to the callback — Peter Grainger, Aug 10 '18 at 13:16

Unit test with sinon fake does not resolve promise

2 Answers2