blockworks-foundation
/
node-fetch
mirror of https://github.com/blockworks-foundation/node-fetch.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
node-fetch/test/test.js

1446 lines
40 KiB
JavaScript
Raw Normal View History

basic http added
2015-01-26 02:15:07 -08:00
// test tools
var chai = require('chai');
var cap = require('chai-as-promised');
chai.use(cap);
var expect = chai.expect;
var bluebird = require('bluebird');
var then = require('promise');
Test for clearing timeout
2015-04-16 11:46:22 -07:00
var spawn = require('child_process').spawn;
basic streaming body
2015-01-26 05:58:52 -08:00
var stream = require('stream');
more tests
2015-01-27 07:33:06 -08:00
var resumer = require('resumer');
Automatically pull headers from node-form-data.
2015-07-21 19:05:06 -07:00
var FormData = require('form-data');
clone method support
2016-03-19 03:06:33 -07:00
var http = require('http');
avoid calling formdata getLengthSync when it has stream as fields
2016-05-25 10:37:36 -07:00
var fs = require('fs');
more tests
2015-01-27 07:33:06 -08:00
basic streaming body
2015-01-26 05:58:52 -08:00
var TestServer = require('./server');
basic http added
2015-01-26 02:15:07 -08:00
// test subjects
var fetch = require('../index.js');
basic refactor done
2015-01-27 05:11:26 -08:00
var Headers = require('../lib/headers.js');
var Response = require('../lib/response.js');
add basic test case for request
2015-06-03 21:12:27 -07:00
var Request = require('../lib/request.js');
fix coverage and remove duplicate tests
2016-03-19 00:11:16 -07:00
var Body = require('../lib/body.js');
Support for program checkable error by introducing custom errors with error types/codes This finally closes #7
2016-04-05 06:20:42 -07:00
var FetchError = require('../lib/fetch-error.js');
basic http added
2015-01-26 02:15:07 -08:00
// test with native promise on node 0.11, and bluebird for node 0.10
fetch.Promise = fetch.Promise || bluebird;
basic streaming body
2015-01-26 05:58:52 -08:00
var url, opts, local, base;
basic http added
2015-01-26 02:15:07 -08:00
more tests
2015-01-27 07:33:06 -08:00
describe('node-fetch', function() {
basic http added
2015-01-26 02:15:07 -08:00
add test cases
2015-01-26 05:28:23 -08:00
before(function(done) {
basic streaming body
2015-01-26 05:58:52 -08:00
local = new TestServer();
base = 'http://' + local.hostname + ':' + local.port;
local.start(done);
add test cases
2015-01-26 05:28:23 -08:00
});
after(function(done) {
basic streaming body
2015-01-26 05:58:52 -08:00
local.stop(done);
basic http added
2015-01-26 02:15:07 -08:00
});
it('should return a promise', function() {
url = 'http://example.com/';
basic streaming body
2015-01-26 05:58:52 -08:00
var p = fetch(url);
expect(p).to.be.an.instanceof(fetch.Promise);
expect(p).to.have.property('then');
basic http added
2015-01-26 02:15:07 -08:00
});
basic streaming body
2015-01-26 05:58:52 -08:00
it('should allow custom promise', function() {
basic http added
2015-01-26 02:15:07 -08:00
url = 'http://example.com/';
var old = fetch.Promise;
fetch.Promise = then;
expect(fetch(url)).to.be.an.instanceof(then);
more tests
2015-01-27 07:33:06 -08:00
expect(fetch(url)).to.not.be.an.instanceof(bluebird);
basic http added
2015-01-26 02:15:07 -08:00
fetch.Promise = old;
});
more tests
2015-01-27 07:33:06 -08:00
it('should throw error when no promise implementation are found', function() {
basic fetch feature done
2015-01-26 09:46:32 -08:00
url = 'http://example.com/';
var old = fetch.Promise;
fetch.Promise = undefined;
expect(function() {
fetch(url)
}).to.throw(Error);
fetch.Promise = old;
});
add basic test case for request
2015-06-03 21:12:27 -07:00
it('should expose Headers, Response and Request constructors', function() {
expose response and headers constructors
2015-05-03 01:37:58 -07:00
expect(fetch.Headers).to.equal(Headers);
expect(fetch.Response).to.equal(Response);
add basic test case for request
2015-06-03 21:12:27 -07:00
expect(fetch.Request).to.equal(Request);
expose response and headers constructors
2015-05-03 01:37:58 -07:00
});
basic streaming body
2015-01-26 05:58:52 -08:00
it('should reject with error if url is protocol relative', function() {
url = '//example.com/';
return expect(fetch(url)).to.eventually.be.rejectedWith(Error);
});
it('should reject with error if url is relative path', function() {
url = '/some/path';
basic http added
2015-01-26 02:15:07 -08:00
return expect(fetch(url)).to.eventually.be.rejectedWith(Error);
});
it('should reject with error if protocol is unsupported', function() {
url = 'ftp://example.com/';
return expect(fetch(url)).to.eventually.be.rejectedWith(Error);
});
basic fetch feature done
2015-01-26 09:46:32 -08:00
it('should reject with error on network failure', function() {
url = 'http://localhost:50000/';
Support for program checkable error by introducing custom errors with error types/codes This finally closes #7
2016-04-05 06:20:42 -07:00
return expect(fetch(url)).to.eventually.be.rejected
.and.be.an.instanceOf(FetchError)
add basic support for redirect mode
2016-04-05 11:47:23 -07:00
.and.include({ type: 'system', code: 'ECONNREFUSED', errno: 'ECONNREFUSED' });
basic fetch feature done
2015-01-26 09:46:32 -08:00
});
basic refactor done
2015-01-27 05:11:26 -08:00
it('should resolve into response', function() {
basic streaming body
2015-01-26 05:58:52 -08:00
url = base + '/hello';
basic http added
2015-01-26 02:15:07 -08:00
return fetch(url).then(function(res) {
basic refactor done
2015-01-27 05:11:26 -08:00
expect(res).to.be.an.instanceof(Response);
expect(res.headers).to.be.an.instanceof(Headers);
expect(res.body).to.be.an.instanceof(stream.Transform);
expect(res.bodyUsed).to.be.false;
more tests
2015-01-27 07:33:06 -08:00
expect(res.url).to.equal(url);
better tests and doc for res.ok
2015-01-27 20:17:12 -08:00
expect(res.ok).to.be.true;
more tests
2015-01-27 07:33:06 -08:00
expect(res.status).to.equal(200);
expect(res.statusText).to.equal('OK');
});
});
it('should accept plain text response', function() {
url = base + '/plain';
return fetch(url).then(function(res) {
expect(res.headers.get('content-type')).to.equal('text/plain');
return res.text().then(function(result) {
expect(res.bodyUsed).to.be.true;
expect(result).to.be.a('string');
expect(result).to.equal('text');
});
});
});
it('should accept html response (like plain text)', function() {
url = base + '/html';
return fetch(url).then(function(res) {
expect(res.headers.get('content-type')).to.equal('text/html');
return res.text().then(function(result) {
expect(res.bodyUsed).to.be.true;
expect(result).to.be.a('string');
expect(result).to.equal('<html></html>');
});
});
});
it('should accept json response', function() {
url = base + '/json';
return fetch(url).then(function(res) {
expect(res.headers.get('content-type')).to.equal('application/json');
return res.json().then(function(result) {
expect(res.bodyUsed).to.be.true;
expect(result).to.be.an('object');
expect(result).to.deep.equal({ name: 'value' });
});
});
});
it('should send request with custom headers', function() {
url = base + '/inspect';
opts = {
headers: { 'x-custom-header': 'abc' }
};
return fetch(url, opts).then(function(res) {
return res.json();
}).then(function(res) {
expect(res.headers['x-custom-header']).to.equal('abc');
});
});
add Headers support
2015-04-22 08:36:11 -07:00
it('should accept headers instance', function() {
url = base + '/inspect';
opts = {
headers: new Headers({ 'x-custom-header': 'abc' })
};
return fetch(url, opts).then(function(res) {
return res.json();
}).then(function(res) {
expect(res.headers['x-custom-header']).to.equal('abc');
});
});
update comment to explain hack, make use of inpsect route in test, and update changelog
2015-07-11 04:38:26 -07:00
it('should accept custom host header', function() {
url = base + '/inspect';
opts = {
headers: {
host: 'example.com'
}
};
return fetch(url, opts).then(function(res) {
return res.json();
}).then(function(res) {
expect(res.headers['host']).to.equal('example.com');
});
});
more tests
2015-01-27 07:33:06 -08:00
it('should follow redirect code 301', function() {
url = base + '/redirect/301';
return fetch(url).then(function(res) {
expect(res.url).to.equal(base + '/inspect');
expect(res.status).to.equal(200);
redirect 301 result in status 200 and res.ok true
2015-01-27 21:10:33 -08:00
expect(res.ok).to.be.true;
more tests
2015-01-27 07:33:06 -08:00
});
});
it('should follow redirect code 302', function() {
url = base + '/redirect/302';
return fetch(url).then(function(res) {
expect(res.url).to.equal(base + '/inspect');
expect(res.status).to.equal(200);
});
});
it('should follow redirect code 303', function() {
url = base + '/redirect/303';
return fetch(url).then(function(res) {
expect(res.url).to.equal(base + '/inspect');
expect(res.status).to.equal(200);
});
});
it('should follow redirect code 307', function() {
url = base + '/redirect/307';
return fetch(url).then(function(res) {
expect(res.url).to.equal(base + '/inspect');
expect(res.status).to.equal(200);
});
});
it('should follow redirect code 308', function() {
url = base + '/redirect/308';
return fetch(url).then(function(res) {
expect(res.url).to.equal(base + '/inspect');
expect(res.status).to.equal(200);
});
});
it('should follow redirect chain', function() {
url = base + '/redirect/chain';
return fetch(url).then(function(res) {
expect(res.url).to.equal(base + '/inspect');
expect(res.status).to.equal(200);
});
});
per spec, follow redirect with GET request
2015-09-28 07:30:41 -07:00
it('should follow POST request redirect code 301 with GET', function() {
url = base + '/redirect/301';
opts = {
method: 'POST'
, body: 'a=1'
};
return fetch(url, opts).then(function(res) {
expect(res.url).to.equal(base + '/inspect');
expect(res.status).to.equal(200);
return res.json().then(function(result) {
expect(result.method).to.equal('GET');
expect(result.body).to.equal('');
});
});
});
it('should follow POST request redirect code 302 with GET', function() {
url = base + '/redirect/302';
opts = {
method: 'POST'
, body: 'a=1'
};
return fetch(url, opts).then(function(res) {
expect(res.url).to.equal(base + '/inspect');
expect(res.status).to.equal(200);
return res.json().then(function(result) {
expect(result.method).to.equal('GET');
expect(result.body).to.equal('');
});
});
});
it('should follow redirect code 303 with GET', function() {
url = base + '/redirect/303';
opts = {
method: 'PUT'
, body: 'a=1'
};
return fetch(url, opts).then(function(res) {
expect(res.url).to.equal(base + '/inspect');
expect(res.status).to.equal(200);
return res.json().then(function(result) {
expect(result.method).to.equal('GET');
expect(result.body).to.equal('');
});
});
});
better test coverage
2015-01-27 09:00:53 -08:00
it('should obey maximum redirect', function() {
more tests
2015-01-27 07:33:06 -08:00
url = base + '/redirect/chain';
opts = {
follow: 1
better test coverage
2015-01-27 09:00:53 -08:00
}
Support for program checkable error by introducing custom errors with error types/codes This finally closes #7
2016-04-05 06:20:42 -07:00
return expect(fetch(url, opts)).to.eventually.be.rejected
.and.be.an.instanceOf(FetchError)
.and.have.property('type', 'max-redirect');
more tests
2015-01-27 07:33:06 -08:00
});
fix follow=0 scenario
2015-03-19 09:22:23 -07:00
it('should allow not following redirect', function() {
url = base + '/redirect/301';
opts = {
follow: 0
}
Support for program checkable error by introducing custom errors with error types/codes This finally closes #7
2016-04-05 06:20:42 -07:00
return expect(fetch(url, opts)).to.eventually.be.rejected
.and.be.an.instanceOf(FetchError)
.and.have.property('type', 'max-redirect');
fix follow=0 scenario
2015-03-19 09:22:23 -07:00
});
add basic support for redirect mode
2016-04-05 11:47:23 -07:00
it('should support redirect mode, manual flag', function() {
url = base + '/redirect/301';
opts = {
redirect: 'manual'
};
return fetch(url, opts).then(function(res) {
fix manual redirect mode
2016-04-12 11:58:04 -07:00
expect(res.url).to.equal(url);
add basic support for redirect mode
2016-04-05 11:47:23 -07:00
expect(res.status).to.equal(301);
expect(res.headers.get('location')).to.equal(base + '/inspect');
});
});
it('should support redirect mode, error flag', function() {
url = base + '/redirect/301';
opts = {
redirect: 'error'
};
return expect(fetch(url, opts)).to.eventually.be.rejected
.and.be.an.instanceOf(FetchError)
.and.have.property('type', 'no-redirect');
});
fix manual redirect mode
2016-04-12 11:58:04 -07:00
it('should support redirect mode, manual flag when there is no redirect', function() {
url = base + '/hello';
opts = {
redirect: 'manual'
};
return fetch(url, opts).then(function(res) {
expect(res.url).to.equal(url);
expect(res.status).to.equal(200);
expect(res.headers.get('location')).to.be.null;
});
});
add Headers support
2015-04-22 08:36:11 -07:00
it('should follow redirect code 301 and keep existing headers', function() {
url = base + '/redirect/301';
opts = {
headers: new Headers({ 'x-custom-header': 'abc' })
};
return fetch(url, opts).then(function(res) {
expect(res.url).to.equal(base + '/inspect');
return res.json();
}).then(function(res) {
expect(res.headers['x-custom-header']).to.equal('abc');
});
});
better test coverage
2015-01-27 09:00:53 -08:00
it('should reject broken redirect', function() {
url = base + '/error/redirect';
Support for program checkable error by introducing custom errors with error types/codes This finally closes #7
2016-04-05 06:20:42 -07:00
return expect(fetch(url)).to.eventually.be.rejected
.and.be.an.instanceOf(FetchError)
.and.have.property('type', 'invalid-redirect');
better test coverage
2015-01-27 09:00:53 -08:00
});
fix manual redirect mode
2016-04-12 11:58:04 -07:00
it('should not reject broken redirect under manual redirect', function() {
url = base + '/error/redirect';
opts = {
redirect: 'manual'
};
return fetch(url, opts).then(function(res) {
expect(res.url).to.equal(url);
expect(res.status).to.equal(301);
expect(res.headers.get('location')).to.be.null;
});
});
better test coverage
2015-01-27 09:00:53 -08:00
it('should handle client-error response', function() {
url = base + '/error/400';
return fetch(url).then(function(res) {
expect(res.headers.get('content-type')).to.equal('text/plain');
expect(res.status).to.equal(400);
expect(res.statusText).to.equal('Bad Request');
better tests and doc for res.ok
2015-01-27 20:17:12 -08:00
expect(res.ok).to.be.false;
better test coverage
2015-01-27 09:00:53 -08:00
return res.text().then(function(result) {
expect(res.bodyUsed).to.be.true;
expect(result).to.be.a('string');
expect(result).to.equal('client error');
});
});
});
it('should handle server-error response', function() {
url = base + '/error/500';
return fetch(url).then(function(res) {
expect(res.headers.get('content-type')).to.equal('text/plain');
expect(res.status).to.equal(500);
expect(res.statusText).to.equal('Internal Server Error');
better tests and doc for res.ok
2015-01-27 20:17:12 -08:00
expect(res.ok).to.be.false;
better test coverage
2015-01-27 09:00:53 -08:00
return res.text().then(function(result) {
expect(res.bodyUsed).to.be.true;
expect(result).to.be.a('string');
expect(result).to.equal('server error');
});
});
});
it('should handle network-error response', function() {
url = base + '/error/reset';
Support for program checkable error by introducing custom errors with error types/codes This finally closes #7
2016-04-05 06:20:42 -07:00
return expect(fetch(url)).to.eventually.be.rejected
.and.be.an.instanceOf(FetchError)
.and.have.property('code', 'ECONNRESET');
});
it('should handle DNS-error response', function() {
use a IETF reserved domain name for invalid dns test
2016-04-05 11:01:07 -07:00
url = 'http://domain.invalid';
Support for program checkable error by introducing custom errors with error types/codes This finally closes #7
2016-04-05 06:20:42 -07:00
return expect(fetch(url)).to.eventually.be.rejected
.and.be.an.instanceOf(FetchError)
.and.have.property('code', 'ENOTFOUND');
better test coverage
2015-01-27 09:00:53 -08:00
});
better test coverage on edge case
2015-01-27 21:01:10 -08:00
it('should reject invalid json response', function() {
url = base + '/error/json';
return fetch(url).then(function(res) {
expect(res.headers.get('content-type')).to.equal('application/json');
return expect(res.json()).to.eventually.be.rejectedWith(Error);
});
});
handle gzip encoding with 204 and 304 responses
2016-05-25 09:46:11 -07:00
it('should handle no content response', function() {
url = base + '/no-content';
better test coverage on edge case
2015-01-27 21:01:10 -08:00
return fetch(url).then(function(res) {
expect(res.status).to.equal(204);
expect(res.statusText).to.equal('No Content');
expect(res.ok).to.be.true;
return res.text().then(function(result) {
expect(result).to.be.a('string');
expect(result).to.be.empty;
});
});
});
handle gzip encoding with 204 and 304 responses
2016-05-25 09:46:11 -07:00
it('should handle no content response with gzip encoding', function() {
url = base + '/no-content/gzip';
return fetch(url).then(function(res) {
expect(res.status).to.equal(204);
expect(res.statusText).to.equal('No Content');
expect(res.headers.get('content-encoding')).to.equal('gzip');
expect(res.ok).to.be.true;
return res.text().then(function(result) {
expect(result).to.be.a('string');
expect(result).to.be.empty;
});
});
});
it('should handle not modified response', function() {
url = base + '/not-modified';
return fetch(url).then(function(res) {
expect(res.status).to.equal(304);
expect(res.statusText).to.equal('Not Modified');
expect(res.ok).to.be.false;
return res.text().then(function(result) {
expect(result).to.be.a('string');
expect(result).to.be.empty;
});
});
});
it('should handle not modified response with gzip encoding', function() {
url = base + '/not-modified/gzip';
return fetch(url).then(function(res) {
expect(res.status).to.equal(304);
expect(res.statusText).to.equal('Not Modified');
expect(res.headers.get('content-encoding')).to.equal('gzip');
expect(res.ok).to.be.false;
return res.text().then(function(result) {
expect(result).to.be.a('string');
expect(result).to.be.empty;
});
});
});
more tests
2015-01-27 07:33:06 -08:00
it('should decompress gzip response', function() {
url = base + '/gzip';
return fetch(url).then(function(res) {
expect(res.headers.get('content-type')).to.equal('text/plain');
return res.text().then(function(result) {
expect(result).to.be.a('string');
expect(result).to.equal('hello world');
});
});
});
it('should decompress deflate response', function() {
url = base + '/deflate';
return fetch(url).then(function(res) {
expect(res.headers.get('content-type')).to.equal('text/plain');
return res.text().then(function(result) {
expect(result).to.be.a('string');
expect(result).to.equal('hello world');
});
});
});
handle raw deflate response from old servers
2016-08-03 02:31:46 -07:00
it('should decompress deflate raw response from old apache server', function() {
url = base + '/deflate-raw';
return fetch(url).then(function(res) {
expect(res.headers.get('content-type')).to.equal('text/plain');
return res.text().then(function(result) {
expect(result).to.be.a('string');
expect(result).to.equal('hello world');
});
});
});
better test coverage on edge case
2015-01-27 21:01:10 -08:00
it('should skip decompression if unsupported', function() {
url = base + '/sdch';
return fetch(url).then(function(res) {
expect(res.headers.get('content-type')).to.equal('text/plain');
return res.text().then(function(result) {
expect(result).to.be.a('string');
expect(result).to.equal('fake sdch string');
});
});
});
handle body stream error
2015-09-28 06:58:45 -07:00
it('should reject if response compression is invalid', function() {
url = base + '/invalid-content-encoding';
return fetch(url).then(function(res) {
expect(res.headers.get('content-type')).to.equal('text/plain');
Support for program checkable error by introducing custom errors with error types/codes This finally closes #7
2016-04-05 06:20:42 -07:00
return expect(res.text()).to.eventually.be.rejected
.and.be.an.instanceOf(FetchError)
.and.have.property('code', 'Z_DATA_ERROR');
handle body stream error
2015-09-28 06:58:45 -07:00
});
});
more tests
2015-01-27 07:33:06 -08:00
it('should allow disabling auto decompression', function() {
url = base + '/gzip';
opts = {
compress: false
};
return fetch(url, opts).then(function(res) {
expect(res.headers.get('content-type')).to.equal('text/plain');
return res.text().then(function(result) {
expect(result).to.be.a('string');
expect(result).to.not.equal('hello world');
});
});
});
it('should allow custom timeout', function() {
timeout on body and clear timeout internally
2015-04-16 22:26:55 -07:00
this.timeout(500);
more tests
2015-01-27 07:33:06 -08:00
url = base + '/timeout';
opts = {
timeout: 100
};
Support for program checkable error by introducing custom errors with error types/codes This finally closes #7
2016-04-05 06:20:42 -07:00
return expect(fetch(url, opts)).to.eventually.be.rejected
.and.be.an.instanceOf(FetchError)
socket timeout should really be custom request timeout, change name to reflect it
2016-04-05 10:47:07 -07:00
.and.have.property('type', 'request-timeout');
more tests
2015-01-27 07:33:06 -08:00
});
timeout on body and clear timeout internally
2015-04-16 22:26:55 -07:00
it('should allow custom timeout on response body', function() {
this.timeout(500);
url = base + '/slow';
opts = {
timeout: 100
};
return fetch(url, opts).then(function(res) {
expect(res.ok).to.be.true;
Support for program checkable error by introducing custom errors with error types/codes This finally closes #7
2016-04-05 06:20:42 -07:00
return expect(res.text()).to.eventually.be.rejected
.and.be.an.instanceOf(FetchError)
.and.have.property('type', 'body-timeout');
timeout on body and clear timeout internally
2015-04-16 22:26:55 -07:00
});
});
it('should clear internal timeout on fetch response', function (done) {
this.timeout(1000);
spawn('node', ['-e', 'require("./")("' + base + '/hello", { timeout: 5000 })'])
.on('exit', function () {
done();
});
});
it('should clear internal timeout on fetch redirect', function (done) {
this.timeout(1000);
spawn('node', ['-e', 'require("./")("' + base + '/redirect/301", { timeout: 5000 })'])
.on('exit', function () {
done();
});
});
it('should clear internal timeout on fetch error', function (done) {
this.timeout(1000);
spawn('node', ['-e', 'require("./")("' + base + '/error/reset", { timeout: 5000 })'])
.on('exit', function () {
done();
});
});
more tests
2015-01-27 07:33:06 -08:00
it('should allow POST request', function() {
url = base + '/inspect';
opts = {
method: 'POST'
};
return fetch(url, opts).then(function(res) {
return res.json();
}).then(function(res) {
expect(res.method).to.equal('POST');
auto add content-length on for string body
2015-09-28 02:40:58 -07:00
expect(res.headers['transfer-encoding']).to.be.undefined;
expect(res.headers['content-length']).to.equal('0');
more tests
2015-01-27 07:33:06 -08:00
});
});
it('should allow POST request with string body', function() {
url = base + '/inspect';
opts = {
method: 'POST'
, body: 'a=1'
};
return fetch(url, opts).then(function(res) {
return res.json();
}).then(function(res) {
expect(res.method).to.equal('POST');
expect(res.body).to.equal('a=1');
auto add content-length on for string body
2015-09-28 02:40:58 -07:00
expect(res.headers['transfer-encoding']).to.be.undefined;
expect(res.headers['content-length']).to.equal('3');
more tests
2015-01-27 07:33:06 -08:00
});
});
support buffer for request body
2016-08-02 22:07:47 -07:00
it('should allow POST request with buffer body', function() {
url = base + '/inspect';
opts = {
method: 'POST'
, body: new Buffer('a=1', 'utf-8')
};
return fetch(url, opts).then(function(res) {
return res.json();
}).then(function(res) {
expect(res.method).to.equal('POST');
expect(res.body).to.equal('a=1');
expect(res.headers['transfer-encoding']).to.equal('chunked');
expect(res.headers['content-length']).to.be.undefined;
});
});
more tests
2015-01-27 07:33:06 -08:00
it('should allow POST request with readable stream as body', function() {
avoid calling formdata getLengthSync when it has stream as fields
2016-05-25 10:37:36 -07:00
var body = resumer().queue('a=1').end();
body = body.pipe(new stream.PassThrough());
more tests
2015-01-27 07:33:06 -08:00
url = base + '/inspect';
opts = {
method: 'POST'
avoid calling formdata getLengthSync when it has stream as fields
2016-05-25 10:37:36 -07:00
, body: body
more tests
2015-01-27 07:33:06 -08:00
};
return fetch(url, opts).then(function(res) {
return res.json();
}).then(function(res) {
expect(res.method).to.equal('POST');
expect(res.body).to.equal('a=1');
auto add content-length on for string body
2015-09-28 02:40:58 -07:00
expect(res.headers['transfer-encoding']).to.equal('chunked');
expect(res.headers['content-length']).to.be.undefined;
basic http added
2015-01-26 02:15:07 -08:00
});
});
basic streaming body
2015-01-26 05:58:52 -08:00
Automatically pull headers from node-form-data.
2015-07-21 19:05:06 -07:00
it('should allow POST request with form-data as body', function() {
var form = new FormData();
additional tests for the new form-data integration
2015-07-22 00:40:52 -07:00
form.append('a','1');
Automatically pull headers from node-form-data.
2015-07-21 19:05:06 -07:00
additional tests for the new form-data integration
2015-07-22 00:40:52 -07:00
url = base + '/multipart';
Automatically pull headers from node-form-data.
2015-07-21 19:05:06 -07:00
opts = {
method: 'POST'
, body: form
};
return fetch(url, opts).then(function(res) {
return res.json();
}).then(function(res) {
expect(res.method).to.equal('POST');
additional tests for the new form-data integration
2015-07-22 00:40:52 -07:00
expect(res.headers['content-type']).to.contain('multipart/form-data');
test for form-data content-length hack
2016-03-19 00:51:48 -07:00
expect(res.headers['content-length']).to.be.a('string');
additional tests for the new form-data integration
2015-07-22 00:40:52 -07:00
expect(res.body).to.equal('a=1');
Automatically pull headers from node-form-data.
2015-07-21 19:05:06 -07:00
});
});
avoid calling formdata getLengthSync when it has stream as fields
2016-05-25 10:37:36 -07:00
it('should allow POST request with form-data using stream as body', function() {
var form = new FormData();
form.append('my_field', fs.createReadStream('test/dummy.txt'));
url = base + '/multipart';
opts = {
method: 'POST'
, body: form
};
return fetch(url, opts).then(function(res) {
return res.json();
}).then(function(res) {
expect(res.method).to.equal('POST');
expect(res.headers['content-type']).to.contain('multipart/form-data');
expect(res.headers['content-length']).to.be.undefined;
expect(res.body).to.contain('my_field=');
});
});
additional tests for the new form-data integration
2015-07-22 00:40:52 -07:00
it('should allow POST request with form-data as body and custom headers', function() {
var form = new FormData();
form.append('a','1');
var headers = form.getHeaders();
headers['b'] = '2';
url = base + '/multipart';
opts = {
method: 'POST'
, body: form
, headers: headers
};
return fetch(url, opts).then(function(res) {
return res.json();
}).then(function(res) {
expect(res.method).to.equal('POST');
expect(res.headers['content-type']).to.contain('multipart/form-data');
test for form-data content-length hack
2016-03-19 00:51:48 -07:00
expect(res.headers['content-length']).to.be.a('string');
additional tests for the new form-data integration
2015-07-22 00:40:52 -07:00
expect(res.headers.b).to.equal('2');
expect(res.body).to.equal('a=1');
});
});
Automatically pull headers from node-form-data.
2015-07-21 19:05:06 -07:00
better test coverage
2015-01-27 09:00:53 -08:00
it('should allow PUT request', function() {
url = base + '/inspect';
opts = {
method: 'PUT'
, body: 'a=1'
};
return fetch(url, opts).then(function(res) {
return res.json();
}).then(function(res) {
expect(res.method).to.equal('PUT');
expect(res.body).to.equal('a=1');
});
});
it('should allow DELETE request', function() {
url = base + '/inspect';
opts = {
method: 'DELETE'
};
return fetch(url, opts).then(function(res) {
return res.json();
}).then(function(res) {
expect(res.method).to.equal('DELETE');
send delete body with content-length
2016-05-25 11:00:25 -07:00
});
});
it('should allow POST request with string body', function() {
url = base + '/inspect';
opts = {
method: 'POST'
, body: 'a=1'
};
return fetch(url, opts).then(function(res) {
return res.json();
}).then(function(res) {
expect(res.method).to.equal('POST');
expect(res.body).to.equal('a=1');
expect(res.headers['transfer-encoding']).to.be.undefined;
expect(res.headers['content-length']).to.equal('3');
});
});
it('should allow DELETE request with string body', function() {
url = base + '/inspect';
opts = {
method: 'DELETE'
, body: 'a=1'
};
return fetch(url, opts).then(function(res) {
return res.json();
}).then(function(res) {
expect(res.method).to.equal('DELETE');
expect(res.body).to.equal('a=1');
expect(res.headers['transfer-encoding']).to.be.undefined;
expect(res.headers['content-length']).to.equal('3');
better test coverage
2015-01-27 09:00:53 -08:00
});
});
better test coverage on edge case
2015-01-27 21:01:10 -08:00
it('should allow PATCH request', function() {
url = base + '/inspect';
opts = {
method: 'PATCH'
, body: 'a=1'
};
return fetch(url, opts).then(function(res) {
return res.json();
}).then(function(res) {
expect(res.method).to.equal('PATCH');
expect(res.body).to.equal('a=1');
});
});
better test coverage
2015-01-27 09:00:53 -08:00
it('should allow HEAD request', function() {
url = base + '/hello';
opts = {
method: 'HEAD'
};
return fetch(url, opts).then(function(res) {
expect(res.status).to.equal(200);
expect(res.statusText).to.equal('OK');
expect(res.headers.get('content-type')).to.equal('text/plain');
expect(res.body).to.be.an.instanceof(stream.Transform);
HEAD request does not need to process body with decompression
2016-08-02 21:55:58 -07:00
return res.text();
}).then(function(text) {
expect(text).to.equal('');
});
});
it('should allow HEAD request with content-encoding header', function() {
url = base + '/error/404';
opts = {
method: 'HEAD'
};
return fetch(url, opts).then(function(res) {
expect(res.status).to.equal(404);
expect(res.headers.get('content-encoding')).to.equal('gzip');
return res.text();
}).then(function(text) {
expect(text).to.equal('');
better test coverage
2015-01-27 09:00:53 -08:00
});
});
test for options support
2016-03-19 03:24:08 -07:00
it('should allow OPTIONS request', function() {
url = base + '/options';
opts = {
method: 'OPTIONS'
};
return fetch(url, opts).then(function(res) {
expect(res.status).to.equal(200);
expect(res.statusText).to.equal('OK');
expect(res.headers.get('allow')).to.equal('GET, HEAD, OPTIONS');
expect(res.body).to.be.an.instanceof(stream.Transform);
});
});
better test coverage
2015-01-27 09:00:53 -08:00
it('should reject decoding body twice', function() {
url = base + '/plain';
return fetch(url).then(function(res) {
expect(res.headers.get('content-type')).to.equal('text/plain');
return res.text().then(function(result) {
expect(res.bodyUsed).to.be.true;
return expect(res.text()).to.eventually.be.rejectedWith(Error);
});
});
});
xml encoding detection, response size limit
2015-01-28 06:56:25 -08:00
it('should support maximum response size, multiple chunk', function() {
url = base + '/size/chunk';
better test coverage
2015-01-27 09:00:53 -08:00
opts = {
xml encoding detection, response size limit
2015-01-28 06:56:25 -08:00
size: 5
better test coverage
2015-01-27 09:00:53 -08:00
};
return fetch(url, opts).then(function(res) {
expect(res.status).to.equal(200);
expect(res.headers.get('content-type')).to.equal('text/plain');
Support for program checkable error by introducing custom errors with error types/codes This finally closes #7
2016-04-05 06:20:42 -07:00
return expect(res.text()).to.eventually.be.rejected
.and.be.an.instanceOf(FetchError)
.and.have.property('type', 'max-size');
better test coverage
2015-01-27 09:00:53 -08:00
});
});
xml encoding detection, response size limit
2015-01-28 06:56:25 -08:00
it('should support maximum response size, single chunk', function() {
url = base + '/size/long';
opts = {
size: 5
};
return fetch(url, opts).then(function(res) {
expect(res.status).to.equal(200);
expect(res.headers.get('content-type')).to.equal('text/plain');
Support for program checkable error by introducing custom errors with error types/codes This finally closes #7
2016-04-05 06:20:42 -07:00
return expect(res.text()).to.eventually.be.rejected
.and.be.an.instanceOf(FetchError)
.and.have.property('type', 'max-size');
xml encoding detection, response size limit
2015-01-28 06:56:25 -08:00
});
});
it('should support encoding decode, xml dtd detect', function() {
url = base + '/encoding/euc-jp';
return fetch(url).then(function(res) {
expect(res.status).to.equal(200);
return res.text().then(function(result) {
expect(result).to.equal('<?xml version="1.0" encoding="EUC-JP"?><title>日本語</title>');
});
});
});
it('should support encoding decode, content-type detect', function() {
better test coverage
2015-01-27 09:00:53 -08:00
url = base + '/encoding/shift-jis';
return fetch(url).then(function(res) {
expect(res.status).to.equal(200);
return res.text().then(function(result) {
expect(result).to.equal('<div>日本語</div>');
});
});
});
it('should support encoding decode, html5 detect', function() {
url = base + '/encoding/gbk';
return fetch(url).then(function(res) {
expect(res.status).to.equal(200);
return res.text().then(function(result) {
expect(result).to.equal('<meta charset="gbk"><div>中文</div>');
});
});
});
it('should support encoding decode, html4 detect', function() {
url = base + '/encoding/gb2312';
return fetch(url).then(function(res) {
expect(res.status).to.equal(200);
return res.text().then(function(result) {
expect(result).to.equal('<meta http-equiv="Content-Type" content="text/html; charset=gb2312"><div>中文</div>');
});
});
});
better test coverage on edge case
2015-01-27 21:01:10 -08:00
it('should default to utf8 encoding', function() {
url = base + '/encoding/utf8';
return fetch(url).then(function(res) {
expect(res.status).to.equal(200);
expect(res.headers.get('content-type')).to.be.null;
return res.text().then(function(result) {
expect(result).to.equal('中文');
});
});
});
added test cases for regex
2015-03-23 21:31:04 -07:00
it('should support uncommon content-type order, charset in front', function() {
url = base + '/encoding/order1';
return fetch(url).then(function(res) {
expect(res.status).to.equal(200);
return res.text().then(function(result) {
expect(result).to.equal('中文');
});
});
});
it('should support uncommon content-type order, end with qs', function() {
url = base + '/encoding/order2';
return fetch(url).then(function(res) {
expect(res.status).to.equal(200);
return res.text().then(function(result) {
expect(result).to.equal('中文');
});
});
});
fix chunked encoding support for character encoding conversion, thx @dsuket PR #50
2016-03-19 01:17:14 -07:00
it('should support chunked encoding, html4 detect', function() {
url = base + '/encoding/chunked';
return fetch(url).then(function(res) {
expect(res.status).to.equal(200);
fix tests for older node
2016-03-19 03:36:53 -07:00
// because node v0.12 doesn't have str.repeat
var padding = new Array(10 + 1).join('a');
fix chunked encoding support for character encoding conversion, thx @dsuket PR #50
2016-03-19 01:17:14 -07:00
return res.text().then(function(result) {
expect(result).to.equal(padding + '<meta http-equiv="Content-Type" content="text/html; charset=Shift_JIS" /><div>日本語</div>');
});
});
});
clone method support
2016-03-19 03:06:33 -07:00
it('should only do encoding detection up to 1024 bytes', function() {
url = base + '/encoding/invalid';
return fetch(url).then(function(res) {
expect(res.status).to.equal(200);
fix tests for older node
2016-03-19 03:36:53 -07:00
// because node v0.12 doesn't have str.repeat
var padding = new Array(1200 + 1).join('a');
clone method support
2016-03-19 03:06:33 -07:00
return res.text().then(function(result) {
expect(result).to.not.equal(padding + '中文');
});
});
});
better test coverage on edge case
2015-01-27 21:01:10 -08:00
it('should allow piping response body as stream', function(done) {
url = base + '/hello';
fetch(url).then(function(res) {
expect(res.body).to.be.an.instanceof(stream.Transform);
res.body.on('data', function(chunk) {
if (chunk === null) {
return;
}
expect(chunk.toString()).to.equal('world');
});
res.body.on('end', function() {
done();
});
});
});
clone method support
2016-03-19 03:06:33 -07:00
it('should allow cloning a response, and use both as stream', function(done) {
url = base + '/hello';
return fetch(url).then(function(res) {
var counter = 0;
var r1 = res.clone();
expect(res.body).to.be.an.instanceof(stream.Transform);
expect(r1.body).to.be.an.instanceof(stream.Transform);
res.body.on('data', function(chunk) {
if (chunk === null) {
return;
}
expect(chunk.toString()).to.equal('world');
});
res.body.on('end', function() {
counter++;
if (counter == 2) {
done();
}
});
r1.body.on('data', function(chunk) {
if (chunk === null) {
return;
}
expect(chunk.toString()).to.equal('world');
});
r1.body.on('end', function() {
counter++;
if (counter == 2) {
done();
}
});
});
});
demostrate restream more clearly in tests
2016-03-23 00:23:56 -07:00
it('should allow cloning a json response and log it as text response', function() {
clone method support
2016-03-19 03:06:33 -07:00
url = base + '/json';
return fetch(url).then(function(res) {
var r1 = res.clone();
demostrate restream more clearly in tests
2016-03-23 00:23:56 -07:00
return fetch.Promise.all([res.json(), r1.text()]).then(function(results) {
expect(results[0]).to.deep.equal({name: 'value'});
expect(results[1]).to.equal('{"name":"value"}');
});
});
});
it('should allow cloning a json response, and then log it as text response', function() {
url = base + '/json';
return fetch(url).then(function(res) {
var r1 = res.clone();
return res.json().then(function(result) {
expect(result).to.deep.equal({name: 'value'});
return r1.text().then(function(result) {
expect(result).to.equal('{"name":"value"}');
});
clone method support
2016-03-19 03:06:33 -07:00
});
});
});
user should be able to resolve cloned body before original body
2016-05-25 10:01:56 -07:00
it('should allow cloning a json response, first log as text response, then return json object', function() {
url = base + '/json';
return fetch(url).then(function(res) {
var r1 = res.clone();
return r1.text().then(function(result) {
expect(result).to.equal('{"name":"value"}');
return res.json().then(function(result) {
expect(result).to.deep.equal({name: 'value'});
});
});
});
});
clone method support
2016-03-19 03:06:33 -07:00
it('should not allow cloning a response after its been used', function() {
url = base + '/hello';
return fetch(url).then(function(res) {
return res.text().then(function(result) {
expect(function() {
var r1 = res.clone();
}).to.throw(Error);
});
})
});
better test coverage
2015-01-27 09:00:53 -08:00
it('should allow get all responses of a header', function() {
url = base + '/cookie';
return fetch(url).then(function(res) {
better test coverage on edge case
2015-01-27 21:01:10 -08:00
expect(res.headers.get('set-cookie')).to.equal('a=1');
expect(res.headers.get('Set-Cookie')).to.equal('a=1');
better test coverage
2015-01-27 09:00:53 -08:00
expect(res.headers.getAll('set-cookie')).to.deep.equal(['a=1', 'b=1']);
better test coverage on edge case
2015-01-27 21:01:10 -08:00
expect(res.headers.getAll('Set-Cookie')).to.deep.equal(['a=1', 'b=1']);
better test coverage
2015-01-27 09:00:53 -08:00
});
});
Add Headers.forEach method.
2015-10-26 22:13:02 -07:00
it('should allow iterating through all headers', function() {
var headers = new Headers({
more test cleanup
2016-03-19 00:33:13 -07:00
a: 1
, b: [2, 3]
, c: [4]
Add Headers.forEach method.
2015-10-26 22:13:02 -07:00
});
more test cleanup
2016-03-19 00:33:13 -07:00
expect(headers).to.have.property('forEach');
Add Headers.forEach method.
2015-10-26 22:13:02 -07:00
more test cleanup
2016-03-19 00:33:13 -07:00
var result = [];
headers.forEach(function(val, key) {
result.push([key, val]);
});
Add Headers.forEach method.
2015-10-26 22:13:02 -07:00
expected = [
more test cleanup
2016-03-19 00:33:13 -07:00
["a", "1"]
, ["b", "2"]
, ["b", "3"]
, ["c", "4"]
Add Headers.forEach method.
2015-10-26 22:13:02 -07:00
];
clone method support
2016-03-19 03:06:33 -07:00
expect(result).to.deep.equal(expected);
Add Headers.forEach method.
2015-10-26 22:13:02 -07:00
});
better test coverage
2015-01-27 09:00:53 -08:00
it('should allow deleting header', function() {
url = base + '/cookie';
return fetch(url).then(function(res) {
res.headers.delete('set-cookie');
expect(res.headers.get('set-cookie')).to.be.null;
expect(res.headers.getAll('set-cookie')).to.be.empty;
});
});
let nodejs handle the connection pool when agent is passed
2016-04-29 22:19:08 -07:00
it('should send request with connection keep-alive if agent is provided', function() {
url = base + '/inspect';
opts = {
agent: new http.Agent({
keepAlive: true
})
};
return fetch(url, opts).then(function(res) {
return res.json();
}).then(function(res) {
expect(res.headers['connection']).to.equal('keep-alive');
});
});
better test for headers, only support string and array
2015-04-28 21:15:08 -07:00
it('should ignore unsupported attributes while reading headers', function() {
travis and tests update, plus some doc clean up
2015-03-19 08:38:27 -07:00
var FakeHeader = function() {};
handle common mistake of passing number as header
2015-05-03 21:05:06 -07:00
// prototypes are ignored
FakeHeader.prototype.z = 'fake';
better test for headers, only support string and array
2015-04-28 21:15:08 -07:00
travis and tests update, plus some doc clean up
2015-03-19 08:38:27 -07:00
var res = new FakeHeader;
handle common mistake of passing number as header
2015-05-03 21:05:06 -07:00
// valid
travis and tests update, plus some doc clean up
2015-03-19 08:38:27 -07:00
res.a = 'string';
better test for headers, only support string and array
2015-04-28 21:15:08 -07:00
res.b = ['1','2'];
res.c = '';
res.d = [];
handle common mistake of passing number as header
2015-05-03 21:05:06 -07:00
// common mistakes, normalized
res.e = 1;
res.f = [1, 2];
// invalid, ignored
res.g = { a:1 };
res.h = undefined;
res.i = null;
res.j = NaN;
res.k = true;
res.l = false;
var h1 = new Headers(res);
expect(h1._headers['a']).to.include('string');
expect(h1._headers['b']).to.include('1');
expect(h1._headers['b']).to.include('2');
expect(h1._headers['c']).to.include('');
expect(h1._headers['d']).to.be.undefined;
expect(h1._headers['e']).to.include('1');
expect(h1._headers['f']).to.include('1');
expect(h1._headers['f']).to.include('2');
expect(h1._headers['g']).to.be.undefined;
expect(h1._headers['h']).to.be.undefined;
expect(h1._headers['i']).to.be.undefined;
expect(h1._headers['j']).to.be.undefined;
expect(h1._headers['k']).to.be.undefined;
expect(h1._headers['l']).to.be.undefined;
expect(h1._headers['z']).to.be.undefined;
travis and tests update, plus some doc clean up
2015-03-19 08:38:27 -07:00
});
add Headers support
2015-04-22 08:36:11 -07:00
it('should wrap headers', function() {
var h1 = new Headers({
a: '1'
});
var h2 = new Headers(h1);
h2.set('b', '1');
var h3 = new Headers(h2);
h3.append('a', '2');
expect(h1._headers['a']).to.include('1');
expect(h1._headers['a']).to.not.include('2');
expect(h2._headers['a']).to.include('1');
expect(h2._headers['a']).to.not.include('2');
expect(h2._headers['b']).to.include('1');
expect(h3._headers['a']).to.include('1');
expect(h3._headers['a']).to.include('2');
expect(h3._headers['b']).to.include('1');
});
add basic test case for request
2015-06-03 21:12:27 -07:00
it('should support fetch with Request instance', function() {
url = base + '/hello';
var req = new Request(url);
return fetch(req).then(function(res) {
expect(res.url).to.equal(url);
expect(res.ok).to.be.true;
expect(res.status).to.equal(200);
});
});
allow request wrapping
2015-06-03 21:40:01 -07:00
it('should support wrapping Request instance', function() {
url = base + '/hello';
fix formdata support when you are trying to wrap the request
2016-03-23 00:02:04 -07:00
var form = new FormData();
form.append('a', '1');
allow request wrapping
2015-06-03 21:40:01 -07:00
var r1 = new Request(url, {
method: 'POST'
, follow: 1
fix formdata support when you are trying to wrap the request
2016-03-23 00:02:04 -07:00
, body: form
allow request wrapping
2015-06-03 21:40:01 -07:00
});
var r2 = new Request(r1, {
follow: 2
fix formdata support when you are trying to wrap the request
2016-03-23 00:02:04 -07:00
});
allow request wrapping
2015-06-03 21:40:01 -07:00
expect(r2.url).to.equal(url);
expect(r2.method).to.equal('POST');
fix formdata support when you are trying to wrap the request
2016-03-23 00:02:04 -07:00
// note that we didn't clone the body
expect(r2.body).to.equal(form);
allow request wrapping
2015-06-03 21:40:01 -07:00
expect(r1.follow).to.equal(1);
expect(r2.follow).to.equal(2);
});
it('should support overwrite Request instance', function() {
url = base + '/inspect';
var req = new Request(url, {
method: 'POST'
, headers: {
a: '1'
}
});
return fetch(req, {
method: 'GET'
, headers: {
a: '2'
}
}).then(function(res) {
return res.json();
}).then(function(body) {
expect(body.method).to.equal('GET');
expect(body.headers.a).to.equal('2');
});
});
test case for Response ctor
2015-09-28 07:39:53 -07:00
it('should support empty options in Response constructor', function() {
var body = resumer().queue('a=1').end();
make sure we test with transform stream
2015-09-28 08:04:14 -07:00
body = body.pipe(new stream.PassThrough());
test case for Response ctor
2015-09-28 07:39:53 -07:00
var res = new Response(body);
return res.text().then(function(result) {
expect(result).to.equal('a=1');
});
});
auto add content-length on for string body
2015-09-28 02:40:58 -07:00
it('should support parsing headers in Response constructor', function() {
fix coverage and remove duplicate tests
2016-03-19 00:11:16 -07:00
var res = new Response(null, {
auto add content-length on for string body
2015-09-28 02:40:58 -07:00
headers: {
a: '1'
}
});
expect(res.headers.get('a')).to.equal('1');
fix coverage and remove duplicate tests
2016-03-19 00:11:16 -07:00
});
it('should support text() method in Response constructor', function() {
var res = new Response('a=1');
return res.text().then(function(result) {
expect(result).to.equal('a=1');
});
});
it('should support json() method in Response constructor', function() {
var res = new Response('{"a":1}');
return res.json().then(function(result) {
expect(result.a).to.equal(1);
});
});
add a much-requested buffer() method for convenience
2016-08-02 22:27:32 -07:00
it('should support buffer() method in Response constructor', function() {
var res = new Response('a=1');
return res.buffer().then(function(result) {
expect(result.toString()).to.equal('a=1');
});
});
clone method support
2016-03-19 03:06:33 -07:00
it('should support clone() method in Response constructor', function() {
fix formdata support when you are trying to wrap the request
2016-03-23 00:02:04 -07:00
var body = resumer().queue('a=1').end();
body = body.pipe(new stream.PassThrough());
var res = new Response(body, {
clone method support
2016-03-19 03:06:33 -07:00
headers: {
a: '1'
}
, url: base
, status: 346
, statusText: 'production'
});
var cl = res.clone();
expect(cl.headers.get('a')).to.equal('1');
expect(cl.url).to.equal(base);
expect(cl.status).to.equal(346);
expect(cl.statusText).to.equal('production');
expect(cl.ok).to.be.false;
fix formdata support when you are trying to wrap the request
2016-03-23 00:02:04 -07:00
// clone body shouldn't be the same body
expect(cl.body).to.not.equal(body);
clone method support
2016-03-19 03:06:33 -07:00
return cl.text().then(function(result) {
expect(result).to.equal('a=1');
});
});
fix coverage and remove duplicate tests
2016-03-19 00:11:16 -07:00
it('should support stream as body in Response constructor', function() {
var body = resumer().queue('a=1').end();
body = body.pipe(new stream.PassThrough());
var res = new Response(body);
return res.text().then(function(result) {
expect(result).to.equal('a=1');
});
});
it('should support string as body in Response constructor', function() {
var res = new Response('a=1');
return res.text().then(function(result) {
expect(result).to.equal('a=1');
});
});
it('should support buffer as body in Response constructor', function() {
var res = new Response(new Buffer('a=1'));
test case for Response ctor
2015-09-28 07:39:53 -07:00
return res.text().then(function(result) {
expect(result).to.equal('a=1');
});
auto add content-length on for string body
2015-09-28 02:40:58 -07:00
});
it('should support parsing headers in Request constructor', function() {
url = base;
var req = new Request(url, {
headers: {
a: '1'
}
});
test case for Response ctor
2015-09-28 07:39:53 -07:00
expect(req.url).to.equal(url);
auto add content-length on for string body
2015-09-28 02:40:58 -07:00
expect(req.headers.get('a')).to.equal('1');
});
fix coverage and remove duplicate tests
2016-03-19 00:11:16 -07:00
it('should support text() method in Request constructor', function() {
url = base;
var req = new Request(url, {
body: 'a=1'
});
expect(req.url).to.equal(url);
return req.text().then(function(result) {
expect(result).to.equal('a=1');
});
});

it('should support json() method in Request constructor', function() {
url = base;
var req = new Request(url, {
body: '{"a":1}'
});
expect(req.url).to.equal(url);
return req.json().then(function(result) {
expect(result.a).to.equal(1);
});
});

add a much-requested buffer() method for convenience
2016-08-02 22:27:32 -07:00
it('should support buffer() method in Request constructor', function() {
url = base;
var req = new Request(url, {
body: 'a=1'
});
expect(req.url).to.equal(url);
return req.buffer().then(function(result) {
expect(result.toString()).to.equal('a=1');
});
});

allow any url for new request, but still reject non-http url in fetch
2016-05-25 11:19:16 -07:00
it('should support arbitrary url in Request constructor', function() {
url = 'anything';
var req = new Request(url);
expect(req.url).to.equal('anything');
});
clone method support
2016-03-19 03:06:33 -07:00
it('should support clone() method in Request constructor', function() {
url = base;
fix formdata support when you are trying to wrap the request
2016-03-23 00:02:04 -07:00
var body = resumer().queue('a=1').end();
body = body.pipe(new stream.PassThrough());
clone method support
2016-03-19 03:06:33 -07:00
var agent = new http.Agent();
var req = new Request(url, {
fix formdata support when you are trying to wrap the request
2016-03-23 00:02:04 -07:00
body: body
clone method support
2016-03-19 03:06:33 -07:00
, method: 'POST'
add basic support for redirect mode
2016-04-05 11:47:23 -07:00
, redirect: 'manual'
clone method support
2016-03-19 03:06:33 -07:00
, headers: {
b: '2'
}
, follow: 3
, compress: false
, agent: agent
});
var cl = req.clone();
expect(cl.url).to.equal(url);
expect(cl.method).to.equal('POST');
add basic support for redirect mode
2016-04-05 11:47:23 -07:00
expect(cl.redirect).to.equal('manual');
clone method support
2016-03-19 03:06:33 -07:00
expect(cl.headers.get('b')).to.equal('2');
expect(cl.follow).to.equal(3);
expect(cl.compress).to.equal(false);
expect(cl.method).to.equal('POST');
expect(cl.counter).to.equal(3);
expect(cl.agent).to.equal(agent);
fix formdata support when you are trying to wrap the request
2016-03-23 00:02:04 -07:00
// clone body shouldn't be the same body
expect(cl.body).to.not.equal(body);
clone method support
2016-03-19 03:06:33 -07:00
return fetch.Promise.all([cl.text(), req.text()]).then(function(results) {
expect(results[0]).to.equal('a=1');
expect(results[1]).to.equal('a=1');
});
});
add a much-requested buffer() method for convenience
2016-08-02 22:27:32 -07:00
it('should support text(), json() and buffer() method in Body constructor', function() {
fix coverage and remove duplicate tests
2016-03-19 00:11:16 -07:00
var body = new Body('a=1');
expect(body).to.have.property('text');
expect(body).to.have.property('json');
add a much-requested buffer() method for convenience
2016-08-02 22:27:32 -07:00
expect(body).to.have.property('buffer');
fix coverage and remove duplicate tests
2016-03-19 00:11:16 -07:00
});

check that FetchError is an instanceof Error
2016-04-05 10:54:20 -07:00
it('should create custom FetchError', function() {
var systemError = new Error('system');
systemError.code = 'ESOMEERROR';
var err = new FetchError('test message', 'test-error', systemError);
expect(err).to.be.an.instanceof(Error);
expect(err).to.be.an.instanceof(FetchError);
expect(err.name).to.equal('FetchError');
expect(err.message).to.equal('test message');
expect(err.type).to.equal('test-error');
expect(err.code).to.equal('ESOMEERROR');
expect(err.errno).to.equal('ESOMEERROR');
});

test case for Response ctor
2015-09-28 07:39:53 -07:00
it('should support https request', function() {
better test coverage
2015-01-27 09:00:53 -08:00
this.timeout(5000);
url = 'https://github.com/';
opts = {
method: 'HEAD'
};
return fetch(url, opts).then(function(res) {
expect(res.status).to.equal(200);
Add a convenience `ok` getter on `Response`
2015-01-27 15:41:48 -08:00
expect(res.ok).to.be.true;
better test coverage
2015-01-27 09:00:53 -08:00
});
});
Add failing test for the ability to set a custom header
2015-07-11 02:36:31 -07:00
basic http added
2015-01-26 02:15:07 -08:00
});