Merge branch 'release/0.0.2'

Author: BryanDonovan

.jshintrc

@@ -76,6 +76,6 @@
     "sub"           : true,   // Tolerate all forms of subscript notation besides dot notation e.g. `dict['key']` instead of `dict.key`.
     "trailing"      : true,   // Prohibit trailing whitespaces. (only works if white is 'true')
     "white"         : true,   // Check against strict whitespace and indentation rules.
-    "indent"        : 4,      // ignored because "white" is false.
+    "indent"        : 4,      // Enforce consistent indenting.
     "unused"        : true
 }

HISTORY.md

@@ -0,0 +1,5 @@
+- 0.0.1
+  Initial release.
+
+- 0.0.2
+  Added responder.redirect().

Makefile

@@ -4,7 +4,7 @@ ISTANBUL = ./node_modules/.bin/istanbul
 TEST_COMMAND = NODE_ENV=test ./node_modules/.bin/mocha
 COVERAGE_OPTS = --lines 95 --statements 90 --branches 80 --functions 90
 
-main: lint test test-buster
+main: lint test
 
 cover:
 	$(ISTANBUL) cover test/run.js
@@ -26,4 +26,4 @@ lint:
 	./node_modules/.bin/jshint ./test --config $(BASE)/.jshintrc
 
 
-.PHONY: test test-buster
+.PHONY: test

lib/server/responder.js

@@ -1,5 +1,13 @@
 var restify = require('restify');
 
+function is_full_url(url) {
+    return url.indexOf('://') !== -1;
+}
+
+function is_relative_path(url) {
+    return url.indexOf('.') === 0;
+}
+
 var responder = {
     error: function (res, err, next) {
         next(err);
@@ -32,6 +40,57 @@ var responder = {
         } else {
             responder.success(res, data, next);
         }
+    },
+
+    /**
+     * Send an HTTP redirect response.
+     * @param {Object} args - hash of args:
+     *   - url (required): Can be one of the following:
+     *      - Full URL with host (and optionally, port).
+     *      - Full path relative to this server.
+     *      - Relative path, relative to the path being requested.
+     *   - status (default 302) - the HTTP status code to use.
+     *
+     * @example
+     *   Say your server's host is http://example.com.
+     *     Full URL:
+     *        redirect(req, res, {url: 'http://google.com'}, next)
+     *        > sets location to 'http://google.com'
+     *     Full path:
+     *        redirect(req, res, {url: '/foo/bar'}, next)
+     *        > sets location to http://example.com/foo/bar
+     *     Relative path:
+     *        If you request http://example.com/buzz:
+     *        redirect(req, res, {url: './foo/bar'}, next)
+     *        > sets location to http://example.com/buzz/foo/bar
+     *
+     * TODO: Maybe change args names to 'url', 'path', and 'relative_path' since paths aren't really URLs.
+     * TODO: Maybe allow a body to be set, e.g.
+     *       var body = require('http').STATUS_CODES[status] + '. Redirecting to ' + url;
+     */
+    redirect: function (req, res, args, next) {
+        args = args || {};
+        var url = args.url;
+        var status = args.status || 302;
+        var content_type = 'application/json; charset=utf-8'; // maybe allow this as an optional arg?
+        if (!args.url) {
+            return responder.error(res, new restify.InternalError('Redirect requires url arg'), next);
+        }
+
+        if (!is_full_url(url)) {
+            var host = req.headers.host;
+            if (is_relative_path(url)) {
+                url = url.replace(/^./, '');
+                url = host + req.path + url;
+            } else {
+                url = host + '/' + url;
+            }
+        }
+
+        res.header('Content-Type', content_type);
+        res.header('Location', url);
+        res.send(status);
+        return next(false);
     }
 };
 

package.json

