import { net, session, ClientRequest, ClientRequestConstructorOptions, utilityProcess } from 'electron/main';

import { expect } from 'chai';

import { once } from 'node:events';
import * as fs from 'node:fs';
import * as http from 'node:http';
import * as http2 from 'node:http2';
import * as path from 'node:path';
import { setTimeout } from 'node:timers/promises';

import {
  collectStreamBody,
  collectStreamBodyBuffer,
  getResponse,
  kOneKiloByte,
  kOneMegaByte,
  randomBuffer,
  randomString,
  respondNTimes,
  respondOnce
} from './lib/net-helpers';
import { listen, defer } from './lib/spec-helpers';

const utilityFixturePath = path.resolve(__dirname, 'fixtures', 'api', 'utility-process', 'api-net-spec.js');
const fixturesPath = path.resolve(__dirname, 'fixtures');

async function itUtility(name: string, fn?: Function, args?: { [key: string]: any }) {
  it(`${name} in utility process`, async () => {
    const child = utilityProcess.fork(utilityFixturePath, [], {
      execArgv: ['--expose-gc']
    });
    if (fn) {
      child.postMessage({ fn: `(${fn})()`, args });
    } else {
      child.postMessage({ fn: '(() => {})()', args });
    }
    const [data] = await once(child, 'message');
    expect(data.ok).to.be.true(data.message);
    // Cleanup.
    const [code] = await once(child, 'exit');
    expect(code).to.equal(0);
  });
}

// eslint-disable-next-line @typescript-eslint/no-unused-vars
async function itIgnoringArgs(name: string, fn?: Mocha.Func | Mocha.AsyncFunc, args?: { [key: string]: any }) {
  it(name, fn);
}

