2252033241

Build # 2252033241

Build Type

github

Committed by GitHub

Commit Message

<a href="https://github.com/dotcore64/chai-superagent/commit/<a class=hub.com/dotcore64/chai-superagent/commit/6a8c7606ef6d8e7347283d8c772f143bff4a68db">6a8c7606e<a href="https://github.com/dotcore64/chai-superagent/commit/6a8c7606ef6d8e7347283d8c772f143bff4a68db">">Merge </a><a class="double-link" href="https://github.com/dotcore64/chai-superagent/commit/<a class="double-link" href="https://github.com/dotcore64/chai-superagent/commit/1084791324f0653abd65f06f893d944fb0765025">108479132</a>">108479132</a><a href="https://github.com/dotcore64/chai-superagent/commit/6a8c7606ef6d8e7347283d8c772f143bff4a68db"> into cc392164d">cc392164d</a>

Pull Request Pull Request #14: Add compatibility with browser environments

Run Details

56 of 58 branches covered (96.55%)

Branch coverage included in aggregate %.

21 of 21 new or added lines in 1 file covered. (100.0%)

475 of 485 relevant lines covered (97.94%)

8.36 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

97.79

/index.js

import { isIP } from 'is-ip'; // preferably use this only in browser environments
import qs from 'qs';
import Cookie from 'cookiejar';
import charset from 'charset';
import { Request, Response, agent } from 'superagent';

// This gets around the fact that in browser environments, the `Agent` constructor is not exported
function Agent() {}
// eslint-disable-next-line no-proto
Agent.prototype = agent().__proto__; // in node environments, it is enough to set const Agent = agent

/**
 * ## Assertions
 *
 * The Chai HTTP module provides a number of assertions
 * for the `expect` and `should` interfaces.
 */

