compose-middleware/lib/index.spec.js

Compose an array of middleware into a single function for use in Express, Connect, router, etc.

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var index_1 = require("./index");
var chai_1 = require("chai");
describe('compose middleware', function () {
    it('should be assignable to array of middleware', function (done) {
        var pipeline = function () {
            var middlewares = [];
            for (var _i = 0; _i < arguments.length; _i++) {
                middlewares[_i] = arguments[_i];
            }
            return index_1.compose(middlewares);
        };
        var middleware = pipeline(function (req, res, next) { return next(); });
        return middleware(undefined, undefined, done);
    });
    it('should compose middleware', function (done) {
        var middleware = index_1.compose([
            function (req, res, next) {
                req.one = true;
                next();
            },
            function (req, res, next) {
                req.two = true;
                next();
            }
        ]);
        var req = {};
        var res = {};
        middleware(req, res, function (err) {
            chai_1.expect(err).to.equal(undefined);
            chai_1.expect(req.one).to.equal(true);
            chai_1.expect(req.two).to.equal(true);
            return done();
        });
    });
    it('should exit with an error', function (done) {
        var middleware = index_1.compose([
            function (req, res, next) {
                req.one = true;
                next(new Error('test'));
            },
            function (req, res, next) {
                req.two = true;
                next();
            }
        ]);
        var req = {};
        var res = {};
        middleware(req, res, function (err) {
            chai_1.expect(err).instanceOf(Error);
            chai_1.expect(req.one).to.equal(true);
            chai_1.expect(req.two).to.equal(undefined);
            return done();
        });
    });
    it('should short-cut handler with a single function', function (done) {
        var middleware = index_1.compose([
            function (req, res, next) {
                req.one = true;
                next();
            }
        ]);
        var req = {};
        var res = {};
        middleware(req, res, function (err) {
            chai_1.expect(err).to.equal(undefined);
            chai_1.expect(req.one).to.equal(true);
            return done();
        });
    });
    it('should accept a single function', function (done) {
        var middleware = index_1.compose(function (req, res, next) {
            req.one = true;
            next();
        });
        var req = {};
        middleware(req, {}, function (err) {
            chai_1.expect(err).to.equal(undefined);
            chai_1.expect(req.one).to.equal(true);
            return done();
        });
    });
    it('should noop with no middleware', function (done) {
        var middleware = index_1.compose([]);
        middleware({}, {}, done);
    });
    it('should validate all handlers are functions', function () {
        chai_1.expect(function () { return index_1.compose(['foo']); }).to.throw(TypeError, 'Handlers must be a function');
    });
    it('should support error handlers', function (done) {
        var middleware = index_1.compose(function (req, res, next) {
            return next(new Error('test'));
        }, function (_, req, res, next) {
            return next();
        }, function (req, res, next) {
            req.success = true;
            return next();
        }, function (_, req, res, next) {
            req.fail = true;
            return next();
        });
        var req = {};
        middleware(req, {}, function (err) {
            chai_1.expect(req.fail).to.equal(undefined);
            chai_1.expect(req.success).to.equal(true);
            return done(err);
        });
    });
    it('should error when calling `next()` multiple times', function (done) {
        var middleware = index_1.compose(function (req, res, next) {
            next();
            next();
        });
        try {
            middleware({}, {}, function () { });
        }
        catch (err) {
            chai_1.expect(err.message).to.equal('`next()` called multiple times');
            return done();
        }
    });
    it('should forward thrown errors', function (done) {
        var middleware = index_1.compose(function (req, res, next) {
            throw new Error('Boom!');
        });
        middleware({}, {}, function (err) {
            chai_1.expect(err).instanceOf(Error);
            chai_1.expect(err.message).to.equal('Boom!');
            return done();
        });
    });
    it('should not cascade errors from `done()`', function (done) {
        var request = {
            done: 0,
            first: 0,
            second: 0,
            third: 0
        };
        var middleware = index_1.compose(function (req, res, next) {
            req.first++;
            return next();
        }, function (req, res, next) {
            req.second++;
            throw new TypeError('Boom!');
        }, function (req, res, next) {
            req.third++;
            return next();
        });
        try {
            middleware(request, {}, function () {
                request.done++;
                throw new TypeError('This is the end');
            });
        }
        catch (err) {
            chai_1.expect(request.done).to.equal(1);
            chai_1.expect(request.first).to.equal(1);
            chai_1.expect(request.second).to.equal(1);
            chai_1.expect(request.third).to.equal(0);
            chai_1.expect(err).instanceOf(TypeError);
            chai_1.expect(err.message).to.equal('This is the end');
            return done();
        }
        return done(new TypeError('Missed thrown error'));
    });
    it('should avoid handling post-next thrown errors', function (done) {
        var middleware = index_1.compose(function (req, res, next) {
            return next();
        }, function (req, res, next) {
            next();
            throw new TypeError('Boom!');
        }, function (req, res, next) {
            return setTimeout(next);
        });
        try {
            middleware({}, {}, function (err) {
                return done(err);
            });
        }
        catch (err) {
            chai_1.expect(err).instanceOf(TypeError);
            chai_1.expect(err.message).to.equal('Boom!');
            return;
        }
        return done(new TypeError('Missed thrown error'));
    });
    it('should compose functions without all arguments', function (done) {
        var middleware = index_1.compose(function (req, res, next) {
            return next();
        }, function () {
            return done();
        });
        middleware({}, {}, function (err) {
            return done(err || new Error('Middleware should not have finished'));
        });
    });
});
//# sourceMappingURL=index.spec.js.map