Ensuring that Express app.use is triggered with a middleware function: A guide using Mocha

Question

Ensuring that Express app.use is triggered with a middleware function: A guide using Mocha

I am faced with the challenge of testing whether app.use is being called with middleware. The issue arises when app.use is called with functions that return other functions, making it difficult to conduct proper testing.

app-factory.js

const express = require('express')
const app = express()
const csurf = require('csurf')
const cookieParser = require('cookie-parser')


class AppFactory {
  createApp () {
    app.use(csurf({ cookie: true }))
    app.use(cookieParser())
    return app
  }
}

module.exports = {
  AppFactory: AppFactory,
  app: app,
  csurf: csurf
}

app-factory.test.js

const chai = require('chai')
const assert = chai.assert
const rewire = require('rewire')
const appFactoryRewire = rewire('../server/app-factory.js')
const sinon = require('sinon')
const appFactory = require('../server/app-factory')

describe('csurf middleware', () => {
  const rewiredCsurf = appFactoryRewire.__get__('csurf')

  it('should exist', () => {
    assert.exists(rewiredCsurf)
  })

  it('should be a function', () => {
    assert.isFunction(rewiredCsurf)
  })

  it('should be equal csurf module', () => {
    assert.strictEqual(rewiredCsurf, require('csurf'))
  })

  it('should be called once as app.use arg', () => {
    const csurf = appFactory.csurf
    const appUseSpy = sinon.spy(appFactory.app, 'use')
    const appInstance = new appFactory.AppFactory()
    appInstance.createApp()
    sinon.assert.calledWith(appUseSpy, csurf({ cookie: true }))
  })
})

The failing test output:

  1) csurf middleware
       should be called once as app.use arg:
     AssertError: expected use to be called with arguments 
Call 1:
function cookieParser() {} function csrf() {} 
Call 2:
function csrf() {}
      at Object.fail (node_modules/sinon/lib/sinon/assert.js:107:21)
      at failAssertion (node_modules/sinon/lib/sinon/assert.js:66:16)
      at Object.assert.<computed> [as calledWith] (node_modules/sinon/lib/sinon/assert.js:92:13)
      at Context.<anonymous> (test/app.test.js:45:18)
      at processImmediate (internal/timers.js:461:21)

When I attempted to simulate calling app.use with a string using something like app.use('/passport', routes) and then validated it with

sinon.assert.calledWith(appUseSpy, '/passport')

, it worked successfully. However, my struggle lies in asserting that app.use is correctly called with csrf({ cookie: true }). Any suggestions on how I can properly achieve this assertion?

node.js express testing mocha.js sinon

Answer 1

Answer №1

Implementing a helper function to compare function arguments as strings:

app-factory.test.js

const chai = require('chai')
const assert = chai.assert
const rewire = require('rewire')
const appFactoryRewire = rewire('../server/app-factory.js')
const sinon = require('sinon')

/**
 * Custom Helper Function: Check if argument is called with expected function
 * @param {*} spyFn - Sinon Spy function
 * @param {*} argFn - Callback or function parameter
 */
function verifyFunctionArgCall (spyFn, argFn) {
  const calls = spyFn.getCalls()
  const argFnString = argFn.toString()
  let foundMatch = false
  for (const call in calls) {
    const arg = spyFn.getCall(call).args[0]
    if (arg.toString() === argFnString) {
      foundMatch = true
    }
  }
  assert(foundMatch === true, 
    'Spy function/method was not called with the expected function')
}

describe('Testing csurf middleware', () => {
  const rewiredCsurf = appFactoryRewire.__get__('csurf')

  it('should be defined', () => {
    assert.exists(rewiredCsurf)
  })

  it('should be a function', () => {
    assert.isFunction(rewiredCsurf)
  })

  it('should equal to csurf module', () => {
    assert.strictEqual(rewiredCsurf, require('csurf'))
  })

  it('should be called once with app.use argument', () => {
    const csurf = require('csurf')
    const app = appFactoryRewire.__get__('app')
    const AppFactory = appFactoryRewire.__get__('AppFactory')
    const appUseSpy = sinon.spy(app, 'use')
    const appInstance = new AppFactory()

    appInstance.createApp()

    verifyFunctionArgCall(appUseSpy, csurf({ cookies: true }))
    sinon.restore()
  })
})

