added some dependencies to package.json

3 files changed, 0 insertions, 689 deletions

diff --git a/node_modules/chai-http/lib/http.js b/node_modules/chai-http/lib/http.js
deleted file mode 100644
index 4651443..0000000
--- a/node_modules/chai-http/lib/http.js
+++ /dev/null
@@ -1,364 +0,0 @@
-/*!
- * chai-http
- * Copyright(c) 2011-2012 Jake Luer <jake@alogicalparadox.com>
- * MIT Licensed
- */
-
-/**
- * ## Assertions
- *
- * The Chai HTTP module provides a number of assertions
- * for the `expect` and `should` interfaces.
- */
-
-module.exports = function (chai, _) {
-
-  /*!
-   * Module dependencies.
-   */
-
-  var net = require('net');
-  var qs = require('qs');
-  var url = require('url');
-  var Cookie = require('cookiejar');
-
-  /*!
-   * Aliases.
-   */
-
-  var Assertion = chai.Assertion
-    , i = _.inspect;
-
-  /*!
-   * Expose request builder
-   */
-
-  chai.request = require('./request');
-
-  /*!
-   * Content types hash. Used to
-   * define `Assertion` properties.
-   *
-   * @type {Object}
-   */
-
-  var contentTypes = {
-      json: 'application/json'
-    , text: 'text/plain'
-    , html: 'text/html'
-  };
-
-  /*!
-   * Return a header from `Request` or `Response` object.
-   *
-   * @param {Request|Response} object
-   * @param {String} Header
-   * @returns {String|Undefined}
-   */
-
-  function getHeader(obj, key) {
-    if (key) key = key.toLowerCase();
-    if (obj.getHeader) return obj.getHeader(key);
-    if (obj.headers) return obj.headers[key];
-  };
-
-  /**
-   * ### .status (code)
-   *
-   * Assert that a response has a supplied status.
-   *
-   * ```js
-   * expect(res).to.have.status(200);
-   * ```
-   *
-   * @param {Number} status number
-   * @name status
-   * @api public
-   */
-
-  Assertion.addMethod('status', function (code) {
-    new Assertion(this._obj).to.have.property('status');
-    var status = this._obj.status;
-
-    this.assert(
-        status == code
-      , 'expected #{this} to have status code #{exp} but got #{act}'
-      , 'expected #{this} to not have status code #{act}'
-      , code
-      , status
-    );
-  });
-
-  /**
-   * ### .header (key[, value])
-   *
-   * Assert that a `Response` or `Request` object has a header.
-   * If a value is provided, equality to value will be asserted.
-   * You may also pass a regular expression to check.
-   *
-   * __Note:__ When running in a web browser, the
-   * [same-origin policy](https://tools.ietf.org/html/rfc6454#section-3)
-   * only allows Chai HTTP to read
-   * [certain headers](https://www.w3.org/TR/cors/#simple-response-header),
-   * which can cause assertions to fail.
-   *
-   * ```js
-   * expect(req).to.have.header('x-api-key');
-   * expect(req).to.have.header('content-type', 'text/plain');
-   * expect(req).to.have.header('content-type', /^text/);
-   * ```
-   *
-   * @param {String} header key (case insensitive)
-   * @param {String|RegExp} header value (optional)
-   * @name header
-   * @api public
-   */
-
-  Assertion.addMethod('header', function (key, value) {
-    var header = getHeader(this._obj, key);
-
-    if (arguments.length < 2) {
-      this.assert(
-          'undefined' !== typeof header || null === header
-        , 'expected header \'' + key + '\' to exist'
-        , 'expected header \'' + key + '\' to not exist'
-      );
-    } else if (arguments[1] instanceof RegExp) {
-      this.assert(
-          value.test(header)
-        , 'expected header \'' + key + '\' to match ' + value + ' but got ' + i(header)
-        , 'expected header \'' + key + '\' not to match ' + value + ' but got ' + i(header)
-        , value
-        , header
-      );
-    } else {
-      this.assert(
-          header == value
-        , 'expected header \'' + key + '\' to have value ' + value + ' but got ' + i(header)
-        , 'expected header \'' + key + '\' to not have value ' + value
-        , value
-        , header
-      );
-    }
-  });
-
-  /**
-   * ### .headers
-   *
-   * Assert that a `Response` or `Request` object has headers.
-   *
-   * __Note:__ When running in a web browser, the
-   * [same-origin policy](https://tools.ietf.org/html/rfc6454#section-3)
-   * only allows Chai HTTP to read
-   * [certain headers](https://www.w3.org/TR/cors/#simple-response-header),
-   * which can cause assertions to fail.
-   *
-   * ```js
-   * expect(req).to.have.headers;
-   * ```
-   *
-   * @name headers
-   * @api public
-   */
-
-  Assertion.addProperty('headers', function () {
-    this.assert(
-        this._obj.headers || this._obj.getHeader
-      , 'expected #{this} to have headers or getHeader method'
-      , 'expected #{this} to not have headers or getHeader method'
-    );
-  });
-
-  /**
-   * ### .ip
-   *
-   * Assert that a string represents valid ip address.
-   *
-   * ```js
-   * expect('127.0.0.1').to.be.an.ip;
-   * expect('2001:0db8:85a3:0000:0000:8a2e:0370:7334').to.be.an.ip;
-   * ```
-   *
-   * @name ip
-   * @api public
-   */
-
-  Assertion.addProperty('ip', function () {
-    this.assert(
-        net.isIP(this._obj)
-      , 'expected #{this} to be an ip'
-      , 'expected #{this} to not be an ip'
-    );
-  });
-
-  /**
-   * ### .json / .text / .html
-   *
-   * Assert that a `Response` or `Request` object has a given content-type.
-   *
-   * ```js
-   * expect(req).to.be.json;
-   * expect(req).to.be.html;
-   * expect(req).to.be.text;
-   * ```
-   *
-   * @name json
-   * @name html
-   * @name text
-   * @api public
-   */
-
-  function checkContentType (name) {
-    var val = contentTypes[name];
-
-    Assertion.addProperty(name, function () {
-      new Assertion(this._obj).to.have.headers;
-      var ct = getHeader(this._obj, 'content-type')
-        , ins = i(ct) === 'undefined'
-          ? 'headers'
-          : i(ct);
-
-      this.assert(
-          ct && ~ct.indexOf(val)
-        , 'expected ' + ins + ' to include \'' + val + '\''
-        , 'expected ' + ins + ' to not include \'' + val + '\''
-      );
-    });
-  }
-
-  Object
-    .keys(contentTypes)
-    .forEach(checkContentType);
-
-  /**
-   * ### .redirect
-   *
-   * Assert that a `Response` object has a redirect status code.
-   *
-   * ```js
-   * expect(res).to.redirect;
-   * ```
-   *
-   * @name redirect
-   * @api public
-   */
-
-  Assertion.addProperty('redirect', function() {
-    var redirectCodes = [301, 302, 303]
-      , status = this._obj.status
-      , redirects = this._obj.redirects;
-
-    this.assert(
-        redirectCodes.indexOf(status) >= 0 || redirects && redirects.length
-      , "expected redirect with 30{1-3} status code but got " + status
-      , "expected not to redirect but got " + status + " status"
-    );
-  });
-
-  /**
-   * ### .redirectTo
-   *
-   * Assert that a `Response` object redirects to the supplied location.
-   *
-   * ```js
-   * expect(res).to.redirectTo('http://example.com');
-   * ```
-   *
-   * @param {String} location url
-   * @name redirectTo
-   * @api public
-   */
-
-  Assertion.addMethod('redirectTo', function(destination) {
-    var redirects = this._obj.redirects;
-
-    new Assertion(this._obj).to.redirect;
-
-    if(redirects && redirects.length) {
-      this.assert(
-        redirects.indexOf(destination) > -1
-        , 'expected redirect to ' + destination + ' but got ' + redirects.join(' then ')
-        , 'expected not to redirect to ' + destination + ' but got ' + redirects.join(' then ')
-      );
-    } else {
-      var assertion = new Assertion(this._obj);
-      _.transferFlags(this, assertion);
-      assertion.with.header('location', destination);
-    }
-  });
-
-  /**
-   * ### .param
-   *
-   * Assert that a `Request` object has a query string parameter with a given
-   * key, (optionally) equal to value
-   *
-   * ```js
-   * expect(req).to.have.param('orderby');
-   * expect(req).to.have.param('orderby', 'date');
-   * expect(req).to.not.have.param('limit');
-   * ```
-   *
-   * @param {String} parameter name
-   * @param {String} parameter value
-   * @name param
-   * @api public
-   */
-
-  Assertion.addMethod('param', function(name, value) {
-    var assertion = new Assertion();
-    _.transferFlags(this, assertion);
-    assertion._obj = qs.parse(url.parse(this._obj.url).query);
-    assertion.property.apply(assertion, arguments);
-  });
-
-  /**
-   * ### .cookie
-   *
-   * Assert that a `Request` or `Response` object has a cookie header with a
-   * given key, (optionally) equal to value
-   *
-   * ```js
-   * expect(req).to.have.cookie('session_id');
-   * expect(req).to.have.cookie('session_id', '1234');
-   * expect(req).to.not.have.cookie('PHPSESSID');
-   * expect(res).to.have.cookie('session_id');
-   * expect(res).to.have.cookie('session_id', '1234');
-   * expect(res).to.not.have.cookie('PHPSESSID');
-   * ```
-   *
-   * @param {String} parameter name
-   * @param {String} parameter value
-   * @name param
-   * @api public
-   */
-
-  Assertion.addMethod('cookie', function (key, value) {
-    var header = getHeader(this._obj, 'set-cookie')
-      , cookie;
-
-    if (!header) {
-       header = (getHeader(this._obj, 'cookie') || '').split(';');
-    }
-
-    cookie = Cookie.CookieJar();
-    cookie.setCookies(header);
-    cookie = cookie.getCookie(key, new Cookie.CookieAccessInfo());
-
-    if (arguments.length === 2) {
-      this.assert(
-          cookie.value == value
-        , 'expected cookie \'' + key + '\' to have value #{exp} but got #{act}'
-        , 'expected cookie \'' + key + '\' to not have value #{exp}'
-        , value
-        , cookie.value
-      );
-    } else {
-      this.assert(
-          'undefined' !== typeof cookie || null === cookie
-        , 'expected cookie \'' + key + '\' to exist'
-        , 'expected cookie \'' + key + '\' to not exist'
-      );
-    }
-  });
-};
diff --git a/node_modules/chai-http/lib/net.js b/node_modules/chai-http/lib/net.js
deleted file mode 100644
index 12fbab8..0000000
--- a/node_modules/chai-http/lib/net.js
+++ /dev/null
@@ -1,14 +0,0 @@
-/*!
- * chai-http - request helper
- * Copyright(c) 2011-2012 Jake Luer <jake@alogicalparadox.com>
- * MIT Licensed
- */
-
-/*!
- * net.isIP shim for browsers
- */
-var isIP = require('is-ip');
-
-exports.isIP = isIP;
-exports.isIPv4 = isIP.v4;
-exports.isIPv6 = isIP.v6;
diff --git a/node_modules/chai-http/lib/request.js b/node_modules/chai-http/lib/request.js
deleted file mode 100644
index fa583de..0000000
--- a/node_modules/chai-http/lib/request.js
+++ /dev/null
@@ -1,311 +0,0 @@
-/*!
- * chai-http - request helper
- * Copyright(c) 2011-2012 Jake Luer <jake@alogicalparadox.com>
- * MIT Licensed
- */
-
-/*!
- * Module dependancies
- */
-
-var http = require('http')
-  , https = require('https')
-  , methods = require('methods')
-  , superagent = require('superagent')
-  , Agent = superagent.agent
-  , Request = superagent.Request
-  , util = require('util');
-
-/**
- * ## Integration Testing
- *
- * Chai HTTP provides an interface for live integration
- * testing via [superagent](https://github.com/visionmedia/superagent).
- * To do this, you must first
- * construct a request to an application or url.
- *
- * Upon construction you are provided a chainable api that
- * allows you to specify the http VERB request (get, post, etc)
- * that you wish to invoke.
- *
- * #### Application / Server
- *
- * You may use a function (such as an express or connect app)
- * or a node.js http(s) server as the foundation for your request.
- * If the server is not running, chai-http will find a suitable
- * port to listen on for a given test.
- *
- * __Note:__ This feature is only supported on Node.js, not in web browsers.
- *
- * ```js
- * chai.request(app)
- *   .get('/')
- * ```
- *
- * #### URL
- *
- * You may also use a base url as the foundation of your request.
- *
- * ```js
- * chai.request('http://localhost:8080')
- *   .get('/')
- * ```
- *
- * #### Setting up requests
- *
- * Once a request is created with a given VERB, it can have headers, form data,
- * json, or even file attachments added to it, all with a simple API:
- *
- * ```js
- * // Send some JSON
- * chai.request(app)
- *   .put('/user/me')
- *   .set('X-API-Key', 'foobar')
- *   .send({ password: '123', confirmPassword: '123' })
- * ```
- *
- * ```js
- * // Send some Form Data
- * chai.request(app)
- *   .post('/user/me')
- *   .field('_method', 'put')
- *   .field('password', '123')
- *   .field('confirmPassword', '123')
- * ```
- *
- * ```js
- * // Attach a file
- * chai.request(app)
- *   .post('/user/avatar')
- *   .attach('imageField', fs.readFileSync('avatar.png'), 'avatar.png')
- * ```
- *
- * ```js
- * // Authenticate with Basic authentication
- * chai.request(app)
- *   .get('/protected')
- *   .auth('user', 'pass')
- * ```
- *
- * ```js
- * // Chain some GET query parameters
- * chai.request(app)
- *   .get('/search')
- *   .query({name: 'foo', limit: 10}) // /search?name=foo&limit=10
- * ```
- *
- * #### Dealing with the response - traditional
- *
- * To make the request and assert on its response, the `end` method can be used:
- *
- * ```js
- * chai.request(app)
- *   .put('/user/me')
- *   .send({ password: '123', confirmPassword: '123' })
- *   .end(function (err, res) {
- *      expect(err).to.be.null;
- *      expect(res).to.have.status(200);
- *   });
- * ```
- * ##### Caveat
- * Because the `end` function is passed a callback, assertions are run
- * asynchronously. Therefore, a mechanism must be used to notify the testing
- * framework that the callback has completed. Otherwise, the test will pass before
- * the assertions are checked.
- *
- * For example, in the [Mocha test framework](http://mochajs.org/), this is
- * accomplished using the
- * [`done` callback](https://mochajs.org/#asynchronous-code), which signal that the
- * callback has completed, and the assertions can be verified:
- *
- * ```js
- * it('fails, as expected', function(done) { // <= Pass in done callback
- *   chai.request('http://localhost:8080')
- *   .get('/')
- *   .end(function(err, res) {
- *     expect(res).to.have.status(123);
- *     done();                               // <= Call done to signal callback end
- *   });
- * }) ;
- *
- * it('succeeds silently!', function() {   // <= No done callback
- *   chai.request('http://localhost:8080')
- *   .get('/')
- *   .end(function(err, res) {
- *     expect(res).to.have.status(123);    // <= Test completes before this runs
- *   });
- * }) ;
- * ```
- *
- * When `done` is passed in, Mocha will wait until the call to `done()`, or until
- * the [timeout](http://mochajs.org/#timeouts) expires. `done` also accepts an
- * error parameter when signaling completion.
- *
- * #### Dealing with the response - Promises
- *
- * If `Promise` is available, `request()` becomes a Promise capable library -
- * and chaining of `then`s becomes possible:
- *
- * ```js
- * chai.request(app)
- *   .put('/user/me')
- *   .send({ password: '123', confirmPassword: '123' })
- *   .then(function (res) {
- *      expect(res).to.have.status(200);
- *   })
- *   .catch(function (err) {
- *      throw err;
- *   })
- * ```
- *
- * __Note:__ Node.js version 0.10.x and some older web browsers do not have
- * native promise support. You can use any promise library, such as
- * [es6-promise](https://github.com/jakearchibald/es6-promise) or
- * [kriskowal/q](https://github.com/kriskowal/q) and call the `addPromise`
- * method to use that library with Chai HTTP. For example:
- *
- * ```js
- * var chai = require('chai');
- * chai.use(require('chai-http'));
- *
- * // Add promise support if this does not exist natively.
- * if (!global.Promise) {
- *   var q = require('q');
- *   chai.request.addPromises(q.Promise);
- * }
- * ```
- *
- * #### Retaining cookies with each request
- *
- * Sometimes you need to keep cookies from one request, and send them with the
- * next. For this, `.request.agent()` is available:
- *
- * ```js
- * // Log in
- * var agent = chai.request.agent(app)
- * agent
- *   .post('/session')
- *   .send({ username: 'me', password: '123' })
- *   .then(function (res) {
- *     expect(res).to.have.cookie('sessionid');
- *     // The `agent` now has the sessionid cookie saved, and will send it
- *     // back to the server in the next request:
- *     return agent.get('/user/me')
- *       .then(function (res) {
- *          expect(res).to.have.status(200);
- *       })
- *   })
- * ```
- *
- */
-
-module.exports = function (app) {
-
-  /*!
-   * @param {Mixed} function or server
-   * @returns {Object} API
-   */
-
-  var server = ('function' === typeof app)
-      ? http.createServer(app)
-      : app
-    , obj = {};
-
-  methods.forEach(function (method) {
-    obj[method] = function (path) {
-      return new Test(server, method, path);
-    };
-  });
-  obj.del = obj.delete;
-
-  return obj;
-};
-
-module.exports.Test = Test;
-module.exports.Request = Test;
-module.exports.agent = TestAgent;
-
-/*!
- * Test
- *
- * An extension of superagent.Request,
- * this provides the same chainable api
- * as superagent so all things can be modified.
- *
- * @param {Object|String} server, app, or url
- * @param {String} method
- * @param {String} path
- * @api private
- */
-
-function Test (app, method, path) {
-  Request.call(this, method, path);
-  this.app = app;
-  this.url = typeof app === 'string' ? app + path : serverAddress(app, path);
-}
-util.inherits(Test, Request);
-
-function serverAddress (app, path) {
-  if ('string' === typeof app) {
-    return app + path;
-  }
-  var addr = app.address();
-  if (!addr) {
-    app.listen(0);
-    addr = app.address();
-  }
-  var protocol = (app instanceof https.Server) ? 'https' : 'http';
-  // If address is "unroutable" IPv4/6 address, then set to localhost
-  if (addr.address === '0.0.0.0' || addr.address === '::') {
-    addr.address = '127.0.0.1';
-  }
-  return protocol + '://' + addr.address + ':' + addr.port + path;
-}
-
-
-/*!
- * agent
- *
- * Follows the same API as superagent.Request,
- * but allows persisting of cookies between requests.
- *
- * @param {Object|String} server, app, or url
- * @param {String} method
- * @param {String} path
- * @api private
- */
-
-function TestAgent(app) {
-  if (!(this instanceof TestAgent)) return new TestAgent(app);
-  if (typeof app === 'function') app = http.createServer(app);
-  (Agent || Request).call(this);
-  this.app = app;
-}
-util.inherits(TestAgent, Agent || Request);
-
-// override HTTP verb methods
-methods.forEach(function(method){
-  TestAgent.prototype[method] = function(url){
-    var req = new Test(this.app, method, url)
-      , self = this;
-
-    if (Agent) {
-      // When running in Node, cookies are managed via
-      // `Agent._saveCookies()` and `Agent._attachCookies()`.
-      req.on('response', function (res) { self._saveCookies(res); });
-      req.on('redirect', function (res) { self._saveCookies(res); });
-      req.on('redirect', function () { self._attachCookies(req); });
-      this._attachCookies(req);
-    }
-    else {
-      // When running in a web browser, cookies are managed via `Request.withCredentials()`.
-      // The browser will attach cookies based on same-origin policy.
-      // https://tools.ietf.org/html/rfc6454#section-3
-      req.withCredentials();
-    }
-
-    return req;
-  };
-});
-
-TestAgent.prototype.del = TestAgent.prototype.delete;