adding server tests

Author: BryanDonovan

lib/server/app_registrar.js

@@ -1,22 +1,23 @@
+var fs = require('fs');
 var path = require('path');
 var lib_dir = path.resolve(__dirname, '../');
 var router = require('./router');
-var ENV = process.env.NODE_ENV;
 
-function AppRegistrar(server, app_name, options) {
-    options = options || {};
-    var self = this;
-    self.server = server;
-    self.app_path = path.join(lib_dir, 'apps', app_name);
+function AppRegistrar(server, app_name) {
+    this.server = server;
+    if (!this.server) {
+        throw new Error('AppRegistrar requires a server instance');
+    }
+
+    this.app_path = path.join(lib_dir, 'apps', app_name);
+    if (!fs.existsSync(this.app_path)) {
+        throw new Error('AppRegistrar: app not found at path ' + this.app_path);
+    }
 }
 
 AppRegistrar.prototype.register = function () {
-    var self = this;
-    var routes = require(path.join(self.app_path, 'routes'));
-    if (routes) {
-        //log.debug("register routes for: " + app_name);
-        router.register_routes(self.server, routes);
-    }
+    var routes = require(path.join(this.app_path, 'routes'));
+    router.register_routes(this.server, routes);
 };
 
 module.exports = AppRegistrar;

lib/server/app_server.js

@@ -22,26 +22,15 @@ function AppServer(config, options) {
         })
     }));
 
