Fix CI

Author: sindresorhus

maintainer.md

@@ -0,0 +1,5 @@
+# Notes
+
+## Testing
+
+Never use `nock` in tests. nock v14 uses `@mswjs/interceptors` under the hood and auto-activates MSW interceptors for the entire process on import — affecting all HTTP requests, even in tests that don't use nock at all. Use real local test servers via `withServer` / `withServer.exec` instead.

package.json

@@ -88,7 +88,6 @@
 		"expect-type": "^1.3.0",
 		"express": "^5.2.1",
 		"get-stream": "^9.0.1",
-		"nock": "^14.0.11",
 		"node-fetch": "^3.3.2",
 		"np": "^11.0.2",
 		"p-event": "^7.1.0",

source/core/index.ts

@@ -947,6 +947,12 @@ export default class Request extends Duplex implements RequestEvents<Request> {
 			}
 		});
 
+		const noPipeCookieJarRawBodyPromise = this._noPipe
+			&& is.object(options.cookieJar)
+			&& !(response.headers.location && redirectCodes.has(statusCode))
+			? this._setRawBody(response)
+			: undefined;
+
 		const rawCookies = response.headers['set-cookie'];
 		if (is.object(options.cookieJar) && rawCookies) {
 			let promises: Array<Promise<unknown>> = rawCookies.map(async (rawCookie: string) => (options.cookieJar as PromiseCookieJar).setCookie(rawCookie, url!.toString()));
@@ -1109,7 +1115,14 @@ export default class Request extends Duplex implements RequestEvents<Request> {
 		}
 
 		// Set up end listener AFTER redirect check to avoid emitting progress for redirect responses
-		response.once('end', () => {
+		let responseEndHandled = false;
+		const handleResponseEnd = () => {
+			if (responseEndHandled) {
+				return;
+			}
+
+			responseEndHandled = true;
+
 			// Validate content-length if it was provided
 			// Per RFC 9112: "If the sender closes the connection before the indicated number
 			// of octets are received, the recipient MUST consider the message to be incomplete"
@@ -1130,7 +1143,9 @@ export default class Request extends Duplex implements RequestEvents<Request> {
 			});
 
 			this.push(null);
-		});
+		};
+
+		response.once('end', handleResponseEnd);
 
 		this.emit('downloadProgress', this.downloadProgress);
 
