Throw if request canceled and received incomplete response

source/as-promise.ts

@@ -40,6 +40,11 @@ export default function asPromise(options: Options) {
 				return;
 			}
 
+			if (response.canceled()) {
+				// Canceled while downloading - will throw a CancelError or TimeoutError
+				return;
+			}
+
 			const limitStatusCode = options.followRedirect ? 299 : 399;
 
 			response.body = data;

source/as-stream.ts

@@ -23,7 +23,15 @@ export default function asStream(options: MergedOptions) {
 	const emitter = requestAsEventEmitter(options, input);
 
 	// Cancels the request
-	proxy._destroy = emitter.abort;
+	proxy._destroy = (error, callback) => {
+		// Stop transmitting data,
+		// so the stream won't have an `end` event.
+		output.destroy();
+
+		// Abort safely
+		emitter.abort();
+		callback(error);
+	};
 
 	emitter.on('response', (response: Response) => {
 		const {statusCode} = response;

source/request-as-event-emitter.ts

@@ -26,10 +26,14 @@ export interface RequestAsEventEmitter extends EventEmitter {
 	abort: () => void;
 }
 
+export interface Abortable {
+	abort: () => void;
+}
+
 export default (options, input?: TransformStream) => {
 	const emitter = new EventEmitter() as RequestAsEventEmitter;
 	const redirects = [] as string[];
-	let currentRequest: http.ClientRequest;
+	let currentRequest: http.ClientRequest | Abortable;
 	let requestUrl: string;
 	let redirectString: string;
 	let uploadBodySize: number | undefined;
@@ -120,6 +124,21 @@ export default (options, input?: TransformStream) => {
 					gotOptions: options
 				};
 
+				// Cached requests don't have the request object (so we can't do `request.aborted`)
+				// so we need to create our own `canceled` property.
+				if (response.fromCache) {
+					response.canceled = () => false;
+
+					currentRequest = {
+						abort: () => {
+							response.canceled = () => true;
+							response.destroy();
+						}
+					};
+				} else {
+					response.canceled = () => response.req.aborted;
+				}
+
 				const rawCookies = response.headers['set-cookie'];
 				if (options.cookieJar && rawCookies) {
 					await Promise.all(rawCookies.map(rawCookie => setCookie(rawCookie, response.url)));

test/timeout.ts

@@ -449,3 +449,35 @@ test('no memory leak when using socket timeout and keepalive agent', withServer,
 
 	t.is(socket.listenerCount('timeout'), 0);
 });
+
+test('throws on incomplete (canceled) response - promise', withServer, async (t, server, got) => {
+	server.get('/', downloadHandler);
+
+	await t.throwsAsync(got({
+		timeout: {request: 500}
+	}), got.TimeoutError);
+});
+
+test('throws on incomplete (canceled) response - promise #2', withServer, async (t, server, got) => {
+	server.get('/', downloadHandler);
+
+	const promise = got('').on('response', () => {
+		setTimeout(() => promise.cancel(), 500);
+	});
+
+	await t.throwsAsync(promise, got.CancelError);
+});
+
+test('throws on incomplete (canceled) response - stream', withServer, async (t, server, got) => {
+	server.get('/', downloadHandler);
+
+	const errorString = 'Foobar';
+
+	const stream = got.stream('').on('response', () => {
+		setTimeout(() => stream.destroy(new Error(errorString)), 500);
+	});
+
+	await t.throwsAsync(getStream(stream), errorString);
+});
+
+test.todo('throws on incomplete (canceled) response - cached request');