如何使用Sinon存根“包装器”函数？

Question

I'm setting up a Lambda function (node.js) and for example's sake, we'll keep it minimal.

module.exports = (event, context, callback) {
  console.log("hello world")
}

However, I've created a function to wrap the lambda function that allows me to perform some functions that are required before each Lambda executes (I have a collection of Lambda functions that are wired up using their Serverless Application Model (SAM) ). It also allows me to consolidate some of the logging and error handling across each function.

// hook.js
const connect = fn => (event, context, callback) => {
  someFunction()
    .then(() => fn(event, context, callback))
    .then(res => callback(null, res))
    .catch(error => {
      // logging
      callback(error)
    })
}

module.exports = { connect }

// index.js
const Hook = require("./hook")

exports.handler = Hook.connect((event, context, callback) => {
  console.log("hello world")
})

The logic is working well and Lambda is processing it successfully. However, I'm trying to stub this Hook.connect function using SinonJS and in need of some guidance.

I simply want to stub it to return a resolved promise, that way we can proceed to handle the code within each Lambda function ( fn(event, context, callback) ).

const sinon = require("sinon")
const Hook = require("./hook")
const { handler } = require("./index")
const event = {} // for simplicity sake
const context = {} // for simplicity sake
const callback = {} // for simplicity sake

describe("Hello", () => {
  let connectStub

  beforeEach(() => {
    connectStub = sinon.stub(Hook, "connect").callsFake()

  afterEach(() => {
    connectStub.restore()
  })

  it("works", () => {
    const results = handler(event, context, callback)
    // assert
  })
})

I've tried a few different methods, from the basic, sinon.stub(Hook, "connect") , to the more complicated where I'm trying to stub private functions inside of the hook.js file using rewire .

Any help would be appreciated -- thank you in advance.

Answer 1

Here is a working test:

const sinon = require('sinon');
const Hook = require('./hook');

const event = {}; // for simplicity sake
const context = {}; // for simplicity sake
const callback = {}; // for simplicity sake

describe('Hello', () => {

  let handler, connectStub;
  before(() => {
    connectStub = sinon.stub(Hook, 'connect');
    connectStub.callsFake(fn => (...args) => fn(...args));  // create the mock...
    delete require.cache[require.resolve('./index')];  // (in case it's already cached)
    handler = require('./index').handler;  // <= ...now require index.js
  });

  after(() => {
    connectStub.restore();  // restore Hook.connect
    delete require.cache[require.resolve('./index')];  // remove the modified index.js
  });

  it('works', () => {
    const results = handler(event, context, callback);  // it works!
    // assert
  });
});

Details

index.js calls Hook.connect to create its exported handler as soon as it runs , and it runs as soon as it is required ...

...so the mock for Hook.connect needs to be in place before index.js is required :

Node.js caches modules , so this test also clears the Node.js cache before and after the test to ensure that index.js picks up the Hook.connect mock, and to ensure that the index.js with the mocked Hook.connect is removed from the cache in case the real index.js is needed later.