describe('net module', () => {
  beforeEach(() => {
    respondNTimes.routeFailure = false;
  });
  afterEach(async function () {
    if (respondNTimes.routeFailure && this.test) {
      if (!this.test.isFailed()) {
        throw new Error(
          'Failing this test due an unhandled error in the respondOnce route handler, check the logs above for the actual error'
        );
      }
    }
  });

  let http2URL: string;

  const certPath = path.join(fixturesPath, 'certificates');
  const h2server = http2.createSecureServer(
    {
      key: fs.readFileSync(path.join(certPath, 'server.key')),
      cert: fs.readFileSync(path.join(certPath, 'server.pem'))
    },
    async (req, res) => {
      if (req.method === 'POST') {
        const chunks = [];
        for await (const chunk of req) chunks.push(chunk);
        res.end(Buffer.concat(chunks).toString('utf8'));
      } else if (req.method === 'GET' && req.headers[':path'] === '/get') {
        res.end(
          JSON.stringify({
            headers: req.headers
          })
        );
      } else {
        res.end('<html></html>');
      }
    }
  );

  before(async () => {
    http2URL = (await listen(h2server)).url + '/';
  });

  after(() => {
    h2server.close();
  });

  for (const test of [itIgnoringArgs, itUtility]) {
    describe('HTTP basics', () => {
      test('should be able to issue a basic GET request', async () => {
        const serverUrl = await respondOnce.toSingleURL((request, response) => {
          expect(request.method).to.equal('GET');
          response.end();
        });
        const urlRequest = net.request(serverUrl);
        const response = await getResponse(urlRequest);
        expect(response.statusCode).to.equal(200);
        await collectStreamBody(response);
      });

      test('should be able to issue a basic POST request', async () => {
        const serverUrl = await respondOnce.toSingleURL((request, response) => {
          expect(request.method).to.equal('POST');
          response.end();
        });
        const urlRequest = net.request({
          method: 'POST',
          url: serverUrl
        });
        const response = await getResponse(urlRequest);
        expect(response.statusCode).to.equal(200);
        await collectStreamBody(response);
      });

      test('should fetch correct data in a GET request', async () => {
        const expectedBodyData = 'Hello World!';
        const serverUrl = await respondOnce.toSingleURL((request, response) => {
          expect(request.method).to.equal('GET');
          response.end(expectedBodyData);
        });
        const urlRequest = net.request(serverUrl);
        const response = await getResponse(urlRequest);
        expect(response.statusCode).to.equal(200);
        const body = await collectStreamBody(response);
        expect(body).to.equal(expectedBodyData);
      });

      test('should post the correct data in a POST request', async () => {
        const bodyData = 'Hello World!';
        let postedBodyData: string = '';
        const serverUrl = await respondOnce.toSingleURL(async (request, response) => {
          postedBodyData = await collectStreamBody(request);
          response.end();
        });
        const urlRequest = net.request({
          method: 'POST',
          url: serverUrl
        });
        urlRequest.write(bodyData);
        const response = await getResponse(urlRequest);
        expect(response.statusCode).to.equal(200);
        expect(postedBodyData).to.equal(bodyData);
      });

      test('a 307 redirected POST request preserves the body', async () => {
        const bodyData = 'Hello World!';
        let postedBodyData: string = '';
        let methodAfterRedirect: string | undefined;
        const serverUrl = await respondNTimes.toRoutes(
          {
            '/redirect': (req, res) => {
              res.statusCode = 307;
              res.setHeader('location', serverUrl);
              return res.end();
            },
            '/': async (req, res) => {
              methodAfterRedirect = req.method;
              postedBodyData = await collectStreamBody(req);
              res.end();
            }
          },
          2
        );
        const urlRequest = net.request({
          method: 'POST',
          url: serverUrl + '/redirect'
        });
        urlRequest.write(bodyData);
        const response = await getResponse(urlRequest);
        expect(response.statusCode).to.equal(200);
        await collectStreamBody(response);
        expect(methodAfterRedirect).to.equal('POST');
        expect(postedBodyData).to.equal(bodyData);
      });

      test('a 302 redirected POST request DOES NOT preserve the body', async () => {
        const bodyData = 'Hello World!';
        let postedBodyData: string = '';
        let methodAfterRedirect: string | undefined;
        const serverUrl = await respondNTimes.toRoutes(
          {
            '/redirect': (req, res) => {
              res.statusCode = 302;
              res.setHeader('location', serverUrl);
              return res.end();
            },
            '/': async (req, res) => {
              methodAfterRedirect = req.method;
              postedBodyData = await collectStreamBody(req);
              res.end();
            }
          },
          2
        );
        const urlRequest = net.request({
          method: 'POST',
          url: serverUrl + '/redirect'
        });
        urlRequest.write(bodyData);
        const response = await getResponse(urlRequest);
        expect(response.statusCode).to.equal(200);
        await collectStreamBody(response);
        expect(methodAfterRedirect).to.equal('GET');
        expect(postedBodyData).to.equal('');
      });

      test('should support chunked encoding', async () => {
        let receivedRequest: http.IncomingMessage = null as any;
        const serverUrl = await respondOnce.toSingleURL((request, response) => {
          response.statusCode = 200;
          response.statusMessage = 'OK';
          response.chunkedEncoding = true;
          receivedRequest = request;
          request.on('data', (chunk: Buffer) => {
            response.write(chunk);
          });
          request.on('end', (chunk: Buffer) => {
            response.end(chunk);
          });
        });
        const urlRequest = net.request({
          method: 'POST',
          url: serverUrl
        });

        let chunkIndex = 0;
        const chunkCount = 100;
        let sent = Buffer.alloc(0);

        urlRequest.chunkedEncoding = true;
        while (chunkIndex < chunkCount) {
          chunkIndex += 1;
          const chunk = randomBuffer(kOneKiloByte);
          sent = Buffer.concat([sent, chunk]);
          urlRequest.write(chunk);
        }

        const response = await getResponse(urlRequest);
        expect(receivedRequest.method).to.equal('POST');
        expect(receivedRequest.headers['transfer-encoding']).to.equal('chunked');
        expect(receivedRequest.headers['content-length']).to.equal(undefined);
        expect(response.statusCode).to.equal(200);
        const received = await collectStreamBodyBuffer(response);
        expect(sent.equals(received)).to.be.true();
        expect(chunkIndex).to.be.equal(chunkCount);
      });

      for (const extraOptions of [
        {},
        { credentials: 'include' },
        { useSessionCookies: false, credentials: 'include' }
      ] as ClientRequestConstructorOptions[]) {
        describe(`authentication when ${JSON.stringify(extraOptions)}`, () => {
          test(
            'should emit the login event when 401',
            async () => {
              const [user, pass] = ['user', 'pass'];
              const serverUrl = await respondOnce.toSingleURL((request, response) => {
                if (!request.headers.authorization) {
                  return response.writeHead(401, { 'WWW-Authenticate': 'Basic realm="Foo"' }).end();
                }
                response.writeHead(200).end('ok');
              });
              let loginAuthInfo: Electron.AuthInfo;
              const request = net.request({ method: 'GET', url: serverUrl, ...extraOptions });
              request.on('login', (authInfo, cb) => {
                loginAuthInfo = authInfo;
                cb(user, pass);
              });
              const response = await getResponse(request);
              expect(response.statusCode).to.equal(200);
              expect(loginAuthInfo!.realm).to.equal('Foo');
              expect(loginAuthInfo!.scheme).to.equal('basic');
            },
            { extraOptions }
          );

          test(
            'should receive 401 response when cancelling authentication',
            async () => {
              const serverUrl = await respondOnce.toSingleURL((request, response) => {
                if (!request.headers.authorization) {
                  response.writeHead(401, { 'WWW-Authenticate': 'Basic realm="Foo"' });
                  response.end('unauthenticated');
                } else {
                  response.writeHead(200).end('ok');
                }
              });
              const request = net.request({ method: 'GET', url: serverUrl, ...extraOptions });
              request.on('login', (authInfo, cb) => {
                cb();
              });
              const response = await getResponse(request);
              const body = await collectStreamBody(response);
              expect(response.statusCode).to.equal(401);
              expect(body).to.equal('unauthenticated');
            },
            { extraOptions }
          );

          test(
            'should upload body when 401',
            async () => {
              const [user, pass] = ['user', 'pass'];
              const serverUrl = await respondOnce.toSingleURL((request, response) => {
                if (!request.headers.authorization) {
                  return response.writeHead(401, { 'WWW-Authenticate': 'Basic realm="Foo"' }).end();
                }
                response.writeHead(200);
                request.on('data', (chunk) => response.write(chunk));
                request.on('end', () => response.end());
              });
              const requestData = randomString(kOneKiloByte);
              const request = net.request({ method: 'GET', url: serverUrl, ...extraOptions });
              request.on('login', (authInfo, cb) => {
                cb(user, pass);
              });
              request.write(requestData);
              const response = await getResponse(request);
              const responseData = await collectStreamBody(response);
              expect(responseData).to.equal(requestData);
            },
            { extraOptions }
          );
        });
      }

      describe('authentication when {"credentials":"omit"}', () => {
        test('should not emit the login event when 401', async () => {
          const serverUrl = await respondOnce.toSingleURL((request, response) => {
            if (!request.headers.authorization) {
              return response.writeHead(401, { 'WWW-Authenticate': 'Basic realm="Foo"' }).end();
            }
            response.writeHead(200).end('ok');
          });
          const request = net.request({ method: 'GET', url: serverUrl, credentials: 'omit' });
          request.on('login', () => {
            expect.fail('unexpected login event');
          });
          const response = await getResponse(request);
          expect(response.statusCode).to.equal(401);
          expect(response.headers['www-authenticate']).to.equal('Basic realm="Foo"');
        });
      });
    });

    describe('ClientRequest API', () => {
      test('request/response objects should emit expected events', async () => {
        const bodyData = randomString(kOneKiloByte);
        const serverUrl = await respondOnce.toSingleURL((request, response) => {
          response.end(bodyData);
        });

        const urlRequest = net.request(serverUrl);
        // request close event
        const closePromise = once(urlRequest, 'close');
        // request finish event
        const finishPromise = once(urlRequest, 'close');
        // request "response" event
        const response = await getResponse(urlRequest);
        response.on('error', (error: Error) => {
          expect(error).to.be.an('Error');
        });
        const statusCode = response.statusCode;
        expect(statusCode).to.equal(200);
        // response data event
        // respond end event
        const body = await collectStreamBody(response);
        expect(body).to.equal(bodyData);
        urlRequest.on('error', (error) => {
          expect(error).to.be.an('Error');
        });
        await Promise.all([closePromise, finishPromise]);
      });

      test('should be able to set a custom HTTP request header before first write', async () => {
        const customHeaderName = 'Some-Custom-Header-Name';
        const customHeaderValue = 'Some-Customer-Header-Value';
        const serverUrl = await respondOnce.toSingleURL((request, response) => {
          expect(request.headers[customHeaderName.toLowerCase()]).to.equal(customHeaderValue);
          response.statusCode = 200;
          response.statusMessage = 'OK';
          response.end();
        });
        const urlRequest = net.request(serverUrl);
        urlRequest.setHeader(customHeaderName, customHeaderValue);
        expect(urlRequest.getHeader(customHeaderName)).to.equal(customHeaderValue);
        expect(urlRequest.getHeader(customHeaderName.toLowerCase())).to.equal(customHeaderValue);
        urlRequest.write('');
        expect(urlRequest.getHeader(customHeaderName)).to.equal(customHeaderValue);
        expect(urlRequest.getHeader(customHeaderName.toLowerCase())).to.equal(customHeaderValue);
        const response = await getResponse(urlRequest);
        expect(response.statusCode).to.equal(200);
        await collectStreamBody(response);
      });

      test('should be able to set a non-string object as a header value', async () => {
        const customHeaderName = 'Some-Integer-Value';
        const customHeaderValue = 900;
        const serverUrl = await respondOnce.toSingleURL((request, response) => {
          expect(request.headers[customHeaderName.toLowerCase()]).to.equal(customHeaderValue.toString());
          response.statusCode = 200;
          response.statusMessage = 'OK';
          response.end();
        });

        const urlRequest = net.request(serverUrl);
        urlRequest.setHeader(customHeaderName, customHeaderValue as any);
        expect(urlRequest.getHeader(customHeaderName)).to.equal(customHeaderValue);
        expect(urlRequest.getHeader(customHeaderName.toLowerCase())).to.equal(customHeaderValue);
        urlRequest.write('');
        expect(urlRequest.getHeader(customHeaderName)).to.equal(customHeaderValue);
        expect(urlRequest.getHeader(customHeaderName.toLowerCase())).to.equal(customHeaderValue);
        const response = await getResponse(urlRequest);
        expect(response.statusCode).to.equal(200);
        await collectStreamBody(response);
      });

      test('should not change the case of header name', async () => {
        const customHeaderName = 'X-Header-Name';
        const customHeaderValue = 'value';
        const serverUrl = await respondOnce.toSingleURL((request, response) => {
          expect(request.headers[customHeaderName.toLowerCase()]).to.equal(customHeaderValue.toString());
          expect(request.rawHeaders.includes(customHeaderName)).to.equal(true);
          response.statusCode = 200;
          response.statusMessage = 'OK';
          response.end();
        });

        const urlRequest = net.request(serverUrl);
        urlRequest.setHeader(customHeaderName, customHeaderValue);
        expect(urlRequest.getHeader(customHeaderName)).to.equal(customHeaderValue);
        urlRequest.write('');
        const response = await getResponse(urlRequest);
        expect(response.statusCode).to.equal(200);
        await collectStreamBody(response);
      });

      test('should not be able to set a custom HTTP request header after first write', async () => {
        const customHeaderName = 'Some-Custom-Header-Name';
        const customHeaderValue = 'Some-Customer-Header-Value';
        const serverUrl = await respondOnce.toSingleURL((request, response) => {
          expect(request.headers[customHeaderName.toLowerCase()]).to.equal(undefined);
          response.statusCode = 200;
          response.statusMessage = 'OK';
          response.end();
        });
        const urlRequest = net.request(serverUrl);
        urlRequest.write('');
        expect(() => {
          urlRequest.setHeader(customHeaderName, customHeaderValue);
        }).to.throw();
        expect(urlRequest.getHeader(customHeaderName)).to.equal(undefined);
        const response = await getResponse(urlRequest);
        expect(response.statusCode).to.equal(200);
        await collectStreamBody(response);
      });

      test('should be able to remove a custom HTTP request header before first write', async () => {
        const customHeaderName = 'Some-Custom-Header-Name';
        const customHeaderValue = 'Some-Customer-Header-Value';
        const serverUrl = await respondOnce.toSingleURL((request, response) => {
          expect(request.headers[customHeaderName.toLowerCase()]).to.equal(undefined);
          response.statusCode = 200;
          response.statusMessage = 'OK';
          response.end();
        });
        const urlRequest = net.request(serverUrl);
        urlRequest.setHeader(customHeaderName, customHeaderValue);
        expect(urlRequest.getHeader(customHeaderName)).to.equal(customHeaderValue);
        urlRequest.removeHeader(customHeaderName);
        expect(urlRequest.getHeader(customHeaderName)).to.equal(undefined);
        urlRequest.write('');
        const response = await getResponse(urlRequest);
        expect(response.statusCode).to.equal(200);
        await collectStreamBody(response);
      });

      test('should not be able to remove a custom HTTP request header after first write', async () => {
        const customHeaderName = 'Some-Custom-Header-Name';
        const customHeaderValue = 'Some-Customer-Header-Value';
        const serverUrl = await respondOnce.toSingleURL((request, response) => {
          expect(request.headers[customHeaderName.toLowerCase()]).to.equal(customHeaderValue);
          response.statusCode = 200;
          response.statusMessage = 'OK';
          response.end();
        });
        const urlRequest = net.request(serverUrl);
        urlRequest.setHeader(customHeaderName, customHeaderValue);
        expect(urlRequest.getHeader(customHeaderName)).to.equal(customHeaderValue);
        urlRequest.write('');
        expect(() => {
          urlRequest.removeHeader(customHeaderName);
        }).to.throw();
        expect(urlRequest.getHeader(customHeaderName)).to.equal(customHeaderValue);
        const response = await getResponse(urlRequest);
        expect(response.statusCode).to.equal(200);
        await collectStreamBody(response);
      });

      test('should keep the order of headers', async () => {
        const customHeaderNameA = 'X-Header-100';
        const customHeaderNameB = 'X-Header-200';
        const serverUrl = await respondOnce.toSingleURL((request, response) => {
          const headerNames = Array.from(Object.keys(request.headers));
          const headerAIndex = headerNames.indexOf(customHeaderNameA.toLowerCase());
          const headerBIndex = headerNames.indexOf(customHeaderNameB.toLowerCase());
          expect(headerBIndex).to.be.below(headerAIndex);
          response.statusCode = 200;
          response.statusMessage = 'OK';
          response.end();
        });

        const urlRequest = net.request(serverUrl);
        urlRequest.setHeader(customHeaderNameB, 'b');
        urlRequest.setHeader(customHeaderNameA, 'a');
        const response = await getResponse(urlRequest);
        expect(response.statusCode).to.equal(200);
        await collectStreamBody(response);
      });

      test('should be able to receive cookies', async () => {
        const cookie = ['cookie1', 'cookie2'];
        const serverUrl = await respondOnce.toSingleURL((request, response) => {
          response.statusCode = 200;
          response.statusMessage = 'OK';
          response.setHeader('set-cookie', cookie);
          response.end();
        });
        const urlRequest = net.request(serverUrl);
        const response = await getResponse(urlRequest);
        expect(response.headers['set-cookie']).to.have.same.members(cookie);
      });

      test('should be able to receive content-type', async () => {
        const contentType = 'mime/test; charset=test';
        const serverUrl = await respondOnce.toSingleURL((request, response) => {
          response.statusCode = 200;
          response.statusMessage = 'OK';
          response.setHeader('content-type', contentType);
          response.end();
        });
        const urlRequest = net.request(serverUrl);
        const response = await getResponse(urlRequest);
        expect(response.headers['content-type']).to.equal(contentType);
      });

      describe('when {"credentials":"omit"}', () => {
        test('should not send cookies');
        test('should not store cookies');
      });

      test('should set sec-fetch-site to same-origin for request from same origin', async () => {
        const serverUrl = await respondOnce.toSingleURL((request, response) => {
          expect(request.headers['sec-fetch-site']).to.equal('same-origin');
          response.statusCode = 200;
          response.statusMessage = 'OK';
          response.end();
        });
        const urlRequest = net.request({
          url: serverUrl,
          origin: serverUrl
        });
        await collectStreamBody(await getResponse(urlRequest));
      });

      test('should set sec-fetch-site to same-origin for request with the same origin header', async () => {
        const serverUrl = await respondOnce.toSingleURL((request, response) => {
          expect(request.headers['sec-fetch-site']).to.equal('same-origin');
          response.statusCode = 200;
          response.statusMessage = 'OK';
          response.end();
        });
        const urlRequest = net.request({
          url: serverUrl
        });
        urlRequest.setHeader('Origin', serverUrl);
        await collectStreamBody(await getResponse(urlRequest));
      });

      test('should set sec-fetch-site to cross-site for request from other origin', async () => {
        const serverUrl = await respondOnce.toSingleURL((request, response) => {
          expect(request.headers['sec-fetch-site']).to.equal('cross-site');
          response.statusCode = 200;
          response.statusMessage = 'OK';
          response.end();
        });
        const urlRequest = net.request({
          url: serverUrl,
          origin: 'https://not-exists.com'
        });
        await collectStreamBody(await getResponse(urlRequest));
      });

      test('should not send sec-fetch-user header by default', async () => {
        const serverUrl = await respondOnce.toSingleURL((request, response) => {
          expect(request.headers).not.to.have.property('sec-fetch-user');
          response.statusCode = 200;
          response.statusMessage = 'OK';
          response.end();
        });
        const urlRequest = net.request({
          url: serverUrl
        });
        await collectStreamBody(await getResponse(urlRequest));
      });

      test('should set sec-fetch-user to ?1 if requested', async () => {
        const serverUrl = await respondOnce.toSingleURL((request, response) => {
          expect(request.headers['sec-fetch-user']).to.equal('?1');
          response.statusCode = 200;
          response.statusMessage = 'OK';
          response.end();
        });
        const urlRequest = net.request({
          url: serverUrl
        });
        urlRequest.setHeader('sec-fetch-user', '?1');
        await collectStreamBody(await getResponse(urlRequest));
      });

      test('should set sec-fetch-mode to no-cors by default', async () => {
        const serverUrl = await respondOnce.toSingleURL((request, response) => {
          expect(request.headers['sec-fetch-mode']).to.equal('no-cors');
          response.statusCode = 200;
          response.statusMessage = 'OK';
          response.end();
        });
        const urlRequest = net.request({
          url: serverUrl
        });
        await collectStreamBody(await getResponse(urlRequest));
      });

      for (const mode of ['navigate', 'cors', 'no-cors', 'same-origin']) {
        test(
          `should set sec-fetch-mode to ${mode} if requested`,
          async () => {
            const serverUrl = await respondOnce.toSingleURL((request, response) => {
              expect(request.headers['sec-fetch-mode']).to.equal(mode);
              response.statusCode = 200;
              response.statusMessage = 'OK';
              response.end();
            });
            const urlRequest = net.request({
              url: serverUrl,
              origin: serverUrl
            });
            urlRequest.setHeader('sec-fetch-mode', mode);
            await collectStreamBody(await getResponse(urlRequest));
          },
          { mode }
        );
      }

      test('should set sec-fetch-dest to empty by default', async () => {
        const serverUrl = await respondOnce.toSingleURL((request, response) => {
          expect(request.headers['sec-fetch-dest']).to.equal('empty');
          response.statusCode = 200;
          response.statusMessage = 'OK';
          response.end();
        });
        const urlRequest = net.request({
          url: serverUrl
        });
        await collectStreamBody(await getResponse(urlRequest));
      });

      for (const dest of [
        'empty',
        'audio',
        'audioworklet',
        'document',
        'embed',
        'font',
        'frame',
        'iframe',
        'image',
        'manifest',
        'object',
        'paintworklet',
        'report',
        'script',
        'serviceworker',
        'style',
        'track',
        'video',
        'worker',
        'xslt'
      ]) {
        test(
          `should set sec-fetch-dest to ${dest} if requested`,
          async () => {
            const serverUrl = await respondOnce.toSingleURL((request, response) => {
              expect(request.headers['sec-fetch-dest']).to.equal(dest);
              response.statusCode = 200;
              response.statusMessage = 'OK';
              response.end();
            });
            const urlRequest = net.request({
              url: serverUrl,
              origin: serverUrl
            });
            urlRequest.setHeader('sec-fetch-dest', dest);
            await collectStreamBody(await getResponse(urlRequest));
          },
          { dest }
        );
      }

      test('should be able to abort an HTTP request before first write', async () => {
        const serverUrl = await respondOnce.toSingleURL((request, response) => {
          response.end();
          expect.fail('Unexpected request event');
        });

        const urlRequest = net.request(serverUrl);
        urlRequest.on('response', () => {
          expect.fail('unexpected response event');
        });
        const aborted = once(urlRequest, 'abort');
        urlRequest.abort();
        urlRequest.write('');
        urlRequest.end();
        await aborted;
      });

      test('it should be able to abort an HTTP request before request end', async () => {
        let requestReceivedByServer = false;
        let urlRequest: ClientRequest | null = null;
        const serverUrl = await respondOnce.toSingleURL(() => {
          requestReceivedByServer = true;
          urlRequest!.abort();
        });
        let requestAbortEventEmitted = false;

        urlRequest = net.request(serverUrl);
        urlRequest.on('response', () => {
          expect.fail('Unexpected response event');
        });
        urlRequest.on('finish', () => {
          expect.fail('Unexpected finish event');
        });
        urlRequest.on('error', () => {
          expect.fail('Unexpected error event');
        });
        urlRequest.on('abort', () => {
          requestAbortEventEmitted = true;
        });

        const p = once(urlRequest, 'close');
        urlRequest.chunkedEncoding = true;
        urlRequest.write(randomString(kOneKiloByte));
        await p;
        expect(requestReceivedByServer).to.equal(true);
        expect(requestAbortEventEmitted).to.equal(true);
      });

      test('it should be able to abort an HTTP request after request end and before response', async () => {
        let requestReceivedByServer = false;
        let urlRequest: ClientRequest | null = null;
        const serverUrl = await respondOnce.toSingleURL((request, response) => {
          requestReceivedByServer = true;
          urlRequest!.abort();
          process.nextTick(() => {
            response.statusCode = 200;
            response.statusMessage = 'OK';
            response.end();
          });
        });
        let requestFinishEventEmitted = false;

        urlRequest = net.request(serverUrl);
        urlRequest.on('response', () => {
          expect.fail('Unexpected response event');
        });
        urlRequest.on('finish', () => {
          requestFinishEventEmitted = true;
        });
        urlRequest.on('error', () => {
          expect.fail('Unexpected error event');
        });
        urlRequest.end(randomString(kOneKiloByte));
        await once(urlRequest, 'abort');
        expect(requestFinishEventEmitted).to.equal(true);
        expect(requestReceivedByServer).to.equal(true);
      });

      test('it should be able to abort an HTTP request after response start', async () => {
        let requestReceivedByServer = false;
        const serverUrl = await respondOnce.toSingleURL((request, response) => {
          requestReceivedByServer = true;
          response.statusCode = 200;
          response.statusMessage = 'OK';
          response.write(randomString(kOneKiloByte));
        });
        let requestFinishEventEmitted = false;
        let requestResponseEventEmitted = false;
        let responseCloseEventEmitted = false;

        const urlRequest = net.request(serverUrl);
        urlRequest.on('response', (response) => {
          requestResponseEventEmitted = true;
          const statusCode = response.statusCode;
          expect(statusCode).to.equal(200);
          response.on('data', () => {});
          response.on('end', () => {
            expect.fail('Unexpected end event');
          });
          response.on('error', () => {
            expect.fail('Unexpected error event');
          });
          response.on('close' as any, () => {
            responseCloseEventEmitted = true;
          });
          urlRequest.abort();
        });
        urlRequest.on('finish', () => {
          requestFinishEventEmitted = true;
        });
        urlRequest.on('error', () => {
          expect.fail('Unexpected error event');
        });
        urlRequest.end(randomString(kOneKiloByte));
        await once(urlRequest, 'abort');
        expect(requestFinishEventEmitted).to.be.true('request should emit "finish" event');
        expect(requestReceivedByServer).to.be.true('request should be received by the server');
        expect(requestResponseEventEmitted).to.be.true('"response" event should be emitted');
        expect(responseCloseEventEmitted).to.be.true('response should emit "close" event');
      });

      test('abort event should be emitted at most once', async () => {
        let requestReceivedByServer = false;
        let urlRequest: ClientRequest | null = null;
        const serverUrl = await respondOnce.toSingleURL(() => {
          requestReceivedByServer = true;
          urlRequest!.abort();
          urlRequest!.abort();
        });
        let requestFinishEventEmitted = false;
        let abortsEmitted = 0;

        urlRequest = net.request(serverUrl);
        urlRequest.on('response', () => {
          expect.fail('Unexpected response event');
        });
        urlRequest.on('finish', () => {
          requestFinishEventEmitted = true;
        });
        urlRequest.on('error', () => {
          expect.fail('Unexpected error event');
        });
        urlRequest.on('abort', () => {
          abortsEmitted++;
        });
        urlRequest.end(randomString(kOneKiloByte));
        await once(urlRequest, 'abort');
        expect(requestFinishEventEmitted).to.be.true('request should emit "finish" event');
        expect(requestReceivedByServer).to.be.true('request should be received by server');
        expect(abortsEmitted).to.equal(1, 'request should emit exactly 1 "abort" event');
      });

      test('should allow to read response body from non-2xx response', async () => {
        const bodyData = randomString(kOneKiloByte);
        const serverUrl = await respondOnce.toSingleURL((request, response) => {
          response.statusCode = 404;
          response.end(bodyData);
        });

        const urlRequest = net.request(serverUrl);
        const bodyCheckPromise = getResponse(urlRequest)
          .then((r) => {
            expect(r.statusCode).to.equal(404);
            return r;
          })
          .then(collectStreamBody)
          .then((receivedBodyData) => {
            expect(receivedBodyData.toString()).to.equal(bodyData);
          });
        const eventHandlers = Promise.all([bodyCheckPromise, once(urlRequest, 'close')]);

        urlRequest.end();

        await eventHandlers;
      });

      test('should throw when calling getHeader without a name', () => {
        expect(() => {
          (net.request({ url: 'https://test' }).getHeader as any)();
        }).to.throw(/`name` is required for getHeader\(name\)/);

        expect(() => {
          net.request({ url: 'https://test' }).getHeader(null as any);
        }).to.throw(/`name` is required for getHeader\(name\)/);
      });

      test('should throw when calling removeHeader without a name', () => {
        expect(() => {
          (net.request({ url: 'https://test' }).removeHeader as any)();
        }).to.throw(/`name` is required for removeHeader\(name\)/);

        expect(() => {
          net.request({ url: 'https://test' }).removeHeader(null as any);
        }).to.throw(/`name` is required for removeHeader\(name\)/);
      });

      test('should follow redirect when no redirect handler is provided', async () => {
        const requestUrl = '/302';
        const serverUrl = await respondOnce.toRoutes({
          '/302': (request, response) => {
            response.statusCode = 302;
            response.setHeader('Location', '/200');
            response.end();
          },
          '/200': (request, response) => {
            response.statusCode = 200;
            response.end();
          }
        });
        const urlRequest = net.request({
          url: `${serverUrl}${requestUrl}`
        });
        const response = await getResponse(urlRequest);
        expect(response.statusCode).to.equal(200);
      });

      test('should follow redirect chain when no redirect handler is provided', async () => {
        const serverUrl = await respondOnce.toRoutes({
          '/redirectChain': (request, response) => {
            response.statusCode = 302;
            response.setHeader('Location', '/302');
            response.end();
          },
          '/302': (request, response) => {
            response.statusCode = 302;
            response.setHeader('Location', '/200');
            response.end();
          },
          '/200': (request, response) => {
            response.statusCode = 200;
            response.end();
          }
        });
        const urlRequest = net.request({
          url: `${serverUrl}/redirectChain`
        });
        const response = await getResponse(urlRequest);
        expect(response.statusCode).to.equal(200);
      });

      test('should not follow redirect when request is canceled in redirect handler', async () => {
        const serverUrl = await respondOnce.toSingleURL((request, response) => {
          response.statusCode = 302;
          response.setHeader('Location', '/200');
          response.end();
        });
        const urlRequest = net.request({
          url: serverUrl
        });
        urlRequest.end();
        urlRequest.on('redirect', () => {
          urlRequest.abort();
        });
        urlRequest.on('error', () => {});
        urlRequest.on('response', () => {
          expect.fail('Unexpected response');
        });
        await once(urlRequest, 'abort');
      });

      test('should not follow redirect when mode is error', async () => {
        const serverUrl = await respondOnce.toSingleURL((request, response) => {
          response.statusCode = 302;
          response.setHeader('Location', '/200');
          response.end();
        });
        const urlRequest = net.request({
          url: serverUrl,
          redirect: 'error'
        });
        urlRequest.end();
        await once(urlRequest, 'error');
      });

      test('should emit an error when redirected from http to file:', async () => {
        const serverUrl = await respondOnce.toSingleURL((request, response) => {
          response.statusCode = 302;
          response.setHeader('Location', 'file:///');
          response.end();
        });
        const urlRequest = net.request({ url: serverUrl });
        urlRequest.end();
        const [err] = await once(urlRequest, 'error');
        expect(String(err)).to.match(/ERR_UNSAFE_REDIRECT/);
      });

      test('should follow redirect when handler calls callback', async () => {
        const serverUrl = await respondOnce.toRoutes({
          '/redirectChain': (request, response) => {
            response.statusCode = 302;
            response.setHeader('Location', '/302');
            response.end();
          },
          '/302': (request, response) => {
            response.statusCode = 302;
            response.setHeader('Location', '/200');
            response.end();
          },
          '/200': (request, response) => {
            response.statusCode = 200;
            response.end();
          }
        });
        const urlRequest = net.request({ url: `${serverUrl}/redirectChain`, redirect: 'manual' });
        const redirects: string[] = [];
        urlRequest.on('redirect', (status, method, url) => {
          redirects.push(url);
          urlRequest.followRedirect();
        });
        const response = await getResponse(urlRequest);
        expect(response.statusCode).to.equal(200);
        expect(redirects).to.deep.equal([`${serverUrl}/302`, `${serverUrl}/200`]);
      });

      test('should be able to create a request with options', async () => {
        const customHeaderName = 'Some-Custom-Header-Name';
        const customHeaderValue = 'Some-Customer-Header-Value';
        const serverUrlUnparsed = await respondOnce.toURL('/', (request, response) => {
          expect(request.method).to.equal('GET');
          expect(request.headers[customHeaderName.toLowerCase()]).to.equal(customHeaderValue);
          response.statusCode = 200;
          response.statusMessage = 'OK';
          response.end();
        });
        const serverUrl = new URL(serverUrlUnparsed);
        const urlRequest = net.request({
          port: serverUrl.port ? parseInt(serverUrl.port, 10) : undefined,
          hostname: '127.0.0.1',
          headers: { [customHeaderName]: customHeaderValue }
        });
        const response = await getResponse(urlRequest);
        expect(response.statusCode).to.be.equal(200);
        await collectStreamBody(response);
      });

      test('should be able to pipe a readable stream into a net request', async () => {
        const bodyData = randomString(kOneMegaByte);
        let netRequestReceived = false;
        let netRequestEnded = false;

        const [nodeServerUrl, netServerUrl] = await Promise.all([
          respondOnce.toSingleURL((request, response) => response.end(bodyData)),
          respondOnce.toSingleURL((request, response) => {
            netRequestReceived = true;
            let receivedBodyData = '';
            request.on('data', (chunk) => {
              receivedBodyData += chunk.toString();
            });
            request.on('end', (chunk: Buffer | undefined) => {
              netRequestEnded = true;
              if (chunk) {
                receivedBodyData += chunk.toString();
              }
              expect(receivedBodyData).to.be.equal(bodyData);
              response.end();
            });
          })
        ]);
        const nodeRequest = http.request(nodeServerUrl);
        const nodeResponse = (await getResponse(nodeRequest as any)) as any as http.ServerResponse;
        const netRequest = net.request(netServerUrl);
        const responsePromise = once(netRequest, 'response');
        // TODO(@MarshallOfSound) - FIXME with #22730
        nodeResponse.pipe(netRequest as any);
        const [netResponse] = await responsePromise;
        expect(netResponse.statusCode).to.equal(200);
        await collectStreamBody(netResponse);
        expect(netRequestReceived).to.be.true('net request received');
        expect(netRequestEnded).to.be.true('net request ended');
      });

      test('should report upload progress', async () => {
        const serverUrl = await respondOnce.toSingleURL((request, response) => {
          response.end();
        });
        const netRequest = net.request({ url: serverUrl, method: 'POST' });
        expect(netRequest.getUploadProgress()).to.have.property('active', false);
        netRequest.end(Buffer.from('hello'));
        const [position, total] = await once(netRequest, 'upload-progress');
        expect(netRequest.getUploadProgress()).to.deep.equal({ active: true, started: true, current: position, total });
      });

      test('should emit error event on server socket destroy', async () => {
        const serverUrl = await respondOnce.toSingleURL((request) => {
          request.socket.destroy();
        });
        const urlRequest = net.request(serverUrl);
        urlRequest.end();
        const [error] = await once(urlRequest, 'error');
        expect(error.message).to.equal('net::ERR_EMPTY_RESPONSE');
      });

      test('should emit error event on server request destroy', async () => {
        const serverUrl = await respondOnce.toSingleURL((request, response) => {
          request.destroy();
          response.end();
        });
        const urlRequest = net.request(serverUrl);
        urlRequest.end(randomBuffer(kOneMegaByte));
        const [error] = await once(urlRequest, 'error');
        expect(error.message).to.be.oneOf([
          'net::ERR_FAILED',
          'net::ERR_CONNECTION_RESET',
          'net::ERR_CONNECTION_ABORTED'
        ]);
      });

      test('should not emit any event after close', async () => {
        const serverUrl = await respondOnce.toSingleURL((request, response) => {
          response.end();
        });

        const urlRequest = net.request(serverUrl);
        urlRequest.end();

        await once(urlRequest, 'close');
        await new Promise((resolve, reject) => {
          for (const evName of ['finish', 'abort', 'close', 'error']) {
            urlRequest.on(evName as any, () => {
              reject(new Error(`Unexpected ${evName} event`));
            });
          }
          setTimeout(50).then(resolve);
        });
      });

      test('should remove the referer header when no referrer url specified', async () => {
        const serverUrl = await respondOnce.toSingleURL((request, response) => {
          expect(request.headers.referer).to.equal(undefined);
          response.statusCode = 200;
          response.statusMessage = 'OK';
          response.end();
        });
        const urlRequest = net.request(serverUrl);
        urlRequest.end();

        const response = await getResponse(urlRequest);
        expect(response.statusCode).to.equal(200);
        await collectStreamBody(response);
      });

      test('should set the referer header when a referrer url specified', async () => {
        const referrerURL = 'https://www.electronjs.org/';
        const serverUrl = await respondOnce.toSingleURL((request, response) => {
          expect(request.headers.referer).to.equal(referrerURL);
          response.statusCode = 200;
          response.statusMessage = 'OK';
          response.end();
        });
        // The referrerPolicy must be unsafe-url because the referrer's origin
        // doesn't match the loaded page. With the default referrer policy
        // (strict-origin-when-cross-origin), the request will be canceled by the
        // network service when the referrer header is invalid.
        // See:
        // - https://source.chromium.org/chromium/chromium/src/+/main:net/url_request/url_request.cc;l=682-683;drc=ae587fa7cd2e5cc308ce69353ee9ce86437e5d41
        // - https://source.chromium.org/chromium/chromium/src/+/main:services/network/public/mojom/network_context.mojom;l=316-318;drc=ae5c7fcf09509843c1145f544cce3a61874b9698
        // - https://w3c.github.io/webappsec-referrer-policy/#determine-requests-referrer
        const urlRequest = net.request({ url: serverUrl, referrerPolicy: 'unsafe-url' });
        urlRequest.setHeader('referer', referrerURL);
        urlRequest.end();

        const response = await getResponse(urlRequest);
        expect(response.statusCode).to.equal(200);
        await collectStreamBody(response);
      });
    });

    describe('IncomingMessage API', () => {
      test('response object should implement the IncomingMessage API', async () => {
        const customHeaderName = 'Some-Custom-Header-Name';
        const customHeaderValue = 'Some-Customer-Header-Value';

        const serverUrl = await respondOnce.toSingleURL((request, response) => {
          response.statusCode = 200;
          response.statusMessage = 'OK';
          response.setHeader(customHeaderName, customHeaderValue);
          response.end();
        });

        const urlRequest = net.request(serverUrl);
        const response = await getResponse(urlRequest);

        expect(response.statusCode).to.equal(200);
        expect(response.statusMessage).to.equal('OK');

        const headers = response.headers;
        expect(headers).to.be.an('object');
        const headerValue = headers[customHeaderName.toLowerCase()];
        expect(headerValue).to.equal(customHeaderValue);

        const rawHeaders = response.rawHeaders;
        expect(rawHeaders).to.be.an('array');
        expect(rawHeaders[0]).to.equal(customHeaderName);
        expect(rawHeaders[1]).to.equal(customHeaderValue);

        const httpVersion = response.httpVersion;
        expect(httpVersion).to.be.a('string').and.to.have.lengthOf.at.least(1);

        const httpVersionMajor = response.httpVersionMajor;
        expect(httpVersionMajor).to.be.a('number').and.to.be.at.least(1);

        const httpVersionMinor = response.httpVersionMinor;
        expect(httpVersionMinor).to.be.a('number').and.to.be.at.least(0);

        await collectStreamBody(response);
      });

      test('should discard duplicate headers', async () => {
        const includedHeader = 'max-forwards';
        const discardableHeader = 'Max-Forwards';

        const includedHeaderValue = 'max-fwds-val';
        const discardableHeaderValue = 'max-fwds-val-two';

        const serverUrl = await respondOnce.toSingleURL((request, response) => {
          response.statusCode = 200;
          response.statusMessage = 'OK';
          response.setHeader(discardableHeader, discardableHeaderValue);
          response.setHeader(includedHeader, includedHeaderValue);
          response.end();
        });
        const urlRequest = net.request(serverUrl);
        const response = await getResponse(urlRequest);
        expect(response.statusCode).to.equal(200);
        expect(response.statusMessage).to.equal('OK');

        const headers = response.headers;
        expect(headers).to.be.an('object');

        expect(headers).to.have.property(includedHeader);
        expect(headers).to.not.have.property(discardableHeader);
        expect(headers[includedHeader]).to.equal(includedHeaderValue);

        await collectStreamBody(response);
      });

      test('should join repeated non-discardable header values with ,', async () => {
        const serverUrl = await respondOnce.toSingleURL((request, response) => {
          response.statusCode = 200;
          response.statusMessage = 'OK';
          response.setHeader('referrer-policy', ['first-text', 'second-text']);
          response.end();
        });
        const urlRequest = net.request(serverUrl);
        const response = await getResponse(urlRequest);
        expect(response.statusCode).to.equal(200);
        expect(response.statusMessage).to.equal('OK');

        const headers = response.headers;
        expect(headers).to.be.an('object');
        expect(headers).to.have.property('referrer-policy');
        expect(headers['referrer-policy']).to.equal('first-text, second-text');

        await collectStreamBody(response);
      });

      test('should not join repeated discardable header values with ,', async () => {
        const serverUrl = await respondOnce.toSingleURL((request, response) => {
          response.statusCode = 200;
          response.statusMessage = 'OK';
          response.setHeader('last-modified', ['yesterday', 'today']);
          response.end();
        });
        const urlRequest = net.request(serverUrl);
        const response = await getResponse(urlRequest);
        expect(response.statusCode).to.equal(200);
        expect(response.statusMessage).to.equal('OK');

        const headers = response.headers;
        expect(headers).to.be.an('object');
        expect(headers).to.have.property('last-modified');
        expect(headers['last-modified']).to.equal('yesterday');

        await collectStreamBody(response);
      });

      test('should make set-cookie header an array even if single value', async () => {
        const serverUrl = await respondOnce.toSingleURL((request, response) => {
          response.statusCode = 200;
          response.statusMessage = 'OK';
          response.setHeader('set-cookie', 'chocolate-chip');
          response.end();
        });
        const urlRequest = net.request(serverUrl);
        const response = await getResponse(urlRequest);
        expect(response.statusCode).to.equal(200);
        expect(response.statusMessage).to.equal('OK');

        const headers = response.headers;
        expect(headers).to.be.an('object');
        expect(headers).to.have.property('set-cookie');
        expect(headers['set-cookie']).to.be.an('array');
        expect(headers['set-cookie'][0]).to.equal('chocolate-chip');

        await collectStreamBody(response);
      });

      test('should keep set-cookie header an array when an array', async () => {
        const serverUrl = await respondOnce.toSingleURL((request, response) => {
          response.statusCode = 200;
          response.statusMessage = 'OK';
          response.setHeader('set-cookie', ['chocolate-chip', 'oatmeal']);
          response.end();
        });
        const urlRequest = net.request(serverUrl);
        const response = await getResponse(urlRequest);
        expect(response.statusCode).to.equal(200);
        expect(response.statusMessage).to.equal('OK');

        const headers = response.headers;
        expect(headers).to.be.an('object');
        expect(headers).to.have.property('set-cookie');
        expect(headers['set-cookie']).to.be.an('array');
        expect(headers['set-cookie'][0]).to.equal('chocolate-chip');
        expect(headers['set-cookie'][1]).to.equal('oatmeal');

        await collectStreamBody(response);
      });

      test('should lowercase header keys', async () => {
        const serverUrl = await respondOnce.toSingleURL((request, response) => {
          response.statusCode = 200;
          response.statusMessage = 'OK';
          response.setHeader('HEADER-KEY', ['header-value']);
          response.setHeader('SeT-CookiE', ['chocolate-chip', 'oatmeal']);
          response.setHeader('rEFERREr-pOLICy', ['first-text', 'second-text']);
          response.setHeader('LAST-modified', 'yesterday');

          response.end();
        });
        const urlRequest = net.request(serverUrl);
        const response = await getResponse(urlRequest);
        expect(response.statusCode).to.equal(200);
        expect(response.statusMessage).to.equal('OK');

        const headers = response.headers;
        expect(headers).to.be.an('object');

        expect(headers).to.have.property('header-key');
        expect(headers).to.have.property('set-cookie');
        expect(headers).to.have.property('referrer-policy');
        expect(headers).to.have.property('last-modified');

        await collectStreamBody(response);
      });

      test('should return correct raw headers', async () => {
        const customHeaders: [string, string | string[]][] = [
          ['HEADER-KEY-ONE', 'header-value-one'],
          ['set-cookie', 'chocolate-chip'],
          ['header-key-two', 'header-value-two'],
          ['referrer-policy', ['first-text', 'second-text']],
          ['HEADER-KEY-THREE', 'header-value-three'],
          ['last-modified', ['first-text', 'second-text']],
          ['header-key-four', 'header-value-four']
        ];

        const serverUrl = await respondOnce.toSingleURL((request, response) => {
          response.statusCode = 200;
          response.statusMessage = 'OK';
          for (const headerTuple of customHeaders) {
            response.setHeader(headerTuple[0], headerTuple[1]);
          }
          response.end();
        });
        const urlRequest = net.request(serverUrl);
        const response = await getResponse(urlRequest);
        expect(response.statusCode).to.equal(200);
        expect(response.statusMessage).to.equal('OK');

        const rawHeaders = response.rawHeaders;
        expect(rawHeaders).to.be.an('array');

        let rawHeadersIdx = 0;
        for (const headerTuple of customHeaders) {
          const headerKey = headerTuple[0];
          const headerValues = Array.isArray(headerTuple[1]) ? headerTuple[1] : [headerTuple[1]];
          for (const headerValue of headerValues) {
            expect(rawHeaders[rawHeadersIdx]).to.equal(headerKey);
            expect(rawHeaders[rawHeadersIdx + 1]).to.equal(headerValue);
            rawHeadersIdx += 2;
          }
        }

        await collectStreamBody(response);
      });

      test('should be able to pipe a net response into a writable stream', async () => {
        const bodyData = randomString(kOneKiloByte);
        let nodeRequestProcessed = false;
        const [netServerUrl, nodeServerUrl] = await Promise.all([
          respondOnce.toSingleURL((request, response) => response.end(bodyData)),
          respondOnce.toSingleURL(async (request, response) => {
            const receivedBodyData = await collectStreamBody(request);
            expect(receivedBodyData).to.be.equal(bodyData);
            nodeRequestProcessed = true;
            response.end();
          })
        ]);
        const netRequest = net.request(netServerUrl);
        const netResponse = await getResponse(netRequest);
        const serverUrl = new URL(nodeServerUrl);
        const nodeOptions = {
          method: 'POST',
          path: serverUrl.pathname,
          port: serverUrl.port
        };
        const nodeRequest = http.request(nodeOptions);
        const nodeResponsePromise = once(nodeRequest, 'response');
        // TODO(@MarshallOfSound) - FIXME with #22730
        (netResponse as any).pipe(nodeRequest);
        const [nodeResponse] = await nodeResponsePromise;
        netRequest.end();
        await collectStreamBody(nodeResponse);
        expect(nodeRequestProcessed).to.equal(true);
      });

      test('should correctly throttle an incoming stream', async () => {
        let numChunksSent = 0;
        const serverUrl = await respondOnce.toSingleURL((request, response) => {
          const data = randomString(kOneMegaByte);
          const write = () => {
            let ok = true;
            do {
              numChunksSent++;
              if (numChunksSent > 30) return;
              ok = response.write(data);
            } while (ok);
            response.once('drain', write);
          };
          write();
        });
        const urlRequest = net.request(serverUrl);
        urlRequest.on('response', () => {});
        urlRequest.end();
        await setTimeout(2000);
        // TODO(nornagon): I think this ought to max out at 20, but in practice
        // it seems to exceed that sometimes. This is at 25 to avoid test flakes,
        // but we should investigate if there's actually something broken here and
        // if so fix it and reset this to max at 20, and if not then delete this
        // comment.
        expect(numChunksSent).to.be.at.most(25);
      });
    });

    describe('net.isOnline', () => {
      test('getter returns boolean', () => {
        expect(net.isOnline()).to.be.a('boolean');
      });

      test('property returns boolean', () => {
        expect(net.online).to.be.a('boolean');
      });
    });

    describe('Stability and performance', () => {
      test('should free unreferenced, never-started request objects without crash', async () => {
        net.request('https://test');
        await new Promise<void>((resolve) => {
          process.nextTick(() => {
            const v8Util = process._linkedBinding('electron_common_v8_util');
            v8Util.requestGarbageCollectionForTesting();
            resolve();
          });
        });
      });

      test('should collect on-going requests without crash', async () => {
        let finishResponse: (() => void) | null = null;
        const serverUrl = await respondOnce.toSingleURL((request, response) => {
          response.write(randomString(kOneKiloByte));
          finishResponse = () => {
            response.write(randomString(kOneKiloByte));
            response.end();
          };
        });
        const urlRequest = net.request(serverUrl);
        const response = await getResponse(urlRequest);
        process.nextTick(() => {
          // Trigger a garbage collection.
          const v8Util = process._linkedBinding('electron_common_v8_util');
          v8Util.requestGarbageCollectionForTesting();
          finishResponse!();
        });
        await collectStreamBody(response);
      });

      test('should collect unreferenced, ended requests without crash', async () => {
        const serverUrl = await respondOnce.toSingleURL((request, response) => {
          response.end();
        });
        const urlRequest = net.request(serverUrl);
        process.nextTick(() => {
          const v8Util = process._linkedBinding('electron_common_v8_util');
          v8Util.requestGarbageCollectionForTesting();
        });
        const response = await getResponse(urlRequest);
        await collectStreamBody(response);
      });

      test('should finish sending data when urlRequest is unreferenced', async () => {
        const serverUrl = await respondOnce.toSingleURL(async (request, response) => {
          const received = await collectStreamBodyBuffer(request);
          expect(received.length).to.equal(kOneMegaByte);
          response.end();
        });
        const urlRequest = net.request(serverUrl);
        urlRequest.on('close', () => {
          process.nextTick(() => {
            const v8Util = process._linkedBinding('electron_common_v8_util');
            v8Util.requestGarbageCollectionForTesting();
          });
        });
        urlRequest.write(randomBuffer(kOneMegaByte));
        const response = await getResponse(urlRequest);
        await collectStreamBody(response);
      });

      test('should finish sending data when urlRequest is unreferenced for chunked encoding', async () => {
        const serverUrl = await respondOnce.toSingleURL(async (request, response) => {
          const received = await collectStreamBodyBuffer(request);
          response.end();
          expect(received.length).to.equal(kOneMegaByte);
        });
        const urlRequest = net.request(serverUrl);
        urlRequest.chunkedEncoding = true;
        urlRequest.write(randomBuffer(kOneMegaByte));
        const response = await getResponse(urlRequest);
        await collectStreamBody(response);
        process.nextTick(() => {
          const v8Util = process._linkedBinding('electron_common_v8_util');
          v8Util.requestGarbageCollectionForTesting();
        });
      });

      test('should finish sending data when urlRequest is unreferenced before close event for chunked encoding', async () => {
        const serverUrl = await respondOnce.toSingleURL(async (request, response) => {
          const received = await collectStreamBodyBuffer(request);
          response.end();
          expect(received.length).to.equal(kOneMegaByte);
        });
        const urlRequest = net.request(serverUrl);
        urlRequest.chunkedEncoding = true;
        urlRequest.write(randomBuffer(kOneMegaByte));
        const v8Util = process._linkedBinding('electron_common_v8_util');
        v8Util.requestGarbageCollectionForTesting();
        await collectStreamBody(await getResponse(urlRequest));
      });

      test('should finish sending data when urlRequest is unreferenced', async () => {
        const serverUrl = await respondOnce.toSingleURL(async (request, response) => {
          const received = await collectStreamBodyBuffer(request);
          response.end();
          expect(received.length).to.equal(kOneMegaByte);
        });
        const urlRequest = net.request(serverUrl);
        urlRequest.on('close', () => {
          process.nextTick(() => {
            const v8Util = process._linkedBinding('electron_common_v8_util');
            v8Util.requestGarbageCollectionForTesting();
          });
        });
        urlRequest.write(randomBuffer(kOneMegaByte));
        await collectStreamBody(await getResponse(urlRequest));
      });

      test('should finish sending data when urlRequest is unreferenced for chunked encoding', async () => {
        const serverUrl = await respondOnce.toSingleURL(async (request, response) => {
          const received = await collectStreamBodyBuffer(request);
          response.end();
          expect(received.length).to.equal(kOneMegaByte);
        });
        const urlRequest = net.request(serverUrl);
        urlRequest.on('close', () => {
          process.nextTick(() => {
            const v8Util = process._linkedBinding('electron_common_v8_util');
            v8Util.requestGarbageCollectionForTesting();
          });
        });
        urlRequest.chunkedEncoding = true;
        urlRequest.write(randomBuffer(kOneMegaByte));
        await collectStreamBody(await getResponse(urlRequest));
      });
    });

    describe('non-http schemes', () => {
      test('should be rejected by net.request', async () => {
        expect(() => {
          net.request('file://bar');
        }).to.throw('ClientRequest only supports http: and https: protocols');
      });

      test('should be rejected by net.request when passed in url:', async () => {
        expect(() => {
          net.request({ url: 'file://bar' });
        }).to.throw('ClientRequest only supports http: and https: protocols');
      });
    });

    describe('net.fetch', () => {
      // NB. there exist much more comprehensive tests for fetch() in the form of
      // the WPT: https://github.com/web-platform-tests/wpt/tree/master/fetch
      // It's possible to run these tests against net.fetch(), but the test
      // harness to do so is quite complex and hasn't been munged to smoothly run
      // inside the Electron test runner yet.
      //
      // In the meantime, here are some tests for basic functionality and
      // Electron-specific behavior.

      describe('basic', () => {
        test('can fetch http urls', async () => {
          const serverUrl = await respondOnce.toSingleURL((request, response) => {
            response.end('test');
          });
          const resp = await net.fetch(serverUrl);
          expect(resp.ok).to.be.true();
          expect(await resp.text()).to.equal('test');
        });

        test('can upload a string body', async () => {
          const serverUrl = await respondOnce.toSingleURL((request, response) => {
            request.on('data', (chunk) => response.write(chunk));
            request.on('end', () => response.end());
          });
          const resp = await net.fetch(serverUrl, {
            method: 'POST',
            body: 'anchovies'
          });
          expect(await resp.text()).to.equal('anchovies');
        });

        test('can read response as an array buffer', async () => {
          const serverUrl = await respondOnce.toSingleURL((request, response) => {
            request.on('data', (chunk) => response.write(chunk));
            request.on('end', () => response.end());
          });
          const resp = await net.fetch(serverUrl, {
            method: 'POST',
            body: 'anchovies'
          });
          expect(new TextDecoder().decode(new Uint8Array(await resp.arrayBuffer()))).to.equal('anchovies');
        });

        test('can read response as form data', async () => {
          const serverUrl = await respondOnce.toSingleURL((request, response) => {
            response.setHeader('content-type', 'application/x-www-form-urlencoded');
            response.end('foo=bar');
          });
          const resp = await net.fetch(serverUrl);
          const result = await resp.formData();
          expect(result.get('foo')).to.equal('bar');
        });

        test('should reject promise on DNS failure', async () => {
          const r = net.fetch('https://i.do.not.exist');
          await expect(r).to.be.rejectedWith(/ERR_NAME_NOT_RESOLVED/);
        });

        test('should follow a redirect to another http origin', async () => {
          const targetUrl = await respondOnce.toSingleURL((req, res) => {
            res.end('redirected');
          });
          const serverUrl = await respondOnce.toSingleURL((req, res) => {
            res.statusCode = 302;
            res.setHeader('Location', targetUrl);
            res.end();
          });
          const resp = await net.fetch(serverUrl);
          expect(resp.status).to.equal(200);
          expect(await resp.text()).to.equal('redirected');
        });

        test('should reject a redirect from http to file:', async () => {
          const serverUrl = await respondOnce.toSingleURL((req, res) => {
            res.statusCode = 302;
            res.setHeader('Location', 'file:///');
            res.end();
          });
          await expect(net.fetch(serverUrl)).to.be.rejectedWith(/ERR_UNSAFE_REDIRECT/);
        });

        test('should reject a redirect from http to data:', async () => {
          const serverUrl = await respondOnce.toSingleURL((req, res) => {
            res.statusCode = 302;
            res.setHeader('Location', 'data:text/plain,hello');
            res.end();
          });
          await expect(net.fetch(serverUrl)).to.be.rejectedWith(/ERR_UNSAFE_REDIRECT/);
        });

        test('should reject a redirect from http to about:', async () => {
          const serverUrl = await respondOnce.toSingleURL((req, res) => {
            res.statusCode = 302;
            res.setHeader('Location', 'about:blank');
            res.end();
          });
          await expect(net.fetch(serverUrl)).to.be.rejectedWith(/ERR_UNSAFE_REDIRECT/);
        });

        test('should reject a redirect from http to blob:', async () => {
          const serverUrl = await respondOnce.toSingleURL((req, res) => {
            res.statusCode = 302;
            res.setHeader('Location', 'blob:https://example.com/00000000-0000-0000-0000-000000000000');
            res.end();
          });
          await expect(net.fetch(serverUrl)).to.be.rejectedWith(/ERR_UNSAFE_REDIRECT/);
        });

        test('should reject body promise when stream fails', async () => {
          const serverUrl = await respondOnce.toSingleURL((request, response) => {
            response.write('first chunk');
            setTimeout().then(() => response.destroy());
          });
          const r = await net.fetch(serverUrl);
          expect(r.status).to.equal(200);
          await expect(r.text()).to.be.rejectedWith(/ERR_INCOMPLETE_CHUNKED_ENCODING/);
        });
      });
    });

    describe('net.resolveHost', () => {
      test('resolves ipv4.localhost2', async () => {
        const { endpoints } = await net.resolveHost('ipv4.localhost2');
        expect(endpoints).to.be.a('array');
        expect(endpoints).to.have.lengthOf(1);
        expect(endpoints[0].family).to.equal('ipv4');
        expect(endpoints[0].address).to.equal('10.0.0.1');
      });

      test('fails to resolve AAAA record for ipv4.localhost2', async () => {
        await expect(
          net.resolveHost('ipv4.localhost2', {
            queryType: 'AAAA'
          })
        ).to.eventually.be.rejectedWith(/net::ERR_NAME_NOT_RESOLVED/);
      });

      test('resolves ipv6.localhost2', async () => {
        const { endpoints } = await net.resolveHost('ipv6.localhost2');
        expect(endpoints).to.be.a('array');
        expect(endpoints).to.have.lengthOf(1);
        expect(endpoints[0].family).to.equal('ipv6');
        expect(endpoints[0].address).to.equal('::1');
      });

      test('fails to resolve A record for ipv6.localhost2', async () => {
        await expect(
          net.resolveHost('notfound.localhost2', {
            queryType: 'A'
          })
        ).to.eventually.be.rejectedWith(/net::ERR_NAME_NOT_RESOLVED/);
      });

      test('fails to resolve notfound.localhost2', async () => {
        await expect(net.resolveHost('notfound.localhost2')).to.eventually.be.rejectedWith(
          /net::ERR_NAME_NOT_RESOLVED/
        );
      });
    });
  }

  for (const test of [itIgnoringArgs]) {
    describe('ClientRequest API', () => {
      for (const [priorityName, urgency] of Object.entries({
        throttled: 'u=5',
        idle: 'u=4',
        lowest: '',
        low: 'u=2',
        medium: 'u=1',
        highest: 'u=0'
      })) {
        for (const priorityIncremental of [true, false]) {
          test(
            `should set priority to ${priorityName}/${priorityIncremental} if requested`,
            async () => {
              // Priority header is available on HTTP/2, which is only
              // supported over TLS, so...
              session.defaultSession.setCertificateVerifyProc((req, cb) => cb(0));
              defer(() => {
                session.defaultSession.setCertificateVerifyProc(null);
              });

              const urlRequest = net.request({
                url: `${http2URL}get`,
                priority: priorityName as any,
                priorityIncremental
              });
              const response = await getResponse(urlRequest);
              const data = JSON.parse(await collectStreamBody(response));
              let expectedPriority = urgency;
              if (priorityIncremental) {
                expectedPriority = expectedPriority ? expectedPriority + ', i' : 'i';
              }
              if (expectedPriority === '') {
                expect(data.headers.priority).to.be.undefined();
              } else {
                expect(data.headers.priority).to.be.a('string').and.equal(expectedPriority);
              }
            },
            { priorityName, urgency, priorityIncremental }
          );
        }
      }
    });
  }
});