export default ({ strict = true } = {}) => (chai, _) => {
  const { Assertion } = chai;
  const i = _.inspect;

  /*!
   * Content types hash. Used to
   * define `Assertion` properties.
   *
   * @type {Object}
   */

  const 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) {
    const normalized = key && key.toLowerCase();
    if (obj.getHeader) return obj.getHeader(normalized);
    if (obj.headers) return obj.headers[normalized];
    return undefined;
  }

  function assertRequest(obj) {
    if (strict) {
      new Assertion(obj).assert(
        obj instanceof Request,
        'expected #{act} to be an instance of Request',
        null,
        true,
        obj,
        false,
      );
    }
  }

  function assertResponse(obj) {
    if (strict) {
      new Assertion(obj).assert(
        obj instanceof Response,
        'expected #{act} to be an instance of Response',
        null,
        true,
        obj,
        false,
      );
    }
  }

  function assertResponseOrRequest(obj) {
    if (strict) {
      new Assertion(obj).assert(
        obj instanceof Response || obj instanceof Request,
        'expected #{act} to be an instance of Request or Response',
        null,
        true,
        obj,
        false,
      );
    }
  }

  function assertResponseOrRequestOrAgent(obj) {
    if (strict) {
      new Assertion(obj).assert(
        obj instanceof Response || obj instanceof Request || obj instanceof Agent,
        'expected #{act} to be an instance of Request or Response or Agent',
        null,
        true,
        obj,
        false,
      );
    }
  }

  /**
   * ### .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) { // eslint-disable-line func-names
    assertResponse(this._obj);

    const hasStatus = Boolean('status' in this._obj || 'statusCode' in this._obj);
    new Assertion(hasStatus).assert(
      hasStatus,
      "expected #{act} to have keys 'status', or 'statusCode'",
      null, // never negated
      hasStatus, // expected
      this._obj, // actual
      false, // no diff
    );

    const status = this._obj.status || this._obj.statusCode;

    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) { // eslint-disable-line func-names
    assertResponseOrRequest(this._obj);

    const header = getHeader(this._obj, key);

    if (arguments.length < 2) {
      this.assert(
        typeof header !== 'undefined' || header === null,
        `expected header '${key}' to exist`,
        `expected header '${key}' to not exist`,
      );
    } else if (value 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 () { // eslint-disable-line func-names
    assertResponseOrRequest(this._obj);

    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 () { // eslint-disable-line func-names
    this.assert(
      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) {
    const val = contentTypes[name];

    Assertion.addProperty(name, function () { // eslint-disable-line func-names
      assertResponseOrRequest(this._obj);

      new Assertion(this._obj).to.have.headers; // eslint-disable-line no-unused-expressions
      const ct = getHeader(this._obj, 'content-type');
      const ins = i(ct) === 'undefined'
        ? 'headers'
        : i(ct);

      this.assert(
        ct && ~ct.indexOf(val), // eslint-disable-line no-bitwise
        `expected ${ins} to include '${val}'`,
        `expected ${ins} to not include '${val}'`,
      );
    });
  }

  Object
    .keys(contentTypes)
    .forEach(checkContentType);

  /**
   * ### .charset
   *
   * Assert that a `Response` or `Request` object has a given charset.
   *
   * ```js
   * expect(req).to.have.charset('utf-8');
   * ```
   *
   * @name charset
   * @api public
   */

  Assertion.addMethod('charset', function (value) { // eslint-disable-line func-names
    assertResponseOrRequest(this._obj);

    const normalized = value.toLowerCase();

    const { headers } = this._obj;
    let cs = charset(headers);

    /*
     * Fix charset() treating "utf8" as a special case
     * See https://github.com/node-modules/charset/issues/12
     */
    if (cs === 'utf8') {
      cs = 'utf-8';
    }

    this.assert(
      cs != null && normalized === cs,
      `expected content type to have ${normalized} charset`,
      `expected content type to not have ${normalized} charset`,
    );
  });

  /**
   * ### .redirect
   *
   * Assert that a `Response` object has a redirect status code.
   *
   * ```js
   * expect(res).to.redirect;
   * ```
   *
   * @name redirect
   * @api public
   */

  Assertion.addProperty('redirect', function () { // eslint-disable-line func-names
    assertResponse(this._obj);

    const redirectCodes = [301, 302, 303, 307, 308];
    const { status } = this._obj;
    const { redirects } = this._obj;

    this.assert(
      redirectCodes.indexOf(status) >= 0 || (redirects && redirects.length),
      `expected redirect with 30X 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|RegExp} location url
   * @name redirectTo
   * @api public
   */

  Assertion.addMethod('redirectTo', function (destination) { // eslint-disable-line func-names
    assertResponse(this._obj);

    const { redirects } = this._obj;

    new Assertion(this._obj).to.redirect; // eslint-disable-line no-unused-expressions

    if (redirects && redirects.length) {
      let hasRedirected;

      if (Object.prototype.toString.call(destination) === '[object RegExp]') {
        hasRedirected = redirects.some((redirect) => destination.test(redirect));
      } else {
        hasRedirected = redirects.indexOf(destination) > -1;
      }
      this.assert(
        hasRedirected,
        `expected redirect to ${destination} but got ${redirects.join(' then ')}`,
        `expected not to redirect to ${destination} but got ${redirects.join(' then ')}`,
      );
    } else {
      const 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 (...args) { // eslint-disable-line func-names
    assertRequest(this._obj);

    const assertion = new Assertion();
    _.transferFlags(this, assertion);
    assertion._obj = qs.parse(new URL(this._obj.url, 'https://dummy.com').search.replace(/^\?/, ''));
    assertion.property(...args);
  });

  /**
   * ### .cookie
   *
   * Assert that a `Request`, `Response` or `Agent` 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');
   * expect(agent).to.have.cookie('session_id');
   * expect(agent).to.have.cookie('session_id', '1234');
   * expect(agent).to.not.have.cookie('PHPSESSID');
   * ```
   *
   * @param {String} parameter name
   * @param {String} parameter value
   * @name param
   * @api public
   */

  Assertion.addMethod('cookie', function (key, value) { // eslint-disable-line func-names
    assertResponseOrRequestOrAgent(this._obj);

    if (this._obj instanceof Agent && this._obj.jar === undefined) {
      new Assertion(this._obj).assert(
        !(this._obj instanceof Agent && this._obj.jar === undefined),
        'In browsers cookies are managed automatically by the browser, so the .agent() does not isolate cookies.',
        null,
        true,
        this._obj,
        false,
      );
    }

    const header = getHeader(this._obj, 'set-cookie') || (getHeader(this._obj, 'cookie') || '').split(';');

    let cookie;

    if (this._obj.jar) {
      cookie = this._obj.jar.getCookie(key, Cookie.CookieAccessInfo.All);
    } else {
      cookie = Cookie.CookieJar();
      cookie.setCookies(header);
      cookie = cookie.getCookie(key, Cookie.CookieAccessInfo.All);
    }

    if (value !== undefined) {
      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(
        typeof cookie !== 'undefined' || cookie === null,
        `expected cookie '${key}' to exist`,
        `expected cookie '${key}' to not exist`,
      );
    }
  });
};

1	import { isIP } from 'is-ip'; // preferably use this only in browser environments	1✔
2	import qs from 'qs';	1✔
3	import Cookie from 'cookiejar';	1✔
4	import charset from 'charset';	1✔
5	import { Request, Response, agent } from 'superagent';	1✔
6		1✔
7	// This gets around the fact that in browser environments, the `Agent` constructor is not exported	1✔
8	function Agent() {}	×
9	// eslint-disable-next-line no-proto	1✔
10	Agent.prototype = agent().__proto__; // in node environments, it is enough to set const Agent = agent	1✔
11		1✔
12	/**	1✔
13	* ## Assertions	1✔
14	*	1✔
15	* The Chai HTTP module provides a number of assertions	1✔
16	* for the `expect` and `should` interfaces.	1✔
17	*/	1✔
18		1✔
19	export default ({ strict = true } = {}) => (chai, _) => {	1✔
20	const { Assertion } = chai;	2✔
21	const i = _.inspect;	2✔
22		2✔
23	/*!	2✔
24	* Content types hash. Used to	2✔
25	* define `Assertion` properties.	2✔
26	*	2✔
27	* @type {Object}	2✔
28	*/	2✔
29		2✔
30	const contentTypes = {	2✔
31	json: 'application/json',	2✔
32	text: 'text/plain',	2✔
33	html: 'text/html',	2✔
34	};	2✔
35		2✔
36	/*!	2✔
37	* Return a header from `Request` or `Response` object.	2✔
38	*	2✔
39	* @param {Request\|Response} object	2✔
40	* @param {String} Header	2✔
41	* @returns {String\|Undefined}	2✔
42	*/	2✔
43		2✔
44	function getHeader(obj, key) {	2✔
45	const normalized = key && key.toLowerCase();	90✔
46	if (obj.getHeader) return obj.getHeader(normalized);	90✔
47	if (obj.headers) return obj.headers[normalized];	90✔
48	return undefined;	24✔
49	}	90✔
50		2✔
51	function assertRequest(obj) {	2✔
52	if (strict) {	21✔
53	new Assertion(obj).assert(	1✔
54	obj instanceof Request,	1✔
55	'expected #{act} to be an instance of Request',	1✔
56	null,	1✔
57	true,	1✔
58	obj,	1✔
59	false,	1✔
60	);	1✔
61	}	1✔
62	}	21✔
63		2✔
64	function assertResponse(obj) {	2✔
65	if (strict) {	45✔
66	new Assertion(obj).assert(	8✔
67	obj instanceof Response,	8✔
68	'expected #{act} to be an instance of Response',	8✔
69	null,	8✔
70	true,	8✔
71	obj,	8✔
72	false,	8✔
73	);	8✔
74	}	8✔
75	}	45✔
76		2✔
77	function assertResponseOrRequest(obj) {	2✔
78	if (strict) {	78✔
79	new Assertion(obj).assert(	23✔
80	obj instanceof Response \|\| obj instanceof Request,	23✔
81	'expected #{act} to be an instance of Request or Response',	23✔
82	null,	23✔
83	true,	23✔
84	obj,	23✔
85	false,	23✔
86	);	23✔
87	}	23✔
88	}	78✔
89		2✔
90	function assertResponseOrRequestOrAgent(obj) {	2✔
91	if (strict) {	36✔
92	new Assertion(obj).assert(	2✔
93	obj instanceof Response \|\| obj instanceof Request \|\| obj instanceof Agent,	2✔
94	'expected #{act} to be an instance of Request or Response or Agent',	2✔
95	null,	2✔
96	true,	2✔
97	obj,	2✔
98	false,	2✔
99	);	2✔
100	}	2✔
101	}	36✔
102		2✔
103	/**	2✔
104	* ### .status (code)	2✔
105	*	2✔
106	* Assert that a response has a supplied status.	2✔
107	*	2✔
108	* ```js	2✔
109	* expect(res).to.have.status(200);	2✔
110	* ```	2✔
111	*	2✔
112	* @param {Number} status number	2✔
113	* @name status	2✔
114	* @api public	2✔
115	*/	2✔
116		2✔
117	Assertion.addMethod('status', function (code) { // eslint-disable-line func-names	2✔
118	assertResponse(this._obj);	11✔
119		11✔
120	const hasStatus = Boolean('status' in this._obj \|\| 'statusCode' in this._obj);	11✔
121	new Assertion(hasStatus).assert(	11✔
122	hasStatus,	11✔
123	"expected #{act} to have keys 'status', or 'statusCode'",	11✔
124	null, // never negated	11✔
125	hasStatus, // expected	11✔
126	this._obj, // actual	11✔
127	false, // no diff	11✔
128	);	11✔
129		11✔
130	const status = this._obj.status \|\| this._obj.statusCode;	11✔
131		11✔
132	this.assert(	11✔
133	status === code,	11✔
134	'expected #{this} to have status code #{exp} but got #{act}',	11✔
135	'expected #{this} to not have status code #{act}',	11✔
136	code,	11✔
137	status,	11✔
138	);	11✔
139	});	2✔
140		2✔
141	/**	2✔
142	* ### .header (key[, value])	2✔
143	*	2✔
144	* Assert that a `Response` or `Request` object has a header.	2✔
145	* If a value is provided, equality to value will be asserted.	2✔
146	* You may also pass a regular expression to check.	2✔
147	*	2✔
148	* __Note:__ When running in a web browser, the	2✔
149	* [same-origin policy](https://tools.ietf.org/html/rfc6454#section-3)	2✔
150	* only allows Chai HTTP to read	2✔
151	* [certain headers](https://www.w3.org/TR/cors/#simple-response-header),	2✔
152	* which can cause assertions to fail.	2✔
153	*	2✔
154	* ```js	2✔
155	* expect(req).to.have.header('x-api-key');	2✔
156	* expect(req).to.have.header('content-type', 'text/plain');	2✔
157	* expect(req).to.have.header('content-type', /^text/);	2✔
158	* ```	2✔
159	*	2✔
160	* @param {String} header key (case insensitive)	2✔
161	* @param {String\|RegExp} header value (optional)	2✔
162	* @name header	2✔
163	* @api public	2✔
164	*/	2✔
165		2✔
166	Assertion.addMethod('header', function (key, value) { // eslint-disable-line func-names	2✔
167	assertResponseOrRequest(this._obj);	26✔
168		26✔
169	const header = getHeader(this._obj, key);	26✔
170		26✔
171	if (arguments.length < 2) {	26✔
172	this.assert(	8✔
173	typeof header !== 'undefined' \|\| header === null,	8✔
174	`expected header '${key}' to exist`,	8✔
175	`expected header '${key}' to not exist`,	8✔
176	);	8✔
177	} else if (value instanceof RegExp) {	26✔
178	this.assert(	4✔
179	value.test(header),	4✔
180	`expected header '${key}' to match ${value} but got ${i(header)}`,	4✔
181	`expected header '${key}' not to match ${value} but got ${i(header)}`,	4✔
182	value,	4✔
183	header,	4✔
184	);	4✔
185	} else {	17✔
186	this.assert(	13✔
187	header === value,	13✔
188	`expected header '${key}' to have value ${value} but got ${i(header)}`,	13✔
189	`expected header '${key}' to not have value ${value}`,	13✔
190	value,	13✔
191	header,	13✔
192	);	13✔
193	}	13✔
194	});	2✔
195		2✔
196	/**	2✔
197	* ### .headers	2✔
198	*	2✔
199	* Assert that a `Response` or `Request` object has headers.	2✔
200	*	2✔
201	* __Note:__ When running in a web browser, the	2✔
202	* [same-origin policy](https://tools.ietf.org/html/rfc6454#section-3)	2✔
203	* only allows Chai HTTP to read	2✔
204	* [certain headers](https://www.w3.org/TR/cors/#simple-response-header),	2✔
205	* which can cause assertions to fail.	2✔
206	*	2✔
207	* ```js	2✔
208	* expect(req).to.have.headers;	2✔
209	* ```	2✔
210	*	2✔
211	* @name headers	2✔
212	* @api public	2✔
213	*/	2✔
214		2✔
215	Assertion.addProperty('headers', function () { // eslint-disable-line func-names	2✔
216	assertResponseOrRequest(this._obj);	23✔
217		23✔
218	this.assert(	23✔
219	this._obj.headers \|\| this._obj.getHeader,	23✔
220	'expected #{this} to have headers or getHeader method',	23✔
221	'expected #{this} to not have headers or getHeader method',	23✔
222	);	23✔
223	});	2✔
224		2✔
225	/**	2✔
226	* ### .ip	2✔
227	*	2✔
228	* Assert that a string represents valid ip address.	2✔
229	*	2✔
230	* ```js	2✔
231	* expect('127.0.0.1').to.be.an.ip;	2✔
232	* expect('2001:0db8:85a3:0000:0000:8a2e:0370:7334').to.be.an.ip;	2✔
233	* ```	2✔
234	*	2✔
235	* @name ip	2✔
236	* @api public	2✔
237	*/	2✔
238		2✔
239	Assertion.addProperty('ip', function () { // eslint-disable-line func-names	2✔
240	this.assert(	4✔
241	isIP(this._obj),	4✔
242	'expected #{this} to be an ip',	4✔
243	'expected #{this} to not be an ip',	4✔
244	);	4✔
245	});	2✔
246		2✔
247	/**	2✔
248	* ### .json / .text / .html	2✔
249	*	2✔
250	* Assert that a `Response` or `Request` object has a given content-type.	2✔
251	*	2✔
252	* ```js	2✔
253	* expect(req).to.be.json;	2✔
254	* expect(req).to.be.html;	2✔
255	* expect(req).to.be.text;	2✔
256	* ```	2✔
257	*	2✔
258	* @name json	2✔
259	* @name html	2✔
260	* @name text	2✔
261	* @api public	2✔
262	*/	2✔
263		2✔
264	function checkContentType(name) {	2✔
265	const val = contentTypes[name];	6✔
266		6✔
267	Assertion.addProperty(name, function () { // eslint-disable-line func-names	6✔
268	assertResponseOrRequest(this._obj);	22✔
269		22✔
270	new Assertion(this._obj).to.have.headers; // eslint-disable-line no-unused-expressions	22✔
271	const ct = getHeader(this._obj, 'content-type');	22✔
272	const ins = i(ct) === 'undefined'	22✔
273	? 'headers'	22!
274	: i(ct);	22✔
275		22✔
276	this.assert(	22✔
277	ct && ~ct.indexOf(val), // eslint-disable-line no-bitwise	22✔
278	`expected ${ins} to include '${val}'`,	22✔
279	`expected ${ins} to not include '${val}'`,	22✔
280	);	22✔
281	});	6✔
282	}	6✔
283		2✔
284	Object	2✔
285	.keys(contentTypes)	2✔
286	.forEach(checkContentType);	2✔
287		2✔
288	/**	2✔
289	* ### .charset	2✔
290	*	2✔
291	* Assert that a `Response` or `Request` object has a given charset.	2✔
292	*	2✔
293	* ```js	2✔
294	* expect(req).to.have.charset('utf-8');	2✔
295	* ```	2✔
296	*	2✔
297	* @name charset	2✔
298	* @api public	2✔
299	*/	2✔
300		2✔
301	Assertion.addMethod('charset', function (value) { // eslint-disable-line func-names	2✔
302	assertResponseOrRequest(this._obj);	7✔
303		7✔
304	const normalized = value.toLowerCase();	7✔
305		7✔
306	const { headers } = this._obj;	7✔
307	let cs = charset(headers);	7✔
308		7✔
309	/*	7✔
310	* Fix charset() treating "utf8" as a special case	7✔
311	* See https://github.com/node-modules/charset/issues/12	7✔
312	*/	7✔
313	if (cs === 'utf8') {	7✔
314	cs = 'utf-8';	2✔
315	}	2✔
316		6✔
317	this.assert(	6✔
318	cs != null && normalized === cs,	7✔
319	`expected content type to have ${normalized} charset`,	7✔
320	`expected content type to not have ${normalized} charset`,	7✔
321	);	7✔
322	});	2✔
323		2✔
324	/**	2✔
325	* ### .redirect	2✔
326	*	2✔
327	* Assert that a `Response` object has a redirect status code.	2✔
328	*	2✔
329	* ```js	2✔
330	* expect(res).to.redirect;	2✔
331	* ```	2✔
332	*	2✔
333	* @name redirect	2✔
334	* @api public	2✔
335	*/	2✔
336		2✔
337	Assertion.addProperty('redirect', function () { // eslint-disable-line func-names	2✔
338	assertResponse(this._obj);	22✔
339		22✔
340	const redirectCodes = [301, 302, 303, 307, 308];	22✔
341	const { status } = this._obj;	22✔
342	const { redirects } = this._obj;	22✔
343		22✔
344	this.assert(	22✔
345	redirectCodes.indexOf(status) >= 0 \|\| (redirects && redirects.length),	22✔
346	`expected redirect with 30X status code but got ${status}`,	22✔
347	`expected not to redirect but got ${status} status`,	22✔
348	);	22✔
349	});	2✔
350		2✔
351	/**	2✔
352	* ### .redirectTo	2✔
353	*	2✔
354	* Assert that a `Response` object redirects to the supplied location.	2✔
355	*	2✔
356	* ```js	2✔
357	* expect(res).to.redirectTo('http://example.com');	2✔
358	* ```	2✔
359	*	2✔
360	* @param {String\|RegExp} location url	2✔
361	* @name redirectTo	2✔
362	* @api public	2✔
363	*/	2✔
364		2✔
365	Assertion.addMethod('redirectTo', function (destination) { // eslint-disable-line func-names	2✔
366	assertResponse(this._obj);	12✔
367		12✔
368	const { redirects } = this._obj;	12✔
369		12✔
370	new Assertion(this._obj).to.redirect; // eslint-disable-line no-unused-expressions	12✔
371		12✔
372	if (redirects && redirects.length) {	12✔
373	let hasRedirected;	6✔
374		6✔
375	if (Object.prototype.toString.call(destination) === '[object RegExp]') {	6✔
376	hasRedirected = redirects.some((redirect) => destination.test(redirect));	3✔
377	} else {	3✔
378	hasRedirected = redirects.indexOf(destination) > -1;	3✔
379	}	3✔
380	this.assert(	6✔
381	hasRedirected,	6✔
382	`expected redirect to ${destination} but got ${redirects.join(' then ')}`,	6✔
383	`expected not to redirect to ${destination} but got ${redirects.join(' then ')}`,	6✔
384	);	6✔
385	} else {	12✔
386	const assertion = new Assertion(this._obj);	5✔
387	_.transferFlags(this, assertion);	5✔
388	assertion.with.header('location', destination);	5✔
389	}	5✔
390	});	2✔
391		2✔
392	/**	2✔
393	* ### .param	2✔
394	*	2✔
395	* Assert that a `Request` object has a query string parameter with a given	2✔
396	* key, (optionally) equal to value	2✔
397	*	2✔
398	* ```js	2✔
399	* expect(req).to.have.param('orderby');	2✔
400	* expect(req).to.have.param('orderby', 'date');	2✔
401	* expect(req).to.not.have.param('limit');	2✔
402	* ```	2✔
403	*	2✔
404	* @param {String} parameter name	2✔
405	* @param {String} parameter value	2✔
406	* @name param	2✔
407	* @api public	2✔
408	*/	2✔
409		2✔
410	Assertion.addMethod('param', function (...args) { // eslint-disable-line func-names	2✔
411	assertRequest(this._obj);	21✔
412		21✔
413	const assertion = new Assertion();	21✔
414	_.transferFlags(this, assertion);	21✔
415	assertion._obj = qs.parse(new URL(this._obj.url, 'https://dummy.com').search.replace(/^\?/, ''));	21✔
416	assertion.property(...args);	21✔
417	});	2✔
418		2✔
419	/**	2✔
420	* ### .cookie	2✔
421	*	2✔
422	* Assert that a `Request`, `Response` or `Agent` object has a cookie header with a	2✔
423	* given key, (optionally) equal to value	2✔
424	*	2✔
425	* ```js	2✔
426	* expect(req).to.have.cookie('session_id');	2✔
427	* expect(req).to.have.cookie('session_id', '1234');	2✔
428	* expect(req).to.not.have.cookie('PHPSESSID');	2✔
429	* expect(res).to.have.cookie('session_id');	2✔
430	* expect(res).to.have.cookie('session_id', '1234');	2✔
431	* expect(res).to.not.have.cookie('PHPSESSID');	2✔
432	* expect(agent).to.have.cookie('session_id');	2✔
433	* expect(agent).to.have.cookie('session_id', '1234');	2✔
434	* expect(agent).to.not.have.cookie('PHPSESSID');	2✔
435	* ```	2✔
436	*	2✔
437	* @param {String} parameter name	2✔
438	* @param {String} parameter value	2✔
439	* @name param	2✔
440	* @api public	2✔
441	*/	2✔
442		2✔
443	Assertion.addMethod('cookie', function (key, value) { // eslint-disable-line func-names	2✔
444	assertResponseOrRequestOrAgent(this._obj);	36✔
445		36✔
446	if (this._obj instanceof Agent && this._obj.jar === undefined) {	36!
447	new Assertion(this._obj).assert(	×
448	!(this._obj instanceof Agent && this._obj.jar === undefined),	×
449	'In browsers cookies are managed automatically by the browser, so the .agent() does not isolate cookies.',	×
450	null,	×
451	true,	×
452	this._obj,	×
453	false,	×
454	);	×
455	}	×
456		34✔
457	const header = getHeader(this._obj, 'set-cookie') \|\| (getHeader(this._obj, 'cookie') \|\| '').split(';');	36✔
458		36✔
459	let cookie;	36✔
460		36✔
461	if (this._obj.jar) {	36✔
462	cookie = this._obj.jar.getCookie(key, Cookie.CookieAccessInfo.All);	12✔
463	} else {	36✔
464	cookie = Cookie.CookieJar();	22✔
465	cookie.setCookies(header);	22✔
466	cookie = cookie.getCookie(key, Cookie.CookieAccessInfo.All);	22✔
467	}	22✔
468		34✔
469	if (value !== undefined) {	36✔
470	this.assert(	17✔
471	cookie.value === value,	17✔
472	`expected cookie '${key}' to have value #{exp} but got #{act}`,	17✔
473	`expected cookie '${key}' to not have value #{exp}`,	17✔
474	value,	17✔
475	cookie.value,	17✔
476	);	17✔
477	} else {	17✔
478	this.assert(	17✔
479	typeof cookie !== 'undefined' \|\| cookie === null,	17✔
480	`expected cookie '${key}' to exist`,	17✔
481	`expected cookie '${key}' to not exist`,	17✔
482	);	17✔
483	}	17✔
484	});	2✔
485	};	1✔

dotcore64 / chai-superagent / 2252033241

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous