2252005866

Build # 2252005866

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/f46dca2a7296a5ed6c47712763776e9f3d70bb62">f46dca2a7<a href="https://github.com/dotcore64/chai-superagent/commit/f46dca2a7296a5ed6c47712763776e9f3d70bb62">">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/ef0dcfdfcb07b0b5ce256bbfca8af8b16e6f5ce2">ef0dcfdfc</a>">ef0dcfdfc</a><a href="https://github.com/dotcore64/chai-superagent/commit/f46dca2a7296a5ed6c47712763776e9f3d70bb62"> into cc392164d">cc392164d</a>

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

Run Details

172 of 180 branches covered (95.56%)

Branch coverage included in aggregate %.

120 of 120 new or added lines in 5 files covered. (100.0%)

1148 of 1164 relevant lines covered (98.63%)

4.08 hits per line

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

98.61

/test/assertions.js

import { expect, use } from 'chai';
import { agent as Agent } from 'superagent';

// eslint-disable-next-line import/no-unresolved,node/no-missing-import
import superagent from 'chai-superagent';

use(superagent({ strict: false }));

describe('assertions', () => {
  it('#status property "status"', () => {
    const res = { status: 200 };
    expect(res).to.have.status(200);

    expect(() => {
      expect(res).to.not.have.status(200);
    }).to.throw('expected { status: 200 } to not have status code 200');

    expect(() => {
      expect({}).to.not.to.have.status(200);
    }).to.throw("expected {} to have keys 'status', or 'statusCode'");
  });

  it('#status property "statusCode"', () => {
    expect({ statusCode: 200 }).to.have.status(200);
  });

  it('#status property "status" should work with inheritance', () => {
    class TestError {}
    TestError.prototype.status = 404;
    const testError = new TestError();
    expect(testError).to.have.status(404);
  });

  it('#ip', () => {
    expect('127.0.0.1').to.be.an.ip; // eslint-disable-line no-unused-expressions
    expect('2001:0db8:85a3:0000:0000:8a2e:0370:7334').to.be.an.ip; // eslint-disable-line no-unused-expressions

    expect(() => {
      expect('127.0.0.1').to.not.be.an.ip; // eslint-disable-line no-unused-expressions
    }).to.throw('expected \'127.0.0.1\' to not be an ip');

    expect(() => {
      expect('2001:0db8:85a3:0000:0000:8a2e:0370:7334').to.not.be.an.ip; // eslint-disable-line no-unused-expressions
    }).to.throw('expected \'2001:0db8:85a3:0000:0000:8a2e:0370:73…\' to not be an ip');
  });

  it('#header test existence', () => {
    const req = { headers: { foo: 'bar' } };
    const res = {
      getHeader(key) {
        return key === 'foo' ? 'bar' : undefined;
      },
    };

    expect(req).to.have.header('foo');
    expect(req).to.not.have.header('bar');

    expect(res).to.have.header('foo');
    expect(res).to.not.have.header('bar');

    expect(() => {
      expect(req).to.have.header('bar');
    }).to.throw('expected header \'bar\' to exist');

    expect(() => {
      expect(res).to.have.header('bar');
    }).to.throw('expected header \'bar\' to exist');
  });

  it('#header test value', () => {
    const req = { headers: { foo: 'bar' } };
    const res = {
      getHeader() {
        return 'foo';
      },
    };

    expect(req).to.have.header('foo', 'bar');
    expect(res).to.have.header('bar', 'foo');
    expect(res).to.have.header('bar', /^fo/);

    expect(() => {
      expect(req).to.not.have.header('foo', 'bar');
    }).to.throw('expected header \'foo\' to not have value bar');

    expect(() => {
      expect(res).to.not.have.header('bar', 'foo');
    }).to.throw('expected header \'bar\' to not have value foo');

    expect(() => {
      expect(res).to.not.have.header('bar', /^fo/);
    }).to.throw('expected header \'bar\' not to match /^fo/ but got \'foo\'');
  });

  it('#header case insensitive', () => {
    const req = { headers: { foo: 'bar' } };
    const res = {
      getHeader() {
        return 'foo';
      },
    };

    expect(res).to.have.header('Foo');
    expect(res).to.have.header('Bar');
    expect(req).to.have.header('FoO', 'bar');
    expect(res).to.have.header('BAr', 'foo');
  });

  it('#headers', () => {
    const req = { headers: { foo: 'bar' } };
    const res = {
      getHeader() {
        return 'foo';
      },
    };

    expect(req).to.have.headers; // eslint-disable-line no-unused-expressions
    expect(res).to.have.headers; // eslint-disable-line no-unused-expressions

    expect(() => {
      expect(req).to.not.have.headers; // eslint-disable-line no-unused-expressions
    }).to.throw('expected { headers: { foo: \'bar\' } } to not have headers or getHeader method');

    expect(() => {
      expect(res).to.not.have.headers; // eslint-disable-line no-unused-expressions
    }).to.throw(/expected .*getHeader.* to not have headers or getHeader method/);
  });

  it('#json', () => {
    const req = { headers: { 'content-type': ['application/json'] } };
    const res = {
      getHeader() {
        return 'application/json';
      },
    };

    expect(req).to.be.json; // eslint-disable-line no-unused-expressions
    expect(res).to.be.json; // eslint-disable-line no-unused-expressions

    expect(() => {
      expect(req).to.not.be.json; // eslint-disable-line no-unused-expressions
    }).to.throw('expected [ \'application/json\' ] to not include \'application/json\'');

    expect(() => {
      expect(res).to.not.be.json; // eslint-disable-line no-unused-expressions
    }).to.throw('expected \'application/json\' to not include \'application/json\'');
  });

  it('#text', () => {
    const req = { headers: { 'content-type': ['text/plain'] } };
    const res = {
      getHeader() {
        return 'text/plain';
      },
    };

    expect(req).to.be.text; // eslint-disable-line no-unused-expressions
    expect(res).to.be.text; // eslint-disable-line no-unused-expressions

    expect(() => {
      expect(req).to.not.be.text; // eslint-disable-line no-unused-expressions
    }).to.throw('expected [ \'text/plain\' ] to not include \'text/plain\'');

    expect(() => {
      expect(res).to.not.be.text; // eslint-disable-line no-unused-expressions
    }).to.throw('expected \'text/plain\' to not include \'text/plain\'');
  });

  it('#html', () => {
    const req = { headers: { 'content-type': ['text/html'] } };
    const res = {
      getHeader() {
        return 'text/html';
      },
    };

    expect(req).to.be.html; // eslint-disable-line no-unused-expressions
    expect(res).to.be.html; // eslint-disable-line no-unused-expressions

    expect(() => {
      expect(req).to.not.be.html; // eslint-disable-line no-unused-expressions
    }).to.throw('expected [ \'text/html\' ] to not include \'text/html\'');

    expect(() => {
      expect(res).to.not.be.html; // eslint-disable-line no-unused-expressions
    }).to.throw('expected \'text/html\' to not include \'text/html\'');
  });

  it('#redirect', () => {
    expect({ status: 200 }).to.not.redirect; // eslint-disable-line no-unused-expressions

    [301, 302, 303, 307, 308].forEach((status) => {
      expect({ status }).to.redirect; // eslint-disable-line no-unused-expressions
    });

    expect({ // eslint-disable-line no-unused-expressions
      status: 200,
      redirects: ['http://example.com'],
    }).to.redirect;

    expect({ // eslint-disable-line no-unused-expressions
      status: 200,
      redirects: [],
    }).to.not.redirect;

    expect(() => {
      expect({ status: 200 }).to.redirect; // eslint-disable-line no-unused-expressions
    }).to.throw('expected redirect with 30X status code but got 200');

    expect(() => {
      expect({ status: 301 }).to.not.redirect; // eslint-disable-line no-unused-expressions
    }).to.throw('expected not to redirect but got 301 status');
  });

  it('#redirectTo', () => {
    expect({ status: 301, headers: { location: 'foo' } }).to.redirectTo('foo');
    expect({ status: 301, headers: { location: 'bar' } }).to.not.redirectTo('foo');
    expect({ status: 200, redirects: ['bar'] }).to.redirectTo('bar');
    expect({ status: 200, redirects: ['bar'] }).to.not.redirectTo('foo');
    expect({ status: 200, redirects: ['foo'] }).to.redirectTo(/foo/);
    expect({ status: 200, redirects: ['foo/bar?baz=qux'] }).to.redirectTo(/^foo\/bar/);

    expect(() => {
      expect({ status: 301, headers: { location: 'foo' } }).to.not.redirectTo('foo');
    }).to.throw('expected header \'location\' to not have value foo');

    expect(() => {
      expect({ status: 301, headers: { location: 'bar' } }).to.redirectTo('foo');
    }).to.throw('expected header \'location\' to have value foo');

    expect(() => {
      expect({ status: 200, redirects: ['bar', 'baz'] }).to.redirectTo('foo');
    }).to.throw('expected redirect to foo but got bar then baz');

    expect(() => {
      expect({ status: 301, headers: { location: 'foo' } }).to.not.redirectTo(/foo/);
    }).to.throw('expected header \'location\' not to match /foo/ but got \'foo\'');

    expect(() => {
      expect({ status: 200, redirects: ['bar', 'baz'] }).to.redirectTo(/foo/);
    }).to.throw('expected redirect to /foo/ but got bar then baz');
  });

  it('#param', () => {
    const req = { url: '/test?x=y&foo=bar' };
    expect(req).to.have.param('x');
    expect(req).to.have.param('foo');
    expect(req).to.have.param('x', 'y');
    expect(req).to.have.param('foo', 'bar');
    expect(req).to.not.have.param('bar');
    expect(req).to.not.have.param('y');
    expect(req).to.not.have.param('x', 'z');
    expect(req).to.not.have.param('foo', 'baz');

    expect(() => {
      expect(req).to.not.have.param('foo');
    }).to.throw(/expected .* to not have property 'foo'/);

    expect(() => {
      expect(req).to.not.have.param('foo', 'bar');
    }).to.throw(/expected .* to not have property 'foo' of 'bar'/);
  });

  it('#param (nested)', () => {
    const req = { url: '/test?form[name]=jim&form[lastName]=bob' };
    expect(req).to.have.param('form');
    expect(req).to.have.nested.param('form.name');
    expect(req).to.have.nested.param('form.name', 'jim');
    expect(req).to.have.nested.param('form.lastName');
    expect(req).to.have.nested.param('form.lastName', 'bob');
    expect(req).to.not.have.param('bar');
    expect(req).to.not.have.nested.param('form.bar');
    expect(req).to.not.have.nested.param('form.name', 'sue');

    expect(() => {
      expect(req).to.not.have.nested.param('form.name');
    }).to.throw(/expected .* to not have nested property 'form.name'/);

    expect(() => {
      expect(req).to.not.have.nested.param('form.lastName', 'bob');
    }).to.throw(/expected .* to not have nested property 'form.lastName' of 'bob'/);
  });

  it('#cookie', () => {
    const res = {
      headers: {
        'set-cookie': [
          'name=value',
          'name2=value2; Expires=Wed, 09 Jun 2024 10:18:14 GMT',
        ],
      },
    };
    expect(res).to.have.cookie('name');
    expect(res).to.have.cookie('name2');
    expect(res).to.have.cookie('name', 'value');
    expect(res).to.have.cookie('name2', 'value2');
    expect(res).to.not.have.cookie('bar');
    expect(res).to.not.have.cookie('name2', 'bar');

    expect(() => {
      expect(res).to.not.have.cookie('name');
    }).to.throw('expected cookie \'name\' to not exist');

    expect(() => {
      expect(res).to.have.cookie('foo');
    }).to.throw('expected cookie \'foo\' to exist');

    expect(() => {
      expect(res).to.not.have.cookie('name', 'value');
    }).to.throw('expected cookie \'name\' to not have value \'value\'');

    expect(() => {
      expect(res).to.have.cookie('name2', 'value');
    }).to.throw('expected cookie \'name2\' to have value \'value\' but got \'value2\'');
  });

  it('#cookie (request)', () => {
    const req = {
      headers: {
        'set-cookie': [
          'name=value;',
          'name2=value2; Expires=Wed, 09 Jun 2024 10:18:14 GMT',
          'name3=value3; Domain=.somedomain.com',
        ],
      },
    };
    expect(req).to.have.cookie('name');
    expect(req).to.have.cookie('name2');
    expect(req).to.have.cookie('name3');
    expect(req).to.have.cookie('name', 'value');
    expect(req).to.have.cookie('name2', 'value2');
    expect(req).to.have.cookie('name3', 'value3');
    expect(req).to.not.have.cookie('bar');
    expect(req).to.not.have.cookie('name2', 'bar');

    expect(() => {
      expect(req).to.not.have.cookie('name');
    }).to.throw('expected cookie \'name\' to not exist');

    expect(() => {
      expect(req).to.have.cookie('foo');
    }).to.throw('expected cookie \'foo\' to exist');

    expect(() => {
      expect(req).to.not.have.cookie('name', 'value');
    }).to.throw('expected cookie \'name\' to not have value \'value\'');

    expect(() => {
      expect(req).to.have.cookie('name2', 'value');
    }).to.throw('expected cookie \'name2\' to have value \'value\' but got \'value2\'');
  });

  it('#cookie (agent)', () => {
    const agent = Agent();

    const cookies = [
      'name=value',
      'name2=value2; Expires=Wed, 09 Jun 2024 10:18:14 GMT',
      'name3=value3; Domain=.somedomain.com',
    ];

    if (!agent.jar) { // in the browser
      expect(() => {
        expect(agent).to.have.cookie('name');
      }).to.throw('In browsers cookies are managed automatically by the browser, so the .agent() does not isolate cookies.');
      return;
    }

    // node
    agent.jar.setCookies(cookies);

    expect(agent).to.have.cookie('name');
    expect(agent).to.have.cookie('name2');
    expect(agent).to.have.cookie('name3');
    expect(agent).to.have.cookie('name', 'value');
    expect(agent).to.have.cookie('name2', 'value2');
    expect(agent).to.have.cookie('name3', 'value3');
    expect(agent).to.not.have.cookie('bar');
    expect(agent).to.not.have.cookie('name2', 'bar');

    expect(() => {
      expect(agent).to.not.have.cookie('name');
    }).to.throw('expected cookie \'name\' to not exist');

    expect(() => {
      expect(agent).to.have.cookie('foo');
    }).to.throw('expected cookie \'foo\' to exist');

    expect(() => {
      expect(agent).to.not.have.cookie('name', 'value');
    }).to.throw('expected cookie \'name\' to not have value \'value\'');

    expect(() => {
      expect(agent).to.have.cookie('name2', 'value');
    }).to.throw('expected cookie \'name2\' to have value \'value\' but got \'value2\'');
  });

  describe('#charset', () => {
    it('should match charset in content type', () => {
      const req = { headers: { 'content-type': ['text/plain; charset=utf-8'] } };
      expect(req).to.have.charset('utf-8');

      expect(() => {
        expect(req).to.not.have.charset('utf-8');
      }).to.throw('expected content type to not have utf-8 charset');
    });

    it('should handle no content type', () => {
      const req = { headers: {} };
      expect(req).to.not.have.charset('utf-8');

      expect(() => {
        expect(req).to.have.charset('utf-8');
      }).to.throw('expected content type to have utf-8 charset');
    });

    it('should handle no charset in content type', () => {
      const req = { headers: { 'content-type': ['text/plain'] } };
      expect(req).to.not.have.charset('utf-8');

      expect(() => {
        expect(req).to.to.have.charset('utf-8');
      }).to.throw('expected content type to have utf-8 charset');
    });
  });
});

