From f016bdbc35b7efa44bd63413bde09433ea916c59 Mon Sep 17 00:00:00 2001 From: HumairAK Date: Tue, 26 Jul 2016 03:43:04 -0400 Subject: added some unit testing, need a lot more --- node_modules/chai-http/lib/http.js | 364 +++++++++++++++++++++++++++++++++++++ 1 file changed, 364 insertions(+) create mode 100644 node_modules/chai-http/lib/http.js (limited to 'node_modules/chai-http/lib/http.js') diff --git a/node_modules/chai-http/lib/http.js b/node_modules/chai-http/lib/http.js new file mode 100644 index 0000000..4651443 --- /dev/null +++ b/node_modules/chai-http/lib/http.js @@ -0,0 +1,364 @@ +/*! + * chai-http + * Copyright(c) 2011-2012 Jake Luer + * 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' + ); + } + }); +}; -- cgit v1.2.3