Answer 2

Implementing a helper function to compare function arguments as strings:

app-factory.test.js

const chai = require('chai')
const assert = chai.assert
const rewire = require('rewire')
const appFactoryRewire = rewire('../server/app-factory.js')
const sinon = require('sinon')

/**
 * Custom Helper Function: Check if argument is called with expected function
 * @param {*} spyFn - Sinon Spy function
 * @param {*} argFn - Callback or function parameter
 */
function verifyFunctionArgCall (spyFn, argFn) {
  const calls = spyFn.getCalls()
  const argFnString = argFn.toString()
  let foundMatch = false
  for (const call in calls) {
    const arg = spyFn.getCall(call).args[0]
    if (arg.toString() === argFnString) {
      foundMatch = true
    }
  }
  assert(foundMatch === true, 
    'Spy function/method was not called with the expected function')
}

describe('Testing csurf middleware', () => {
  const rewiredCsurf = appFactoryRewire.__get__('csurf')

  it('should be defined', () => {
    assert.exists(rewiredCsurf)
  })

  it('should be a function', () => {
    assert.isFunction(rewiredCsurf)
  })

  it('should equal to csurf module', () => {
    assert.strictEqual(rewiredCsurf, require('csurf'))
  })

  it('should be called once with app.use argument', () => {
    const csurf = require('csurf')
    const app = appFactoryRewire.__get__('app')
    const AppFactory = appFactoryRewire.__get__('AppFactory')
    const appUseSpy = sinon.spy(app, 'use')
    const appInstance = new AppFactory()

    appInstance.createApp()

    verifyFunctionArgCall(appUseSpy, csurf({ cookies: true }))
    sinon.restore()
  })
})

Answer 3

Answer №2

Software testing solution:

app-factory.js:

const express = require('express');
const app = express();
const csurf = require('csurf');
const cookieParser = require('cookie-parser');

class AppFactory {
  createApp() {
    app.use(csurf({ cookie: true }));
    app.use(cookieParser());
    return app;
  }
}

module.exports = {
  AppFactory: AppFactory,
  app: app,
};

app-factory.test.js:

const chai = require('chai');
const rewire = require('rewire');
const sinon = require('sinon');
const { expect } = chai;

describe('Testing csurf middleware functionality', () => {
  it('Verifies that csurf middleware is called once as an argument by app.use', (done) => {
    const appFactory = rewire('./app-factory');
    const mCsurfRequestHandler = sinon.stub();
    const mCsurf = sinon.stub().returns(mCsurfRequestHandler);
    const mCookieParserRequestHandler = sinon.stub();
    const mCookieParser = sinon.stub().returns(mCookieParserRequestHandler);
    appFactory.__with__({
      csurf: mCsurf,
      cookieParser: mCookieParser,
    })(() => {
      const appUseStub = sinon.stub(appFactory.app, 'use');
      const appInstance = new appFactory.AppFactory();
      const actual = appInstance.createApp();
      expect(actual).to.be.equal(appFactory.app);
      sinon.assert.calledWithExactly(mCsurf, { cookie: true });
      sinon.assert.calledOnce(mCookieParser);
      sinon.assert.calledWith(appUseStub, mCsurfRequestHandler);
      sinon.assert.calledWith(appUseStub, mCookieParserRequestHandler);
      done();
    });
  });
});

Test Results:

  Testing csurf middleware functionality
    ✓ Verifies that csurf middleware is called once as an argument by app.use (214ms)


  1 passing test case (223ms)