@@ -1149,7 +1164,14 @@ export default class Request extends Duplex implements RequestEvents<Request> {
 		});
 
 		if (this._noPipe) {
-			const success = await this._setRawBody();
+			const captureFromResponse = response.readableEnded || noPipeCookieJarRawBodyPromise !== undefined;
+			const success = noPipeCookieJarRawBodyPromise
+				? await noPipeCookieJarRawBodyPromise
+				: await this._setRawBody(captureFromResponse ? response : this);
+
+			if (captureFromResponse) {
+				handleResponseEnd();
+			}
 
 			if (success) {
 				this.emit('response', response);
@@ -1192,10 +1214,6 @@ export default class Request extends Duplex implements RequestEvents<Request> {
 	}
 
 	private async _setRawBody(from: Readable = this): Promise<boolean> {
-		if (from.readableEnded) {
-			return false;
-		}
-
 		try {
 			// Errors are emitted via the `error` event
 			const fromArray = await from.toArray();
@@ -1212,6 +1230,9 @@ export default class Request extends Duplex implements RequestEvents<Request> {
 				&& this.response
 			) {
 				this.response.rawBody = rawBody;
+				if (from !== this) {
+					this._downloadedSize = rawBody.byteLength;
+				}
 
 				if (shouldUseIncrementalDecodedBody) {
 					try {
@@ -1305,7 +1326,9 @@ export default class Request extends Duplex implements RequestEvents<Request> {
 			}
 
 			/*
-			Transient write errors (EPIPE, ECONNRESET) often fire during redirects when the server closes the connection after sending the redirect response. Defer by one microtask to let the response event make the request stale.
+			Transient write errors (EPIPE, ECONNRESET) often fire during redirects when the
+			server closes the connection after sending the redirect response. Defer by one
+			microtask to let the response event make the request stale.
 			*/
 			if (isTransientWriteError(error)) {
 				queueMicrotask(() => {
@@ -1419,25 +1442,28 @@ export default class Request extends Duplex implements RequestEvents<Request> {
 		const isInitialRequest = currentRequest === this;
 
 		(async () => {
+			let request: ClientRequest | undefined;
+
 			try {
-				const request = isInitialRequest ? this._request : currentRequest as ClientRequest;
+				request = isInitialRequest ? this._request : currentRequest as ClientRequest;
+				const activeRequest = request;
 
-				if (!request) {
+				if (!activeRequest) {
 					if (isInitialRequest) {
 						super.end();
 					}
 
 					return;
 				}
 
-				if (request.destroyed) {
+				if (activeRequest.destroyed) {
 					return;
 				}
 
-				await this._writeChunksToRequest(buffer, request);
+				await this._writeChunksToRequest(buffer, activeRequest);
 
-				if (this._isRequestStale(request)) {
-					this._finalizeStaleChunkedWrite(request, isInitialRequest);
+				if (this._isRequestStale(activeRequest)) {
+					this._finalizeStaleChunkedWrite(activeRequest, isInitialRequest);
 					return;
 				}
 
@@ -1447,25 +1473,54 @@ export default class Request extends Duplex implements RequestEvents<Request> {
 				}
 
 				await new Promise<void>((resolve, reject) => {
-					request.end((error?: Error | null) => { // eslint-disable-line @typescript-eslint/no-restricted-types
+					activeRequest.end((error?: Error | null) => { // eslint-disable-line @typescript-eslint/no-restricted-types
 						if (error) {
 							reject(error);
 							return;
 						}
 
-						if (this._request === request && !request.destroyed) {
-							this._emitUploadComplete(request);
+						if (this._request === activeRequest && !activeRequest.destroyed) {
+							this._emitUploadComplete(activeRequest);
 						}
 
 						resolve();
 					});
 				});
 			} catch (error: unknown) {
+				const normalizedError = normalizeError(error);
+
+				// Transient write errors (EPIPE, ECONNRESET) are handled by the request-level
+				// error and close handlers. For initial redirected writes, still finalize
+				// writable state once the stale transition becomes observable.
+				if (isTransientWriteError(normalizedError)) {
+					if (isInitialRequest && request) {
+						const initialRequest = request;
+						let didFinalize = false;
+						const finalizeIfStale = () => {
+							if (didFinalize || !this._isRequestStale(initialRequest)) {
+								return;
+							}
+
+							didFinalize = true;
+							this._finalizeStaleChunkedWrite(initialRequest, true);
+						};
+
+						finalizeIfStale();
+
+						if (!didFinalize) {
+							initialRequest.once('response', finalizeIfStale);
+							queueMicrotask(finalizeIfStale);
+						}
+					}
+
+					return;
+				}
+
 				if (!isInitialRequest && this._isRequestStale(currentRequest as ClientRequest)) {
 					return;
 				}
 
-				this._beforeError(normalizeError(error));
+				this._beforeError(normalizedError);
 			}
 		})();
 	}
@@ -1716,7 +1771,8 @@ export default class Request extends Duplex implements RequestEvents<Request> {
 
 		// Set cookies
 		if (cookieJar) {
-			const cookieString: string = await cookieJar.getCookieString(options.url!.toString());
+			let cookieString = '';
+			cookieString = await cookieJar.getCookieString(options.url!.toString());
 
 			if (is.nonEmptyString(cookieString)) {
 				options.setInternalHeader('cookie', cookieString);

test/cache.ts

@@ -8,7 +8,6 @@ import test from 'ava';
 import {pEvent} from 'p-event';
 import getStream from 'get-stream';
 import type {Handler} from 'express';
-import nock from 'nock';
 import CacheableLookup from 'cacheable-lookup';
 import delay from 'delay';
 import got, {CacheError, type Response} from '../source/index.js';
@@ -431,11 +430,19 @@ test('http-cache-semantics typings', t => {
 	t.is(instance.defaults.options.cacheOptions.shared, false);
 });
 
-test('allows internal modifications', async t => {
-	nock('http://example.com').get('/test').reply(401);
-	nock('http://example.com').get('/test').reply(200, JSON.stringify({
-		wat: ['123'],
-	}));
+test('allows internal modifications', withServer, async (t, server, got) => {
+	let requestCount = 0;
+
+	server.get('/test', (_request, response) => {
+		requestCount++;
+		if (requestCount === 1) {
+			response.writeHead(401);
+			response.end();
+		} else {
+			response.writeHead(200);
+			response.end(JSON.stringify({wat: ['123']}));
+		}
+	});
 
 	const client = got.extend({
 		cache: new Map(),
@@ -452,7 +459,7 @@ test('allows internal modifications', async t => {
 		},
 	});
 
-	await t.notThrowsAsync(client.get('http://example.com/test'));
+	await t.notThrowsAsync(client.get('test'));
 });
 
 test('response.complete is true when using keepalive agent', withServer, async (t, server, got) => {

test/cookies.ts

@@ -2,7 +2,6 @@ import net from 'node:net';
 import test from 'ava';
 import * as toughCookie from 'tough-cookie';
 import delay from 'delay';
-import nock from 'nock';
 import got, {RequestError} from '../source/index.js';
 import withServer from './helpers/with-server.js';
 
@@ -206,24 +205,26 @@ test('throws on invalid `options.cookieJar.getCookieString`', async t => {
 	});
 });
 
-test('cookies are cleared when redirecting to a different hostname (no cookieJar)', withServer, async (t, server, got) => {
-	server.get('/', (_request, response) => {
-		response.writeHead(302, {
-			location: 'https://example.com/',
+test('cookies are cleared when redirecting to a different hostname (no cookieJar)', withServer, async (t, server1, got) => {
+	await withServer.exec(t, async (t, server2) => {
+		server1.get('/', (_request, response) => {
+			response.writeHead(302, {
+				location: `http://localhost:${server2.port}/`,
+			});
+			response.end();
 		});
-		response.end();
-	});
 
-	nock('https://example.com').get('/').reply(200, function () {
-		return JSON.stringify({headers: this.req.headers});
-	});
+		server2.get('/', (request, response) => {
+			response.end(JSON.stringify({headers: request.headers}));
+		});
 
-	const {headers} = await got('', {
-		headers: {
-			cookie: 'foo=bar',
-			'user-agent': 'custom',
-		},
-	}).json<{headers: Record<string, string | undefined>}>();
-	t.is(headers.cookie, undefined);
-	t.is(headers['user-agent'], 'custom');
+		const {headers} = await got('', {
+			headers: {
+				cookie: 'foo=bar',
+				'user-agent': 'custom',
+			},
+		}).json<{headers: Record<string, string | undefined>}>();
+		t.is(headers.cookie, undefined);
+		t.is(headers['user-agent'], 'custom');
+	});
 });