2252283331

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/0a9ef888818a2f6b9961c462214f3eefeaee4a55">0a9ef8888<a href="https://github.com/dotcore64/chai-superagent/commit/0a9ef888818a2f6b9961c462214f3eefeaee4a55">">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/22aecc7e6ebe9b07ac5dbfe2ee724749197e151a">22aecc7e6</a>">22aecc7e6</a><a href="https://github.com/dotcore64/chai-superagent/commit/0a9ef888818a2f6b9961c462214f3eefeaee4a55"> 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 %.

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

477 of 487 relevant lines covered (97.95%)

8.33 hits per line

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

97.8

/index.js

import qs from 'qs';
import Cookie from 'cookiejar';
import charset from 'charset';
import { Request, Response, agent } from 'superagent';

// eslint-disable-next-line import/no-unresolved,node/no-missing-import
import { isIP } from '#is-ip'; // this is 'net' in node, 'is-ip' in browsers

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

dotcore64 / chai-superagent / 2252283331

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