-
-    //self.logger = self.server.Logger;
-
-    //process.on('uncaughtException', uncaught_exception_handler.handle);
-    process.on('SIGHUP', function () {
-        process.exit();
-    });
+    process.on('SIGHUP', function () { process.exit(); });
 }
 
 AppServer.prototype.start = function (options) {
     options = options || {};
     var self = this;
-    var port = options.port;
-
-    //self.logger.debug("Started with ENV: " + ENV);
-
-    port = port || self.config.server.port;
+    var port = options.port || self.config.server.port;
 
     self.server.listen(parseInt(port, 10));
-    //self.logger.debug("Server Listening on Port: " + port);
 
     self.server.use(restify.bodyParser());
     self.server.use(restify.queryParser());

lib/server/index.js

@@ -1,6 +1,6 @@
 var server = {
-    app_registrar: require('./app_registrar'),
-    app_server: require('./app_server'),
+    AppRegistrar: require('./app_registrar'),
+    AppServer: require('./app_server'),
     responder: require('./responder'),
     router: require('./router')
 };

lib/server/responder.js

@@ -4,22 +4,6 @@ var util = require('util');
 var responder = {
     error: function (res, err, next) {
         next(err);
-        /*
-        options = options || {};
-
-        if (!res) {
-            var msg = "No res passed into responder.error()";
-            throw new Error(msg);
-        }
-
-        res.header('Content-Type', 'application/json; charset=utf-8');
-        res.charSet = "utf-8";
-        res.status(formatted_error.status_code);
-        delete formatted_error.status_code;
-        res.mog_response = formatted_error;
-        res.json(formatted_error);
-        next();
-        */
     },
 
     success: function (res, data, next) {

lib/server/router.js

@@ -3,24 +3,13 @@ var router = {
         if (!Array.isArray(routes)) { throw new Error('routes must be an array'); }
 
         routes.forEach(function (route) {
-            try {
-                //log.debug("Registering route: ", route);
-
-                if (!route.middleware) {
-                    route.middleware = [];
-                }
-
-                server[route.method](route.url, route.middleware, function (req, res, next) {
-                    if (req.middleware_error !== true) {
-                        route.func(req, res, next);
-                    } else if (next) {
-                        return next();
-                    }
-                });
-            } catch (e) {
-                console.log("Failed to load route: ", route, e);
-                //log.error("Failed to load route: ", route, e);
+            if (!route.middleware) {
+                route.middleware = [];
             }
+
+            server[route.method](route.url, route.middleware, function (req, res, next) {
+                route.func(req, res, next);
+            });
         });
     }
 };

test/run.js

@@ -9,8 +9,8 @@ var walk_dir = require('./support/walk_dir');
 
 var argv = optimist
     .usage("Usage: $0 -t [types] --reporter [reporter] --timeout [timeout]")
-    .default({types: 'unit,component', reporter: 'spec', timeout: 6000})
-    .describe('types', 'The types of tests to run, separated by commas. E.g., unit,component,acceptance')
+    .default({types: 'unit,functional', reporter: 'spec', timeout: 6000})
+    .describe('types', 'The types of tests to run, separated by commas. E.g., unit,functional,acceptance')
     .describe('reporter', 'The mocha test reporter to use.')
     .describe('timeout', 'The mocha timeout to use per test (ms).')
     .boolean('help')

test/server/app_registrar.unit.js

@@ -0,0 +1,64 @@
+var assert = require('assert');
+var restify = require('restify');
+var sinon = require('sinon');
+var support = require('../support');
+var path = require('path');
+var AppRegistrar = main.server.AppRegistrar;
+
+var settings_path = path.join(__dirname, '..', 'support', 'data', 'fake_app_settings.js');
+var empty_settings_path = path.join(__dirname, '..', 'support', 'data', 'empty_app_settings.js');
+
+describe("app_registrar.js", function () {
+    var server;
+
+    beforeEach(function () {
+        server = restify.createServer({
+            name: 'test'
+        });
+
+        server.listen(support.http.port);
+    });
+
+    afterEach(function (done) {
+        setTimeout(function () {
+            server.close();
+            done();
+        }, 10);
+    });
+
+    describe("instantiating", function () {
+        context("when server missing", function () {
+            it("throws an error", function () {
+                assert.throws(function () {
+                    var registrar = new AppRegistrar(null, 'users');
+                }, /AppRegistrar.*server/);
+            });
+        });
+
+        context("when app_name not found in apps path", function () {
+            it("throws an error", function () {
+                assert.throws(function () {
+                    var registrar = new AppRegistrar(server, 'foo');
+                }, /AppRegistrar.*app not found/);
+            });
+        });
+    });
+
+    describe("instance methods", function () {
+        var registrar;
+
+        describe("register()", function () {
+            context("when server and app_name are valid", function () {
+                it("does not throw error", function (done) {
+                    registrar = new AppRegistrar(server, 'users');
+                    registrar.register();
+
+                    setTimeout(function () {
+                        assert.ok(true);
+                        done();
+                    }, 10);
+                });
+            });
+        });
+    });
+});

test/server/app_server.unit.js

@@ -0,0 +1,86 @@
+var assert = require('assert');
+var sinon = require('sinon');
+var support = require('../support');
+var path = require('path');
+var Settings = require('settings');
+var config = new Settings(require('../../config'));
+var AppServer = main.server.AppServer;
+
+describe('app_server.js', function () {
+    describe("instantiating", function () {
+        context("when config is not passed in", function () {
+            it("throws an error", function () {
+                assert.throws(function () {
+                    var new_server = new AppServer(null);
+                }, /AppServer.*config/);
+            });
+        });
+    });
+
+    describe("start()", function () {
+        context("with no args", function () {
+            it("starts the server", function (done) {
+                var new_server = new AppServer(config);
+                new_server.start();
+                setTimeout(function () {
+                    assert.ok(new_server.server.server._handle);
+                    new_server.close();
+                    done();
+                }, 20);
+            });
+        });
+    });
+
+    describe("close()", function () {
+        context("when server has been started", function () {
+            it("closes the server", function (done) {
+                var new_server = new AppServer(config);
+
+                new_server.start();
+
+                setTimeout(function () {
+                    assert.ok(new_server.server.server._handle);
+
+                    new_server.close();
+                    setTimeout(function () {
+                        assert.strictEqual(new_server.server.server._handle, null);
+                        done();
+                    }, 10);
+                }, 30);
+            });
+        });
+
+        context("when server hasn't been started", function () {
+            it("doesn't blow up", function (done) {
+                var new_server = new AppServer(config);
+
+                setTimeout(function () {
+                    new_server.close();
+                    setTimeout(function () {
+                        done();
+                    }, 10);
+                }, 10);
+            });
+        });
+
+        context("when server has already been closed", function () {
+            it("doesn't blow up", function (done) {
+                var new_server = new AppServer(config);
+
+                new_server.start();
+
+                setTimeout(function () {
+                    new_server.close();
+
+                    setTimeout(function () {
+                        new_server.close();
+
+                        setTimeout(function () {
+                            done();
+                        }, 10);
+                    }, 10);
+                }, 10);
+            });
+        });
+    });
+});

test/server/responder.functional.js

@@ -0,0 +1,54 @@
+var assert = require('assert');
+var restify = require('restify');
+var sinon = require('sinon');
+var support = require('../support');
+var http = support.http;
+var responder = main.server.responder;
+
+var methods = {
+    get_restify_error: function (req, res, next) {
+        var error = new restify.InvalidArgumentError('foo arg invalid');
+        return responder.error(res, error, next);
+    }
+};
+
+var routes = [
+    {
+        method: "get",
+        url: "/test/errors/restify",
+        func: methods.get_restify_error,
+        middleware: []
+    }
+];
+
+describe("functional - server/responder.js", function () {
+    var server;
+    var http_client;
+
+    before(function () {
+        server = http.server.create(routes);
+        server.start();
+        http_client = http.client();
+    });
+
+    after(function () {
+        server.stop();
+    });
+
+    describe("error responses", function () {
+        describe("restify errors", function () {
+            it("returns correct response body", function (done) {
+                http_client.get('/test/errors/restify', function (err, result, raw_res) {
+                    var expected = {
+                        code: 'InvalidArgument',
+                        message: 'foo arg invalid'
+                    };
+
+                    assert.strictEqual(err.statusCode, 409);
+                    assert.deepEqual(result, expected);
+                    done();
+                });
+            });
+        });
+    });
+});