@@ -1,6 +1,6 @@
 {
     "name": "nodejs-tdd-boilerplate",
-    "version": "0.0.1",
+    "version": "0.0.2",
     "description": "TDD boilerplate for NodeJS API apps",
     "author": "Bryan Donovan",
     "engines": {

test/server/responder.functional.js

@@ -8,6 +8,26 @@ var methods = {
     get_restify_error: function (req, res, next) {
         var error = new restify.InvalidArgumentError('foo arg invalid');
         return responder.error(res, error, next);
+    },
+
+    redirect_to_full_url: function (req, res, next) {
+        var args = {url: 'http://google.com'};
+        return responder.redirect(req, res, args, next);
+    },
+
+    redirect_to_full_url_301: function (req, res, next) {
+        var args = {url: 'http://google.com', status: 301};
+        return responder.redirect(req, res, args, next);
+    },
+
+    redirect_to_full_path: function (req, res, next) {
+        var args = {url: 'foo/bar'};
+        return responder.redirect(req, res, args, next);
+    },
+
+    redirect_to_relative_path: function (req, res, next) {
+        var args = {url: './foo/bar'};
+        return responder.redirect(req, res, args, next);
     }
 };
 
@@ -17,17 +37,43 @@ var routes = [
         url: "/test/errors/restify",
         func: methods.get_restify_error,
         middleware: []
+    },
+    {
+        method: "get",
+        url: "/test/redirects/full_url",
+        func: methods.redirect_to_full_url,
+        middleware: []
+    },
+    {
+        method: "get",
+        url: "/test/redirects/full_url_301",
+        func: methods.redirect_to_full_url_301,
+        middleware: []
+    },
+    {
+        method: "get",
+        url: "/test/redirects/full_path",
+        func: methods.redirect_to_full_path,
+        middleware: []
+    },
+    {
+        method: "get",
+        url: "/test/redirects/relative_path",
+        func: methods.redirect_to_relative_path,
+        middleware: []
     }
 ];
 
 describe("functional - server/responder.js", function () {
     var server;
     var http_client;
+    var http_string_client;
 
     before(function () {
         server = http.server.create(routes);
         server.start();
         http_client = http.client();
+        http_string_client = http.string_client();
     });
 
     after(function () {
@@ -50,4 +96,51 @@ describe("functional - server/responder.js", function () {
             });
         });
     });
+
+    describe("redirect()", function () {
+        context("when full URL passed in", function () {
+            context("and no status passed in", function () {
+                it("redirects to the full URL with status 302", function (done) {
+                    http_client.get('/test/redirects/full_url', function (err, result, raw_res) {
+                        assert.equal(raw_res.headers.location, 'http://google.com');
+                        assert.equal(raw_res.statusCode, 302);
+                        done();
+                    });
+                });
+            });
+
+            context("and status 301 passed in", function () {
+                it("redirects to the full URL with status 301", function (done) {
+                    http_client.get('/test/redirects/full_url_301', function (err, result, raw_res) {
+                        assert.equal(raw_res.headers.location, 'http://google.com');
+                        assert.equal(raw_res.statusCode, 301);
+                        done();
+                    });
+                });
+            });
+        });
+
+        context("when full path passed in without host and port", function () {
+            it("redirects to the correct URL using request's host and port", function (done) {
+                http_client.get('/test/redirects/full_path', function (err, result, raw_res) {
+                    var expected_location = http.host + ':' + http.port + '/foo/bar';
+                    assert.equal(raw_res.headers.location, expected_location);
+                    assert.equal(raw_res.statusCode, 302);
+                    done();
+                });
+            });
+        });
+
+        context("when relative path passed in", function () {
+            it("redirects to the correct URL using request's host and port", function (done) {
+                var starting_path = '/test/redirects/relative_path';
+                http_client.get(starting_path, function (err, result, raw_res) {
+                    var expected_location = http.host + ':' + http.port + starting_path + '/foo/bar';
+                    assert.equal(raw_res.headers.location, expected_location);
+                    assert.equal(raw_res.statusCode, 302);
+                    done();
+                });
+            });
+        });
+    });
 });

test/server/responder.unit.js

@@ -8,6 +8,8 @@ var fake_res = {
     json: function () {}
 };
 
+var fake_req = {};
+
 var fake_next = function () {};
 
 
@@ -43,8 +45,8 @@ describe("responder.js", function () {
                 responder.success(fake_res, null, fake_next);
 
                 assert.ok(responder.error.called);
-                responder.error.restore();
 
+                responder.error.restore();
                 done();
             });
         });
@@ -62,4 +64,43 @@ describe("responder.js", function () {
             });
         });
     });
+
+    describe("redirect()", function () {
+        var args;
+
+        beforeEach(function () {
+            args = {url: '/foo/bar'};
+        });
+
+        context("when no args passed in", function () {
+            it("responds with an InternalError", function (done) {
+                sinon.stub(responder, 'error', function (res, err, next) {
+                    next();
+                });
+
+                responder.redirect(fake_res, fake_req, null, fake_next);
+
+                assert.ok(responder.error.called);
+
+                responder.error.restore();
+                done();
+            });
+        });
+
+        context("when args.user not passed in", function () {
+            it("responds with an InternalError", function (done) {
+                sinon.stub(responder, 'error', function (res, err, next) {
+                    next();
+                });
+
+                delete args.url;
+                responder.redirect(fake_res, fake_req, args, fake_next);
+
+                assert.ok(responder.error.called);
+
+                responder.error.restore();
+                done();
+            });
+        });
+    });
 });

test/support/http.js

@@ -41,8 +41,11 @@ function HttpClient(args) {
     this.port = args.port;
     this.url = 'http://' + this.host + ':' + this.port;
 
-    //this.client = restify.createStringClient({url: this.url});
-    this.client = restify.createJsonClient({url: this.url});
+    if (args.type === 'string') {
+        this.client = restify.createStringClient({url: this.url});
+    } else {
+        this.client = restify.createJsonClient({url: this.url});
+    }
 }
 
 HttpClient.prototype.get = function (path_or_options, cb) {
@@ -51,6 +54,12 @@ HttpClient.prototype.get = function (path_or_options, cb) {
     });
 };
 
+HttpClient.prototype.get_plain = function (path_or_options, cb) {
+    this.string_client.get(path_or_options, function (err, req, res, data) {
+        cb(err, data, res, req);
+    });
+};
+
 HttpClient.prototype.post = function (path_or_options, body, cb) {
     this.client.post(path_or_options, body, function (err, req, res, data) {
         cb(err, data, res, req);
@@ -70,6 +79,10 @@ HttpClient.prototype.del = function (path_or_options, cb) {
 };
 
 var http = {
+    string_client: function () {
+        return new HttpClient({host: host, port: port, type: 'string'});
+    },
+
     client: function () {
         return new HttpClient({host: host, port: port});
     },