----------------|---------|----------|---------|---------|-------------------
File            | % Stmts | % Branch | % Funcs | % Lines | Uncovered Line #s 
----------------|---------|----------|---------|---------|-------------------
All files       |     100 |      100 |     100 |     100 |                   
 app-factory.js |     100 |      100 |     100 |     100 |                   
----------------|---------|----------|---------|---------|-------------------

Answer 4

Software testing solution:

app-factory.js:

const express = require('express');
const app = express();
const csurf = require('csurf');
const cookieParser = require('cookie-parser');

class AppFactory {
  createApp() {
    app.use(csurf({ cookie: true }));
    app.use(cookieParser());
    return app;
  }
}

module.exports = {
  AppFactory: AppFactory,
  app: app,
};

app-factory.test.js:

const chai = require('chai');
const rewire = require('rewire');
const sinon = require('sinon');
const { expect } = chai;

describe('Testing csurf middleware functionality', () => {
  it('Verifies that csurf middleware is called once as an argument by app.use', (done) => {
    const appFactory = rewire('./app-factory');
    const mCsurfRequestHandler = sinon.stub();
    const mCsurf = sinon.stub().returns(mCsurfRequestHandler);
    const mCookieParserRequestHandler = sinon.stub();
    const mCookieParser = sinon.stub().returns(mCookieParserRequestHandler);
    appFactory.__with__({
      csurf: mCsurf,
      cookieParser: mCookieParser,
    })(() => {
      const appUseStub = sinon.stub(appFactory.app, 'use');
      const appInstance = new appFactory.AppFactory();
      const actual = appInstance.createApp();
      expect(actual).to.be.equal(appFactory.app);
      sinon.assert.calledWithExactly(mCsurf, { cookie: true });
      sinon.assert.calledOnce(mCookieParser);
      sinon.assert.calledWith(appUseStub, mCsurfRequestHandler);
      sinon.assert.calledWith(appUseStub, mCookieParserRequestHandler);
      done();
    });
  });
});

Test Results:

  Testing csurf middleware functionality
    ✓ Verifies that csurf middleware is called once as an argument by app.use (214ms)


  1 passing test case (223ms)

----------------|---------|----------|---------|---------|-------------------
File            | % Stmts | % Branch | % Funcs | % Lines | Uncovered Line #s 
----------------|---------|----------|---------|---------|-------------------
All files       |     100 |      100 |     100 |     100 |                   
 app-factory.js |     100 |      100 |     100 |     100 |                   
----------------|---------|----------|---------|---------|-------------------

Ensuring that Express app.use is triggered with a middleware function: A guide using Mocha

Answer №1

Answer №2

Similar questions

Monitor the download status of clients from the server

Having trouble updating a specific document in my MongoDB collection

Transmitting files instantly without the need for a response body

Authentication is necessary for the "insert" command when establishing a connection to a remote database server | error code: 13, error code name

Dynamic content is not displaying when utilizing the email-template-v2 package in Node.js

There is no compatible version available for @typescript-eslint/[email protected]

Automatically update and reload Express.js routes without the need to manually restart the server

"Master chef preparing a delicious dish with fresh ingredients, skillfully incorporating node, npm

Is it possible to run a React, Vite, Node.js, and Express app all at once

error message: sendFile function not recognizing basename and dirname parameters

Is it feasible to indent lines in a template without affecting the content alignment?

Can you provide the function that updates subscription and account details using Recurly JS?

What regular expression should be used to meet the following requirement in JavaScript?

Having trouble installing my package with npm

Encountering a Typescript error while attempting to utilize mongoose functions

Guide to Setting User Permissions with CheckboxList in MERN Stack

Developing single-page application frontends without utilizing node or npm

Is there a way to allow an HTML page rendered by node.js to communicate back to its corresponding node.js file?

How to add multiple entries using Node.js and Tedious

How can I utilize angular's $http service to fetch a JavaScript file?