Testing expressjs Middleware
The middleware is one of the components that improve the composability of expressjs router. This blog post approaches middleware testing from a real-world perspective. The use case is a CORS since found in almost all expressjs enabled applications.
In this article we will talk about:
- How to mock Request/Response Objects
- Spying if certain calls have been called
- Make sure the requests don't leave the local machine.
Even though this blog post was designed to offer complementary materials to those who bought my Testing
nodejsApplications book, the content can help any software developer to tuneup working environment. You use this link to buy the book.
Show me the code
The CORS middleware is one of the most used middleware in the nodejs community.
module.exports = function cors(req, res, next) {
res.set('Access-Control-Allow-Credentials', true);
res.set('Access-Control-Allow-Origin', '*');
res.set('Access-Control-Allow-Methods', 'GET,PUT,POST,DELETE,OPTIONS');
res.set('Access-Control-Allow-Headers', 'X-CSRF-Token, X-CSRF-Strategy, X-Requested-With, Accept, Authorization, Accept-Version, Content-Length, Content-MD5, Content-Type, Date, X-Api-Version');
res.set('Content-Type', 'application/json');
res.set('Access-Control-Allow-Max-Age', 3600);
return req && req.method === 'OPTIONS' ? res.send(200) : next();
};
Example: CORS middleware in lib/middleware/cors.js
Code sample is modeled from: Unit Testing Controllers the Easy Way in Express 4
What can possibly go wrong?
As is the case for routers, the following points may be other challenges when unit testing expressjs middleware:
- Mock database read/write operations for a middleware that reads/writes from/to a database
- Mocking read/write from/to third-party services to avoid integration testing trap
Choosing tools
If you haven't already, reading “How to choose the right tools” blog post gives insights on a framework we used to choose the tools we suggest in this blog.
Following our tiny Choosing the right tools framework, the following tools make sense in a context of this blog, when testing expressjs routes middleware:
- There exists well respected such as
jasmine(jasmine-node),ava,jestin the wild.mochacan just do fine for examples sakes. - There is also code instrumentation tools in the wild.
mochaintegrates well withistanbultest coverage and reporting library.
The testing stack
mocha,chaiandsinonworths a shot for most use cases.
Workflow
If you haven't already, read the “How to write test cases developers will love”
# In package.json at "test" - add next line
> "istanbul test mocha -- --color --reporter mocha-lcov-reporter specs"
# OR $ nyc test mocha -- --color --reporter mocha-lcov-reporter specs
# Then run the tests using
$ npm test --coverage
Example: istanbul generates reports as tests progress
Show me the tests
Have you ever wondered where to start from, when refactoring a code block? That is a common source of frustration and the bad decision-making that generally follows. When paying off technical debt, small bad moves can build up into catastrophe, such as having unexpected downtime with little to no failure traceability.
This blog post approaches testing of fairly large nodejs application from a real-world perspective and with refactoring in mind.
The mainstream philosophy about automated testing is to write failing tests, followed by code that resolves the failing use cases. In the real world, a writing test should start as it should follow writing code. A particular case is when dealing with untested code.
var sinon = require('sinon'),
chai = require('chai'),
expect = chai.expect,
cors = require('./middleware').cors,
req,
res,
next;
describe("cors()", function() {
before(function(){
req = {},
res = { send: sinon.spy()},
next = sinon.spy();
});
it("should skip preflight requests", function() {
req = {method: 'OPTIONS'};//preflight requests have method === options
cors(req, res, next);
expect(res.send.calledOnce).to.equal(true);
res.send.restore();
});
it('should decorate requests with CORS permissions', function() => {
cors(req, res, next);
expect(next.calledOnce).to.equal(true);
next.restore();
});
});
Example:
Special Use Case: How to mock a response that will be used with a Streaming Source.
It worths mentioning that mocking a request object is not rocket science. An empty object, with the right methods we use in a given test, is sufficient enough to assert whether areas of our interest are covered.
Conclusion
Automated testing of any JavaScript project is quite intimidating for newbies and veterans alike.
In this article, we reviewed how testing tends to be more of an art, than science. We also stressed the fact that, like in any art, practice makes perfect. One way this idea may be reflected in real life is by testing middleware as an isolated reusable, composable component that the middleware constitutes. Writing a good meaningful testing message is pure art.
There are additional complimentary materials in the “Testing nodejs applications” book.