Adding proxy tests and doing a little refactoring

Makefile

@@ -2,7 +2,7 @@ REPORTER = dot
 
 test: 
 	@#lib-cov
-	@NODE_ENV=test ./node_modules/.bin/mocha --recursive --reporter $(REPORTER) --ignore-leaks
+	@NODE_ENV=test ./node_modules/.bin/mocha --recursive --reporter $(REPORTER) --ignore-leaks --timeout 3000
 	@#$(MAKE) rm-lib-cov
 
 tests: test
@@ -27,7 +27,7 @@ tap: lib-cov
 
 unit: 
 	@#lib-cov
-	@NODE_ENV=test ./node_modules/.bin/mocha --recursive -R xunit --ignore-leaks > results.xml
+	@NODE_ENV=test ./node_modules/.bin/mocha --recursive -R xunit --ignore-leaks > results.xml --timeout 3000
 	@#$(MAKE) rm-lib-cov
 
 .PHONY: test tap test-cv test-cov-html unit lib-cov rm-lib-cov

lib/error.js

@@ -14,7 +14,7 @@ exports = module.exports = internals.Error = function (code, message, options) {
 
     Utils.assert(this.constructor === internals.Error, 'Error must be instantiated using new');
     Utils.assert(!options || !options.toResponse || typeof options.toResponse === 'function', 'options.toReponse must be a function');
-    Utils.assert(code >= 400 && code < 600, 'Error code must be 4xx or 5xx');
+    Utils.assert(code >= 400, 'Error code must be 4xx or 5xx');
 
     Error.call(this);
 
@@ -158,10 +158,4 @@ internals.Error.toResponse = function (err) {
     }
 
     return response;
-};
-
-
-
-
-
-
+};

lib/proxy.js

@@ -14,23 +14,19 @@ var internals = {};
 
 exports = module.exports = internals.Proxy = function (options, route) {
 
-    var self = this;
-
     Utils.assert(options, 'Missing options');
-    Utils.assert(options.host || options.mapUri, 'Missing options.host and no options.mapUri');
+    Utils.assert(!!options.host ^ !!options.mapUri, 'Must have either options.host or options.mapUri');
     Utils.assert(!options.passThrough || !route.cache.isMode('server'), 'Cannot use pass-through proxy mode with caching');
     Utils.assert(!options.mapUri || typeof options.mapUri === 'function', 'options.mapUri must be a function');
     Utils.assert(!options.postResponse || typeof options.postResponse === 'function', 'options.postResponse must be a function');
     Utils.assert(!options.hasOwnProperty('isCustomPostResponse'), 'Cannot manually set options.isCustomPostResponse');
 
-    this.settings = Utils.clone(options);                                                           // Options can be reused
-    this.settings.protocol = this.settings.protocol || 'http';
-    this.settings.port = this.settings.port || (this.settings.protocol === 'http' ? 80 : 443);
-    this.settings.xforward = this.settings.xforward || false;
-    this.settings.passHeaders = this.settings.passThrough || false;
-    this.settings.mapUri = this.settings.mapUri || internals.mapUri;                       // function (request, settings, function (err, uri, query))
-    this.settings.isCustomPostResponse = !!this.settings.postResponse;
-    this.settings.postResponse = this.settings.postResponse || internals.postResponse;     // function (request, settings, response, payload)
+    this.settings = {};
+    this.settings.mapUri = options.mapUri || internals.mapUri(options.protocol, options.host, options.port);
+    this.settings.xforward = options.xforward || false;
+    this.settings.passHeaders = options.passThrough || false;
+    this.settings.isCustomPostResponse = !!options.postResponse;
+    this.settings.postResponse = options.postResponse || internals.postResponse;     // function (request, settings, response, payload)
 
     return this;
 };
