Increase coverage (#542)

source/normalize-arguments.js

@@ -169,10 +169,10 @@ module.exports = (url, options, defaults) => {
 
 			if (Reflect.has(error, 'headers') && Reflect.has(error.headers, 'retry-after') && retryAfterStatusCodes.has(error.statusCode)) {
 				let after = Number(error.headers['retry-after']);
-				if (is.number(after)) {
-					after *= 1000;
+				if (is.nan(after)) {
+					after = Date.parse(error.headers['retry-after']) - Date.now();
 				} else {
-					after = Math.max(Date.parse(error.headers['retry-after']) - Date.now(), 0);
+					after *= 1000;
 				}
 
 				if (after > options.gotRetry.maxRetryAfter) {

source/request-as-event-emitter.js

@@ -15,7 +15,7 @@ const {GotError, CacheError, UnsupportedProtocolError, MaxRedirectsError, Reques
 const getMethodRedirectCodes = new Set([300, 301, 302, 303, 304, 305, 307, 308]);
 const allMethodRedirectCodes = new Set([300, 303, 307, 308]);
 
-module.exports = (options = {}) => {
+module.exports = options => {
 	const emitter = new EventEmitter();
 	const requestUrl = options.href || (new URLGlobal(options.path, urlLib.format(options))).toString();
 	const redirects = [];
@@ -138,17 +138,17 @@ module.exports = (options = {}) => {
 	};
 
 	emitter.on('retry', (error, cb) => {
-		const backoff = options.gotRetry.retries(++retryTries, error);
+		let backoff;
+		try {
+			backoff = options.gotRetry.retries(++retryTries, error);
+		} catch (error) {
+			emitter.emit('error', error);
+			return;
+		}
 
 		if (backoff) {
 			retryCount++;
-			setTimeout(options => {
-				try {
-					get(options);
-				} catch (error2) {
-					emitter.emit('error', error2);
-				}
-			}, backoff, options);
+			setTimeout(get, backoff, options);
 			cb(true);
 			return;
 		}

test/error.js

@@ -27,6 +27,11 @@ test.before('setup', async () => {
 		response.end('body');
 	});
 
+	s.on('/no-status-message', (request, response) => {
+		response.writeHead(400, '');
+		response.end('body');
+	});
+
 	s.on('/body', async (request, response) => {
 		const body = await getStream(request);
 		response.end(body);
@@ -102,6 +107,12 @@ test('custom status message', async t => {
 	t.is(error.statusMessage, 'Something Exploded');
 });
 
+test('no status message is overriden by the default one', async t => {
+	const error = await t.throws(got(`${s.url}/no-status-message`));
+	t.is(error.statusCode, 400);
+	t.is(error.statusMessage, http.STATUS_CODES[400]);
+});
+
 test.serial('http.request error', async t => {
 	const stub = sinon.stub(http, 'request').callsFake(() => {
 		throw new TypeError('The header content contains invalid characters');

test/retry.js

@@ -8,6 +8,7 @@ let trys = 0;
 let knocks = 0;
 let fifth = 0;
 let lastTried413access = Date.now();
+let lastTried413TimestampAccess;
 
 const retryAfterOn413 = 2;
 const socketTimeout = 200;
@@ -54,6 +55,16 @@ test.before('setup', async () => {
 		response.end();
 	});
 
+	s.on('/413withTimestamp', (request, response) => {
+		const date = (new Date(Date.now() + (retryAfterOn413 * 1000))).toUTCString();
+
+		response.writeHead(413, {
+			'Retry-After': date
+		});
+		response.end(lastTried413TimestampAccess);
+		lastTried413TimestampAccess = date;
+	});
+
 	s.on('/413withoutRetryAfter', (request, response) => {
 		response.statusCode = 413;
 		response.end();
@@ -149,6 +160,15 @@ test('respect 413 Retry-After', async t => {
 	t.true(Number(body) >= retryAfterOn413 * 1000);
 });
 
+test('respect 413 Retry-After with RFC-1123 timestamp', async t => {
+	const {statusCode, body} = await got(`${s.url}/413withTimestamp`, {
+		throwHttpErrors: false,
+		retry: 1
+	});
+	t.is(statusCode, 413);
+	t.true(Date.now() >= Date.parse(body));
+});
+
 test('doesn\'t retry on 413 with empty statusCodes and methods', async t => {
 	const {statusCode, retryCount} = await got(`${s.url}/413`, {
 		throwHttpErrors: false,
@@ -193,8 +213,10 @@ test('retries on 503 without Retry-After header', async t => {
 test('doesn\'t retry on streams', async t => {
 	const stream = got.stream(s.url, {
 		timeout: 1,
-		retries: () => {
-			t.fail('Retries on streams');
+		retry: {
+			retries: () => {
+				t.fail('Retries on streams');
+			}
 		}
 	});
 	await t.throws(pEvent(stream, 'response'));
@@ -207,3 +229,34 @@ test('doesn\'t retry if Retry-After header is greater than maxRetryAfter', async
 	});
 	t.is(retryCount, 0);
 });
+
+test('doesn\'t retry when set to false', async t => {
+	const {statusCode, retryCount} = await got(`${s.url}/413`, {
+		throwHttpErrors: false,
+		retry: false
+	});
+	t.is(statusCode, 413);
+	t.is(retryCount, 0);
+});
+
+test('works when defaults.options.retry is not an object', async t => {
+	const instance = got.extend({
+		retry: 2
+	});
+
+	const {retryCount} = await instance(`${s.url}/413`, {
+		throwHttpErrors: false
+	});
+	t.is(retryCount, 0);
+});
+
+test('retry function can throw', async t => {
+	const error = 'Simple error';
+	await t.throws(got(`${s.url}/413`, {
+		retry: {
+			retries: () => {
+				throw new Error(error);
+			}
+		}
+	}), error);
+});

test/stream.js

@@ -2,6 +2,7 @@ import test from 'ava';
 import toReadableStream from 'to-readable-stream';
 import getStream from 'get-stream';
 import pEvent from 'p-event';
+import delay from 'delay';
 import is from '@sindresorhus/is';
 import got from '../source';
 import {createServer} from './helpers/server';
@@ -13,9 +14,10 @@ test.before('setup', async () => {
 
 	s.on('/', (request, response) => {
 		response.writeHead(200, {
-			unicorn: 'rainbow'
+			unicorn: 'rainbow',
+			'content-encoding': 'gzip'
 		});
-		response.end('ok');
+		response.end(Buffer.from('H4sIAAAAAAAA/8vPBgBH3dx5AgAAAA==', 'base64')); // 'ok'
 	});
 
 	s.on('/post', (request, response) => {
@@ -127,6 +129,38 @@ test('proxying headers works', async t => {
 
 	const {headers} = await got(server.url);
 	t.is(headers.unicorn, 'rainbow');
+	t.is(headers['content-encoding'], undefined);
 
 	await server.close();
 });
+
+test('skips proxying headers after server has sent them already', async t => {
+	const server = await createServer();
+
+	server.on('/', (request, response) => {
+		response.writeHead(200);
+		got.stream(s.url).pipe(response);
+	});
+
+	await server.listen(server.port);
+
+	const {headers} = await got(server.url);
+	t.is(headers.unicorn, undefined);
+
+	await server.close();
+});
+
+test('throws when trying to proxy through a closed stream', async t => {
+	const server = await createServer();
+
+	server.on('/', async (request, response) => {
+		const stream = got.stream(s.url);
+		await delay(1000);
+		t.throws(() => stream.pipe(response));
+		response.end();
+	});
+
+	await server.listen(server.port);
+	await got(server.url);
+	await server.close();
+});

test/timeout.js

@@ -24,8 +24,8 @@ const slowDataStream = () => {
 	return slowStream;
 };
 
-const requestDelay = 250;
-const requestTimeout = requestDelay - 10;
+const requestDelay = 500;
+const requestTimeout = requestDelay - 20;
 
 const errorMatcher = {
 	instanceOf: got.TimeoutError,

test/unix-socket.js

@@ -41,4 +41,8 @@ if (process.platform !== 'win32') {
 		const url = format('unix:%s:%s', socketPath, '/foo:bar');
 		t.is((await got(url)).body, 'ok');
 	});
+
+	test('throws on invalid URL', async t => {
+		await t.throws(got('unix:'));
+	});
 }