1	import { expect, use } from 'chai';	1✔
2	import { agent as Agent } from 'superagent';	1✔
3		1✔
4	// eslint-disable-next-line import/no-unresolved,node/no-missing-import	1✔
5	import superagent from 'chai-superagent';	1✔
6		1✔
7	use(superagent({ strict: false }));	1✔
8		1✔
9	describe('assertions', () => {	1✔
10	it('#status property "status"', () => {	1✔
11	const res = { status: 200 };	1✔
12	expect(res).to.have.status(200);	1✔
13		1✔
14	expect(() => {	1✔
15	expect(res).to.not.have.status(200);	1✔
16	}).to.throw('expected { status: 200 } to not have status code 200');	1✔
17		1✔
18	expect(() => {	1✔
19	expect({}).to.not.to.have.status(200);	1✔
20	}).to.throw("expected {} to have keys 'status', or 'statusCode'");	1✔
21	});	1✔
22		1✔
23	it('#status property "statusCode"', () => {	1✔
24	expect({ statusCode: 200 }).to.have.status(200);	1✔
25	});	1✔
26		1✔
27	it('#status property "status" should work with inheritance', () => {	1✔
28	class TestError {}	1✔
29	TestError.prototype.status = 404;	1✔
30	const testError = new TestError();	1✔
31	expect(testError).to.have.status(404);	1✔
32	});	1✔
33		1✔
34	it('#ip', () => {	1✔
35	expect('127.0.0.1').to.be.an.ip; // eslint-disable-line no-unused-expressions	1✔
36	expect('2001:0db8:85a3:0000:0000:8a2e:0370:7334').to.be.an.ip; // eslint-disable-line no-unused-expressions	1✔
37		1✔
38	expect(() => {	1✔
39	expect('127.0.0.1').to.not.be.an.ip; // eslint-disable-line no-unused-expressions	1✔
40	}).to.throw('expected \'127.0.0.1\' to not be an ip');	1✔
41		1✔
42	expect(() => {	1✔
43	expect('2001:0db8:85a3:0000:0000:8a2e:0370:7334').to.not.be.an.ip; // eslint-disable-line no-unused-expressions	1✔
44	}).to.throw('expected \'2001:0db8:85a3:0000:0000:8a2e:0370:73…\' to not be an ip');	1✔
45	});	1✔
46		1✔
47	it('#header test existence', () => {	1✔
48	const req = { headers: { foo: 'bar' } };	1✔
49	const res = {	1✔
50	getHeader(key) {	1✔
51	return key === 'foo' ? 'bar' : undefined;	3✔
52	},	1✔
53	};	1✔
54		1✔
55	expect(req).to.have.header('foo');	1✔
56	expect(req).to.not.have.header('bar');	1✔
57		1✔
58	expect(res).to.have.header('foo');	1✔
59	expect(res).to.not.have.header('bar');	1✔
60		1✔
61	expect(() => {	1✔
62	expect(req).to.have.header('bar');	1✔
63	}).to.throw('expected header \'bar\' to exist');	1✔
64		1✔
65	expect(() => {	1✔
66	expect(res).to.have.header('bar');	1✔
67	}).to.throw('expected header \'bar\' to exist');	1✔
68	});	1✔
69		1✔
70	it('#header test value', () => {	1✔
71	const req = { headers: { foo: 'bar' } };	1✔
72	const res = {	1✔
73	getHeader() {	1✔
74	return 'foo';	4✔
75	},	1✔
76	};	1✔
77		1✔
78	expect(req).to.have.header('foo', 'bar');	1✔
79	expect(res).to.have.header('bar', 'foo');	1✔
80	expect(res).to.have.header('bar', /^fo/);	1✔
81		1✔
82	expect(() => {	1✔
83	expect(req).to.not.have.header('foo', 'bar');	1✔
84	}).to.throw('expected header \'foo\' to not have value bar');	1✔
85		1✔
86	expect(() => {	1✔
87	expect(res).to.not.have.header('bar', 'foo');	1✔
88	}).to.throw('expected header \'bar\' to not have value foo');	1✔
89		1✔
90	expect(() => {	1✔
91	expect(res).to.not.have.header('bar', /^fo/);	1✔
92	}).to.throw('expected header \'bar\' not to match /^fo/ but got \'foo\'');	1✔
93	});	1✔
94		1✔
95	it('#header case insensitive', () => {	1✔
96	const req = { headers: { foo: 'bar' } };	1✔
97	const res = {	1✔
98	getHeader() {	1✔
99	return 'foo';	3✔
100	},	1✔
101	};	1✔
102		1✔
103	expect(res).to.have.header('Foo');	1✔
104	expect(res).to.have.header('Bar');	1✔
105	expect(req).to.have.header('FoO', 'bar');	1✔
106	expect(res).to.have.header('BAr', 'foo');	1✔
107	});	1✔
108		1✔
109	it('#headers', () => {	1✔
110	const req = { headers: { foo: 'bar' } };	1✔
111	const res = {	1✔
112	getHeader() {	1✔
113	return 'foo';	×
114	},	1✔
115	};	1✔
116		1✔
117	expect(req).to.have.headers; // eslint-disable-line no-unused-expressions	1✔
118	expect(res).to.have.headers; // eslint-disable-line no-unused-expressions	1✔
119		1✔
120	expect(() => {	1✔
121	expect(req).to.not.have.headers; // eslint-disable-line no-unused-expressions	1✔
122	}).to.throw('expected { headers: { foo: \'bar\' } } to not have headers or getHeader method');	1✔
123		1✔
124	expect(() => {	1✔
125	expect(res).to.not.have.headers; // eslint-disable-line no-unused-expressions	1✔
126	}).to.throw(/expected .getHeader. to not have headers or getHeader method/);	1✔
127	});	1✔
128		1✔
129	it('#json', () => {	1✔
130	const req = { headers: { 'content-type': ['application/json'] } };	1✔
131	const res = {	1✔
132	getHeader() {	1✔
133	return 'application/json';	2✔
134	},	1✔
135	};	1✔
136		1✔
137	expect(req).to.be.json; // eslint-disable-line no-unused-expressions	1✔
138	expect(res).to.be.json; // eslint-disable-line no-unused-expressions	1✔
139		1✔
140	expect(() => {	1✔
141	expect(req).to.not.be.json; // eslint-disable-line no-unused-expressions	1✔
142	}).to.throw('expected [ \'application/json\' ] to not include \'application/json\'');	1✔
143		1✔
144	expect(() => {	1✔
145	expect(res).to.not.be.json; // eslint-disable-line no-unused-expressions	1✔
146	}).to.throw('expected \'application/json\' to not include \'application/json\'');	1✔
147	});	1✔
148		1✔
149	it('#text', () => {	1✔
150	const req = { headers: { 'content-type': ['text/plain'] } };	1✔
151	const res = {	1✔
152	getHeader() {	1✔
153	return 'text/plain';	2✔
154	},	1✔
155	};	1✔
156		1✔
157	expect(req).to.be.text; // eslint-disable-line no-unused-expressions	1✔
158	expect(res).to.be.text; // eslint-disable-line no-unused-expressions	1✔
159		1✔
160	expect(() => {	1✔
161	expect(req).to.not.be.text; // eslint-disable-line no-unused-expressions	1✔
162	}).to.throw('expected [ \'text/plain\' ] to not include \'text/plain\'');	1✔
163		1✔
164	expect(() => {	1✔
165	expect(res).to.not.be.text; // eslint-disable-line no-unused-expressions	1✔
166	}).to.throw('expected \'text/plain\' to not include \'text/plain\'');	1✔
167	});	1✔
168		1✔
169	it('#html', () => {	1✔
170	const req = { headers: { 'content-type': ['text/html'] } };	1✔
171	const res = {	1✔
172	getHeader() {	1✔
173	return 'text/html';	2✔
174	},	1✔
175	};	1✔
176		1✔
177	expect(req).to.be.html; // eslint-disable-line no-unused-expressions	1✔
178	expect(res).to.be.html; // eslint-disable-line no-unused-expressions	1✔
179		1✔
180	expect(() => {	1✔
181	expect(req).to.not.be.html; // eslint-disable-line no-unused-expressions	1✔
182	}).to.throw('expected [ \'text/html\' ] to not include \'text/html\'');	1✔
183		1✔
184	expect(() => {	1✔
185	expect(res).to.not.be.html; // eslint-disable-line no-unused-expressions	1✔
186	}).to.throw('expected \'text/html\' to not include \'text/html\'');	1✔
187	});	1✔
188		1✔
189	it('#redirect', () => {	1✔
190	expect({ status: 200 }).to.not.redirect; // eslint-disable-line no-unused-expressions	1✔
191		1✔
192	[301, 302, 303, 307, 308].forEach((status) => {	1✔
193	expect({ status }).to.redirect; // eslint-disable-line no-unused-expressions	5✔
194	});	1✔
195		1✔
196	expect({ // eslint-disable-line no-unused-expressions	1✔
197	status: 200,	1✔
198	redirects: ['http://example.com'],	1✔
199	}).to.redirect;	1✔
200		1✔
201	expect({ // eslint-disable-line no-unused-expressions	1✔
202	status: 200,	1✔
203	redirects: [],	1✔
204	}).to.not.redirect;	1✔
205		1✔
206	expect(() => {	1✔
207	expect({ status: 200 }).to.redirect; // eslint-disable-line no-unused-expressions	1✔
208	}).to.throw('expected redirect with 30X status code but got 200');	1✔
209		1✔
210	expect(() => {	1✔
211	expect({ status: 301 }).to.not.redirect; // eslint-disable-line no-unused-expressions	1✔
212	}).to.throw('expected not to redirect but got 301 status');	1✔
213	});	1✔
214		1✔
215	it('#redirectTo', () => {	1✔
216	expect({ status: 301, headers: { location: 'foo' } }).to.redirectTo('foo');	1✔
217	expect({ status: 301, headers: { location: 'bar' } }).to.not.redirectTo('foo');	1✔
218	expect({ status: 200, redirects: ['bar'] }).to.redirectTo('bar');	1✔
219	expect({ status: 200, redirects: ['bar'] }).to.not.redirectTo('foo');	1✔
220	expect({ status: 200, redirects: ['foo'] }).to.redirectTo(/foo/);	1✔
221	expect({ status: 200, redirects: ['foo/bar?baz=qux'] }).to.redirectTo(/^foo\/bar/);	1✔
222		1✔
223	expect(() => {	1✔
224	expect({ status: 301, headers: { location: 'foo' } }).to.not.redirectTo('foo');	1✔
225	}).to.throw('expected header \'location\' to not have value foo');	1✔
226		1✔
227	expect(() => {	1✔
228	expect({ status: 301, headers: { location: 'bar' } }).to.redirectTo('foo');	1✔
229	}).to.throw('expected header \'location\' to have value foo');	1✔
230		1✔
231	expect(() => {	1✔
232	expect({ status: 200, redirects: ['bar', 'baz'] }).to.redirectTo('foo');	1✔
233	}).to.throw('expected redirect to foo but got bar then baz');	1✔
234		1✔
235	expect(() => {	1✔
236	expect({ status: 301, headers: { location: 'foo' } }).to.not.redirectTo(/foo/);	1✔
237	}).to.throw('expected header \'location\' not to match /foo/ but got \'foo\'');	1✔
238		1✔
239	expect(() => {	1✔
240	expect({ status: 200, redirects: ['bar', 'baz'] }).to.redirectTo(/foo/);	1✔
241	}).to.throw('expected redirect to /foo/ but got bar then baz');	1✔
242	});	1✔
243		1✔
244	it('#param', () => {	1✔
245	const req = { url: '/test?x=y&foo=bar' };	1✔
246	expect(req).to.have.param('x');	1✔
247	expect(req).to.have.param('foo');	1✔
248	expect(req).to.have.param('x', 'y');	1✔
249	expect(req).to.have.param('foo', 'bar');	1✔
250	expect(req).to.not.have.param('bar');	1✔
251	expect(req).to.not.have.param('y');	1✔
252	expect(req).to.not.have.param('x', 'z');	1✔
253	expect(req).to.not.have.param('foo', 'baz');	1✔
254		1✔
255	expect(() => {	1✔
256	expect(req).to.not.have.param('foo');	1✔
257	}).to.throw(/expected .* to not have property 'foo'/);	1✔
258		1✔
259	expect(() => {	1✔
260	expect(req).to.not.have.param('foo', 'bar');	1✔
261	}).to.throw(/expected .* to not have property 'foo' of 'bar'/);	1✔
262	});	1✔
263		1✔
264	it('#param (nested)', () => {	1✔
265	const req = { url: '/test?form[name]=jim&form[lastName]=bob' };	1✔
266	expect(req).to.have.param('form');	1✔
267	expect(req).to.have.nested.param('form.name');	1✔
268	expect(req).to.have.nested.param('form.name', 'jim');	1✔
269	expect(req).to.have.nested.param('form.lastName');	1✔
270	expect(req).to.have.nested.param('form.lastName', 'bob');	1✔
271	expect(req).to.not.have.param('bar');	1✔
272	expect(req).to.not.have.nested.param('form.bar');	1✔
273	expect(req).to.not.have.nested.param('form.name', 'sue');	1✔
274		1✔
275	expect(() => {	1✔
276	expect(req).to.not.have.nested.param('form.name');	1✔
277	}).to.throw(/expected .* to not have nested property 'form.name'/);	1✔
278		1✔
279	expect(() => {	1✔
280	expect(req).to.not.have.nested.param('form.lastName', 'bob');	1✔
281	}).to.throw(/expected .* to not have nested property 'form.lastName' of 'bob'/);	1✔
282	});	1✔
283		1✔
284	it('#cookie', () => {	1✔
285	const res = {	1✔
286	headers: {	1✔
287	'set-cookie': [	1✔
288	'name=value',	1✔
289	'name2=value2; Expires=Wed, 09 Jun 2024 10:18:14 GMT',	1✔
290	],	1✔
291	},	1✔
292	};	1✔
293	expect(res).to.have.cookie('name');	1✔
294	expect(res).to.have.cookie('name2');	1✔
295	expect(res).to.have.cookie('name', 'value');	1✔
296	expect(res).to.have.cookie('name2', 'value2');	1✔
297	expect(res).to.not.have.cookie('bar');	1✔
298	expect(res).to.not.have.cookie('name2', 'bar');	1✔
299		1✔
300	expect(() => {	1✔
301	expect(res).to.not.have.cookie('name');	1✔
302	}).to.throw('expected cookie \'name\' to not exist');	1✔
303		1✔
304	expect(() => {	1✔
305	expect(res).to.have.cookie('foo');	1✔
306	}).to.throw('expected cookie \'foo\' to exist');	1✔
307		1✔
308	expect(() => {	1✔
309	expect(res).to.not.have.cookie('name', 'value');	1✔
310	}).to.throw('expected cookie \'name\' to not have value \'value\'');	1✔
311		1✔
312	expect(() => {	1✔
313	expect(res).to.have.cookie('name2', 'value');	1✔
314	}).to.throw('expected cookie \'name2\' to have value \'value\' but got \'value2\'');	1✔
315	});	1✔
316		1✔
317	it('#cookie (request)', () => {	1✔
318	const req = {	1✔
319	headers: {	1✔
320	'set-cookie': [	1✔
321	'name=value;',	1✔
322	'name2=value2; Expires=Wed, 09 Jun 2024 10:18:14 GMT',	1✔
323	'name3=value3; Domain=.somedomain.com',	1✔
324	],	1✔
325	},	1✔
326	};	1✔
327	expect(req).to.have.cookie('name');	1✔
328	expect(req).to.have.cookie('name2');	1✔
329	expect(req).to.have.cookie('name3');	1✔
330	expect(req).to.have.cookie('name', 'value');	1✔
331	expect(req).to.have.cookie('name2', 'value2');	1✔
332	expect(req).to.have.cookie('name3', 'value3');	1✔
333	expect(req).to.not.have.cookie('bar');	1✔
334	expect(req).to.not.have.cookie('name2', 'bar');	1✔
335		1✔
336	expect(() => {	1✔
337	expect(req).to.not.have.cookie('name');	1✔
338	}).to.throw('expected cookie \'name\' to not exist');	1✔
339		1✔
340	expect(() => {	1✔
341	expect(req).to.have.cookie('foo');	1✔
342	}).to.throw('expected cookie \'foo\' to exist');	1✔
343		1✔
344	expect(() => {	1✔
345	expect(req).to.not.have.cookie('name', 'value');	1✔
346	}).to.throw('expected cookie \'name\' to not have value \'value\'');	1✔
347		1✔
348	expect(() => {	1✔
349	expect(req).to.have.cookie('name2', 'value');	1✔
350	}).to.throw('expected cookie \'name2\' to have value \'value\' but got \'value2\'');	1✔
351	});	1✔
352		1✔
353	it('#cookie (agent)', () => {	1✔
354	const agent = Agent();	1✔
355		1✔
356	const cookies = [	1✔
357	'name=value',	1✔
358	'name2=value2; Expires=Wed, 09 Jun 2024 10:18:14 GMT',	1✔
359	'name3=value3; Domain=.somedomain.com',	1✔
360	];	1✔
361		1✔
362	if (!agent.jar) { // in the browser	1!
363	expect(() => {	×
364	expect(agent).to.have.cookie('name');	×
365	}).to.throw('In browsers cookies are managed automatically by the browser, so the .agent() does not isolate cookies.');	×
366	return;	×
367	}	×
368		1✔
369	// node	1✔
370	agent.jar.setCookies(cookies);	1✔
371		1✔
372	expect(agent).to.have.cookie('name');	1✔
373	expect(agent).to.have.cookie('name2');	1✔
374	expect(agent).to.have.cookie('name3');	1✔
375	expect(agent).to.have.cookie('name', 'value');	1✔
376	expect(agent).to.have.cookie('name2', 'value2');	1✔
377	expect(agent).to.have.cookie('name3', 'value3');	1✔
378	expect(agent).to.not.have.cookie('bar');	1✔
379	expect(agent).to.not.have.cookie('name2', 'bar');	1✔
380		1✔
381	expect(() => {	1✔
382	expect(agent).to.not.have.cookie('name');	1✔
383	}).to.throw('expected cookie \'name\' to not exist');	1✔
384		1✔
385	expect(() => {	1✔
386	expect(agent).to.have.cookie('foo');	1✔
387	}).to.throw('expected cookie \'foo\' to exist');	1✔
388		1✔
389	expect(() => {	1✔
390	expect(agent).to.not.have.cookie('name', 'value');	1✔
391	}).to.throw('expected cookie \'name\' to not have value \'value\'');	1✔
392		1✔
393	expect(() => {	1✔
394	expect(agent).to.have.cookie('name2', 'value');	1✔
395	}).to.throw('expected cookie \'name2\' to have value \'value\' but got \'value2\'');	1✔
396	});	1✔
397		1✔
398	describe('#charset', () => {	1✔
399	it('should match charset in content type', () => {	1✔
400	const req = { headers: { 'content-type': ['text/plain; charset=utf-8'] } };	1✔
401	expect(req).to.have.charset('utf-8');	1✔
402		1✔
403	expect(() => {	1✔
404	expect(req).to.not.have.charset('utf-8');	1✔
405	}).to.throw('expected content type to not have utf-8 charset');	1✔
406	});	1✔
407		1✔
408	it('should handle no content type', () => {	1✔
409	const req = { headers: {} };	1✔
410	expect(req).to.not.have.charset('utf-8');	1✔
411		1✔
412	expect(() => {	1✔
413	expect(req).to.have.charset('utf-8');	1✔
414	}).to.throw('expected content type to have utf-8 charset');	1✔
415	});	1✔
416		1✔
417	it('should handle no charset in content type', () => {	1✔
418	const req = { headers: { 'content-type': ['text/plain'] } };	1✔
419	expect(req).to.not.have.charset('utf-8');	1✔
420		1✔
421	expect(() => {	1✔
422	expect(req).to.to.have.charset('utf-8');	1✔
423	}).to.throw('expected content type to have utf-8 charset');	1✔
424	});	1✔
425	});	1✔
426	});	1✔

dotcore64 / chai-superagent / 2252005866

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