@@ -42,7 +38,7 @@ internals.Proxy.prototype.handler = function () {
 
     return function (request) {
 
-        self.settings.mapUri(request, self.settings, function (err, uri, query) {
+        self.settings.mapUri(request, function (err, uri, query) {
 
             if (err) {
                 return request.reply(err);
@@ -57,7 +53,7 @@ internals.Proxy.prototype.handler = function () {
                 headers: {}
             };
 
-            if (self.settings.passThrough) {                        // Never set with cache
+            if (self.settings.passHeaders) {                        // Never set with cache
                 options.headers = Utils.clone(req.headers);
                 delete options.headers.host;
             }
@@ -116,22 +112,31 @@ internals.Proxy.prototype.handler = function () {
 };
 
 
-internals.mapUri = function (request, settings, callback) {
+internals.mapUri = function (protocol, host, port) {
+
+    protocol = protocol || 'http';
+    port = port || (protocol === 'http' ? 80 : 443);
+    var baseUrl = protocol + '://' + host + ':' + port;
+
+    return function(request, callback) {
 
-    return callback(null, settings.protocol + '://' + settings.host + ':' + settings.port + request.path, request.query);
+        return callback(null, baseUrl + request.path, request.query);
+    };
 };
 
 
 internals.postResponse = function (request, settings, response, payload) {
 
-    if (response.statusCode >= 400) {
-        return request.reply(Err.internal('Error proxy response', { code: response.statusCode, payload: payload }));
+    var contentType = response.headers['content-type'];
+    var statusCode = response.statusCode;
+
+    if (statusCode >= 400) {
+        return request.reply(Err.passThrough(statusCode, payload, contentType));
     }
 
-    if (response.headers['content-type']) {
-        request.reply.type(response.headers['content-type']);
+    if (contentType) {
+        request.reply.type(contentType);
     }
 
     return request.reply(payload);
-};
-
+};

test/integration/proxy.js

@@ -14,10 +14,8 @@ describe('Proxy', function () {
     function startServer(done) {
 
         var listening = false;
-        var config = null;
 
         var routeCache = {
-            mode: 'server',
             expiresIn: 500
         };
 
@@ -32,13 +30,20 @@ describe('Proxy', function () {
         var dummyServer = new Hapi.Server('0.0.0.0', 18093);
         dummyServer.addRoutes([{ method: 'GET', path: '/profile', config: { handler: profile } },
             { method: 'GET', path: '/item', config: { handler: activeItem } },
-            { method: 'POST', path: '/item', config: { handler: item } }]);
+            { method: 'POST', path: '/item', config: { handler: item } },
+            { method: 'GET', path: '/unauthorized', config: { handler: unauthorized }},
+            { method: 'POST', path: '/echo', config: { handler: echoPostBody } }
+        ]);
 
         _server = new Hapi.Server('0.0.0.0', 18092, config);
         _server.addRoutes([
             { method: 'GET', path: '/profile', config: { proxy: { host: '127.0.0.1', port: 18093, xforward: true, passThrough: true } } },
             { method: 'GET', path: '/item', config: { proxy: { host: '127.0.0.1', port: 18093 }, cache: routeCache } },
-            { method: 'POST', path: '/item', config: { proxy: { host: '127.0.0.1', port: 18093 } } }
+            { method: 'GET', path: '/unauthorized', config: { proxy: { host: '127.0.0.1', port: 18093 }, cache: routeCache } },
+            { method: 'POST', path: '/item', config: { proxy: { host: '127.0.0.1', port: 18093 } } },
+            { method: 'POST', path: '/notfound', config: { proxy: { host: '127.0.0.1', port: 18093 } } },
+            { method: 'GET', path: '/postResponseError', config: { proxy: { host: '127.0.0.1', port: 18093, postResponse: postResponseWithError }, cache: routeCache } },
+            { method: 'POST', path: '/echo', config: { proxy: { mapUri: mapUri } } }
         ]);
 
         dummyServer.listener.on('listening', function () {
@@ -62,28 +67,58 @@ describe('Proxy', function () {
         _server.start();
     }
 
+    function mapUri(request, callback) {
+
+        return callback(null, 'http://127.0.0.1:18093' + request.path, request.query);
+    }
+
     function profile(request) {
+
         request.reply({
             'id': 'fa0dbda9b1b',
             'name': 'John Doe'
         });
     }
 
     function activeItem(request) {
+
         request.reply({
             'id': '55cf687663',
             'name': 'Active Item'
         });
     }
 
     function item(request) {
+
         request.reply.created('http://google.com')({
             'id': '55cf687663',
             'name': 'Item'
         });
     }
 
+    function echoPostBody(request) {
+
+        request.reply(request.payload);
+    }
+
+    function unauthorized(request) {
+
+        request.reply(Hapi.Error.unauthorized('Not authorized'));
+    }
+
+    function postResponseWithError(request) {
+
+        request.reply(Hapi.Error.forbidden('Forbidden'));
+    }
+
+    function postResponse(request, settings, response, payload) {
+
+        request.reply.type(response.headers['content-type']);
+        request.reply(payload);
+    }
+
     function makeRequest(options, callback) {
+
         var next = function (err, res) {
             return callback(res);
         };
@@ -94,31 +129,84 @@ describe('Proxy', function () {
 
         Request({
             method: options.method,
-            url: _serverUrl + options.path
+            url: _serverUrl + options.path,
+            form: options.form
         }, next);
     }
 
     it('forwards on the response when making a GET request', function (done) {
+
         makeRequest({ path: '/profile' }, function (rawRes) {
+
             expect(rawRes.statusCode).to.equal(200);
             expect(rawRes.body).to.contain('John Doe');
             done();
         });
     });
 
     it('forwards on the response when making a GET request to a route that also accepts a POST', function (done) {
+
         makeRequest({ path: '/item' }, function (rawRes) {
+
             expect(rawRes.statusCode).to.equal(200);
             expect(rawRes.body).to.contain('Active Item');
             done();
         });
     });
 
     it('forwards on the status code when making a POST request', function (done) {
+
         makeRequest({ path: '/item', method: 'post' }, function (rawRes) {
+
             expect(rawRes.statusCode).to.equal(201);
             expect(rawRes.body).to.contain('Item');
             done();
         });
     });
+
+    it('sends the correct status code with a request is unauthorized', function(done) {
+
+        makeRequest({ path: '/unauthorized', method: 'get' }, function (rawRes) {
+
+            expect(rawRes.statusCode).to.equal(401);
+            done();
+        });
+    });
+
+    it('sends a 404 status code with a proxied route doesn\'t exist', function(done) {
+
+        makeRequest({ path: '/notfound', method: 'get' }, function (rawRes) {
+
+            expect(rawRes.statusCode).to.equal(404);
+            done();
+        });
+    });
+
+    it('forwards on the status code when a custom postResponse returns an error', function(done) {
+
+        makeRequest({ path: '/postResponseError', method: 'get' }, function (rawRes) {
+
+            expect(rawRes.statusCode).to.equal(403);
+            done();
+        });
+    });
+
+    it('forwards the error message with a custom postResponse and a route error', function(done) {
+
+        makeRequest({ path: '/postResponseNotFound', method: 'get' }, function (rawRes) {
+
+            expect(rawRes.body).to.contain('error');
+            done();
+        });
+    });
+
+    it('forwards on a POST body', function(done) {
+
+        makeRequest({ path: '/echo', method: 'post', form: { echo: true } }, function (rawRes) {
+
+            expect(rawRes.statusCode).to.equal(200);
+            expect(rawRes.body).to.contain('echo');
+            done();
+        });
+    });
 });