global-agent 4.1.0 → 4.1.1

package/.gitignore

@@ -5,8 +5,6 @@ node_modules
 .*
 !.babelrc
 !.editorconfig
-!.eslintignore
-!.eslintrc
 !.github
 !.gitignore
 !.npmignore

package/README.md

@@ -1,6 +1,5 @@
 # global-agent
 
-[![Coveralls](https://img.shields.io/coveralls/gajus/global-agent.svg?style=flat-square)](https://coveralls.io/github/gajus/global-agent)
 [![NPM version](http://img.shields.io/npm/v/global-agent.svg?style=flat-square)](https://www.npmjs.org/package/global-agent)
 [![Canonical Code Style](https://img.shields.io/badge/code%20style-canonical-blue.svg?style=flat-square)](https://github.com/gajus/canonical)
 [![Twitter Follow](https://img.shields.io/twitter/follow/kuizinas.svg?style=social&label=Follow)](https://twitter.com/kuizinas)

package/package.json

@@ -2,18 +2,7 @@
   "author": {
     "email": "gajus@gajus.com",
     "name": "Gajus Kuizinas",
-    "url": "http://gajus.com"
-  },
-  "ava": {
-    "extensions": [
-      "ts"
-    ],
-    "files": [
-      "test/global-agent/**/*"
-    ],
-    "require": [
-      "ts-node/register/transpile-only"
-    ]
+    "url": "https://gajus.com"
   },
   "dependencies": {
     "es6-error": "^4.1.1",
@@ -25,14 +14,12 @@
   },
   "description": "Global HTTP/HTTPS proxy configurable using environment variables.",
   "devDependencies": {
-    "@ava/babel": "^2.0.0",
     "@babel/cli": "^7.14.8",
     "@babel/core": "^7.14.8",
     "@babel/node": "^7.14.7",
     "@babel/plugin-transform-flow-strip-types": "^7.14.5",
     "@babel/preset-env": "^7.14.8",
     "@babel/register": "^7.14.5",
-    "@istanbuljs/nyc-config-typescript": "^1.0.1",
     "@semantic-release/commit-analyzer": "^13.0.1",
     "@semantic-release/github": "^12.0.3",
     "@semantic-release/npm": "^13.1.3",
@@ -41,24 +28,20 @@
     "@types/request": "^2.48.6",
     "@types/semver": "^7.3.8",
     "@types/sinon": "^10.0.2",
-    "ava": "^3.15.0",
     "axios": "^0.21.1",
-    "babel-plugin-istanbul": "^6.0.0",
     "babel-plugin-transform-export-default-name": "^2.1.0",
-    "coveralls": "^3.1.1",
     "del-cli": "^4.0.1",
-    "eslint": "^7.31.0",
-    "eslint-config-canonical": "^26.2.3",
     "get-port": "^5.1.1",
     "got": "^11.8.2",
     "husky": "^7.0.1",
-    "nyc": "^15.1.0",
+    "oxlint": "^1.43.0",
     "pem": "^1.14.4",
     "request": "^2.88.2",
     "semantic-release": "^25.0.3",
     "sinon": "^11.1.2",
     "ts-node": "^10.1.0",
-    "typescript": "^4.3.5"
+    "typescript": "^4.3.5",
+    "vitest": "^4.0.18"
   },
   "engines": {
     "node": ">=10.0"
@@ -77,20 +60,16 @@
   "license": "BSD-3-Clause",
   "main": "./dist/src/index.js",
   "name": "global-agent",
-  "nyc": {
-    "extends": "@istanbuljs/nyc-config-typescript",
-    "all": true
-  },
   "repository": {
     "type": "git",
     "url": "https://github.com/gajus/global-agent"
   },
   "scripts": {
     "build": "del-cli ./dist && tsc",
-    "lint": "eslint ./src ./test && tsc",
-    "test": "ava --verbose --serial",
+    "lint": "oxlint ./src && tsc",
+    "test": "vitest run",
     "create-readme": "gitdown ./.README/README.md --output-file ./README.md"
   },
   "typings": "./dist/src/index.d.ts",
-  "version": "4.1.0"
+  "version": "4.1.1"
 }

package/src/Logger.ts

@@ -9,7 +9,7 @@ export type Logger = {
   warn: LogMethod,
 };
 
-// eslint-disable-next-line @typescript-eslint/no-empty-function
+// oxlint-disable-next-line @typescript-eslint/no-empty-function
 const noop = () => {};
 
 const createNoopLogger = (): Logger => {

package/src/classes/Agent.ts

@@ -108,7 +108,7 @@ abstract class Agent {
    * Evaluate value for tls reject unauthorized variable
    */
   public getRejectUnauthorized () {
-    // eslint-disable-next-line node/no-process-env
+    // oxlint-disable-next-line node/no-process-env
     const rejectUnauthorized = process.env.NODE_TLS_REJECT_UNAUTHORIZED;
     let returnValue = true;
     if (typeof rejectUnauthorized === 'boolean') {
@@ -136,7 +136,7 @@ abstract class Agent {
     } else if (request.method === 'CONNECT') {
       requestUrl = 'https://' + request.path;
     } else {
-      requestUrl = this.protocol + '//' + (configuration.hostname ?? configuration.host) + (configuration.port === 80 ?? configuration.port === 443 ? '' : ':' + configuration.port) + request.path;
+      requestUrl = this.protocol + '//' + (configuration.hostname ?? configuration.host) + (configuration.port === 80 || configuration.port === 443 ? '' : ':' + configuration.port) + request.path;
     }
 
     // If a request should go to a local socket, proxying it through an HTTP

package/{test/global-agent/factories/createGlobalProxyAgent.ts → src/factories/createGlobalProxyAgent.test.ts}

@@ -6,11 +6,12 @@ import http from 'http';
 import https from 'https';
 import net from 'net';
 import {
-  serial,
-  before,
   afterEach,
+  beforeAll,
   beforeEach,
-} from 'ava';
+  expect,
+  test,
+} from 'vitest';
 import axios from 'axios';
 import getPort from 'get-port';
 import got from 'got';
@@ -19,7 +20,7 @@ import makeRequest from 'request';
 import {
   stub,
 } from 'sinon';
-import createGlobalProxyAgent from '../../../src/factories/createGlobalProxyAgent';
+import createGlobalProxyAgent from './createGlobalProxyAgent';
 
 type ProxyServerType = {
   port: number,
@@ -57,7 +58,7 @@ const defaultHttpAgent = http.globalAgent;
 const defaultHttpsAgent = https.globalAgent;
 
 // Backup original value of NODE_TLS_REJECT_UNAUTHORIZED
-// eslint-disable-next-line node/no-process-env
+// oxlint-disable-next-line node/no-process-env
 const defaultNodeTlsRejectUnauthorized = process.env.NODE_TLS_REJECT_UNAUTHORIZED;
 
 let lastPort = 3_000;
@@ -101,7 +102,7 @@ const generateCertificates = (): Promise<{
   });
 };
 
-before(async () => {
+beforeAll(async () => {
   // Pre-generate certificates
   await generateCertificates();
 });
@@ -131,7 +132,7 @@ afterEach(() => {
   localHttpsServers = [];
 
   // Reset NODE_TLS_REJECT_UNAUTHORIZED to original value
-  // eslint-disable-next-line node/no-process-env
+  // oxlint-disable-next-line node/no-process-env
   process.env.NODE_TLS_REJECT_UNAUTHORIZED = defaultNodeTlsRejectUnauthorized;
 });
 
@@ -291,7 +292,7 @@ const createHttpServer = async (): Promise<HttpServerType> => {
   return localHttpServer;
 };
 
-serial('proxies HTTP request', async (t) => {
+test('proxies HTTP request', async () => {
   const globalProxyAgent = createGlobalProxyAgent();
 
   const proxyServer = await createProxyServer();
@@ -302,10 +303,10 @@ serial('proxies HTTP request', async (t) => {
     http.get('http://127.0.0.1', createHttpResponseResolver(resolve));
   });
 
-  t.is(response.body, 'OK');
+  expect(response.body).toBe('OK');
 });
 
-serial('proxies HTTP request with proxy-authorization header', async (t) => {
+test('proxies HTTP request with proxy-authorization header', async () => {
   const globalProxyAgent = createGlobalProxyAgent();
 
   const beforeSendRequest = stub().callsFake(() => {
@@ -328,45 +329,45 @@ serial('proxies HTTP request with proxy-authorization header', async (t) => {
     http.get('http://127.0.0.1', createHttpResponseResolver(resolve));
   });
 
-  t.is(response.body, 'OK');
+  expect(response.body).toBe('OK');
 
-  t.is(beforeSendRequest.firstCall.args[0].requestOptions.headers['proxy-authorization'], 'Basic Zm9v');
+  expect(beforeSendRequest.firstCall.args[0].requestOptions.headers['proxy-authorization']).toBe('Basic Zm9v');
 });
 
-serial('Test reject unauthorized variable when NODE_TLS_REJECT_UNAUTHORIZED = undefined', async (t) => {
-  // eslint-disable-next-line node/no-process-env
-  const {NODE_TLS_REJECT_UNAUTHORIZED, ...restEnvironments} = process.env; // eslint-disable-line @typescript-eslint/no-unused-vars
-  // eslint-disable-next-line node/no-process-env
+test('Test reject unauthorized variable when NODE_TLS_REJECT_UNAUTHORIZED = undefined', async () => {
+  // oxlint-disable-next-line node/no-process-env
+  const {NODE_TLS_REJECT_UNAUTHORIZED, ...restEnvironments} = process.env; // oxlint-disable-line @typescript-eslint/no-unused-vars
+  // oxlint-disable-next-line node/no-process-env
   process.env = restEnvironments;
-  // eslint-disable-next-line node/no-process-env
+  // oxlint-disable-next-line node/no-process-env
   process.env.GLOBAL_AGENT_FORCE_GLOBAL_AGENT = 'true';
   const globalProxyAgent = createGlobalProxyAgent();
   const proxyServer = await createProxyServer();
   globalProxyAgent.HTTP_PROXY = proxyServer.url;
   const globalAgent: any = https.globalAgent;
-  t.is(globalAgent.getRejectUnauthorized(), true);
+  expect(globalAgent.getRejectUnauthorized()).toBe(true);
 
   const response: HttpResponseType = await new Promise((resolve) => {
     http.get('http://127.0.0.1', createHttpResponseResolver(resolve));
   });
 
-  t.is(response.body, 'OK');
+  expect(response.body).toBe('OK');
 });
 
-serial('Test reject unauthorized variable when NODE_TLS_REJECT_UNAUTHORIZED = null', async (t) => {
-  // eslint-disable-next-line node/no-process-env
+test('Test reject unauthorized variable when NODE_TLS_REJECT_UNAUTHORIZED = null', async () => {
+  // oxlint-disable-next-line node/no-process-env
   process.env.NODE_TLS_REJECT_UNAUTHORIZED = 'null';
   const globalProxyAgent = createGlobalProxyAgent();
   const proxyServer = await createProxyServer();
   globalProxyAgent.HTTP_PROXY = proxyServer.url;
 
   const globalAgent: any = https.globalAgent;
-  t.is(globalAgent.getRejectUnauthorized(), false);
+  expect(globalAgent.getRejectUnauthorized()).toBe(false);
 });
 
-serial('Test reject unauthorized variable when NODE_TLS_REJECT_UNAUTHORIZED = 1', async (t) => {
+test('Test reject unauthorized variable when NODE_TLS_REJECT_UNAUTHORIZED = 1', async () => {
   // @ts-expect-error it is expected as we wanted to set process variable with int
-  // eslint-disable-next-line node/no-process-env
+  // oxlint-disable-next-line node/no-process-env
   process.env.NODE_TLS_REJECT_UNAUTHORIZED = 1;
   const globalProxyAgent = createGlobalProxyAgent();
 
@@ -375,12 +376,12 @@ serial('Test reject unauthorized variable when NODE_TLS_REJECT_UNAUTHORIZED = 1'
   globalProxyAgent.HTTP_PROXY = proxyServer.url;
 
   const globalAgent: any = https.globalAgent;
-  t.is(globalAgent.getRejectUnauthorized(), true);
+  expect(globalAgent.getRejectUnauthorized()).toBe(true);
 });
 
-serial('Test reject unauthorized variable when NODE_TLS_REJECT_UNAUTHORIZED = 0', async (t) => {
+test('Test reject unauthorized variable when NODE_TLS_REJECT_UNAUTHORIZED = 0', async () => {
   // @ts-expect-error it is expected as we wanted to set process variable with int
-  // eslint-disable-next-line node/no-process-env
+  // oxlint-disable-next-line node/no-process-env
   process.env.NODE_TLS_REJECT_UNAUTHORIZED = 0;
   const globalProxyAgent = createGlobalProxyAgent();
 
@@ -389,74 +390,74 @@ serial('Test reject unauthorized variable when NODE_TLS_REJECT_UNAUTHORIZED = 0'
   globalProxyAgent.HTTP_PROXY = proxyServer.url;
 
   const globalAgent: any = https.globalAgent;
-  t.is(globalAgent.getRejectUnauthorized(), false);
+  expect(globalAgent.getRejectUnauthorized()).toBe(false);
 });
 
-serial('Test reject unauthorized variable when NODE_TLS_REJECT_UNAUTHORIZED = true', async (t) => {
+test('Test reject unauthorized variable when NODE_TLS_REJECT_UNAUTHORIZED = true', async () => {
   // @ts-expect-error it is expected as we wanted to set process variable with boolean
-  // eslint-disable-next-line node/no-process-env
+  // oxlint-disable-next-line node/no-process-env
   process.env.NODE_TLS_REJECT_UNAUTHORIZED = true;
   const globalProxyAgent = createGlobalProxyAgent();
   const proxyServer = await createProxyServer();
   globalProxyAgent.HTTP_PROXY = proxyServer.url;
 
   const globalAgent: any = https.globalAgent;
-  t.is(globalAgent.getRejectUnauthorized(), true);
+  expect(globalAgent.getRejectUnauthorized()).toBe(true);
 });
 
-serial('Test reject unauthorized variable when NODE_TLS_REJECT_UNAUTHORIZED = false', async (t) => {
+test('Test reject unauthorized variable when NODE_TLS_REJECT_UNAUTHORIZED = false', async () => {
   // @ts-expect-error it is expected as we wanted to set process variable with boolean
-  // eslint-disable-next-line node/no-process-env
+  // oxlint-disable-next-line node/no-process-env
   process.env.NODE_TLS_REJECT_UNAUTHORIZED = false;
   const globalProxyAgent = createGlobalProxyAgent();
   const proxyServer = await createProxyServer();
   globalProxyAgent.HTTP_PROXY = proxyServer.url;
 
   const globalAgent: any = https.globalAgent;
-  t.is(globalAgent.getRejectUnauthorized(), false);
+  expect(globalAgent.getRejectUnauthorized()).toBe(false);
 });
 
-serial('Test reject unauthorized variable when NODE_TLS_REJECT_UNAUTHORIZED = yes', async (t) => {
-  // eslint-disable-next-line node/no-process-env
+test('Test reject unauthorized variable when NODE_TLS_REJECT_UNAUTHORIZED = yes', async () => {
+  // oxlint-disable-next-line node/no-process-env
   process.env.NODE_TLS_REJECT_UNAUTHORIZED = 'yes';
   const globalProxyAgent = createGlobalProxyAgent();
   const proxyServer = await createProxyServer();
   globalProxyAgent.HTTP_PROXY = proxyServer.url;
 
   const globalAgent: any = https.globalAgent;
-  t.is(globalAgent.getRejectUnauthorized(), true);
+  expect(globalAgent.getRejectUnauthorized()).toBe(true);
 });
 
-serial('Test reject unauthorized variable when NODE_TLS_REJECT_UNAUTHORIZED = no', async (t) => {
-  // eslint-disable-next-line node/no-process-env
+test('Test reject unauthorized variable when NODE_TLS_REJECT_UNAUTHORIZED = no', async () => {
+  // oxlint-disable-next-line node/no-process-env
   process.env.NODE_TLS_REJECT_UNAUTHORIZED = 'no';
   const globalProxyAgent = createGlobalProxyAgent();
   const proxyServer = await createProxyServer();
   globalProxyAgent.HTTP_PROXY = proxyServer.url;
 
   const globalAgent: any = https.globalAgent;
-  t.is(globalAgent.getRejectUnauthorized(), false);
+  expect(globalAgent.getRejectUnauthorized()).toBe(false);
 });
 
-serial('Test addCACertificates and clearCACertificates methods', async (t) => {
+test('Test addCACertificates and clearCACertificates methods', async () => {
   const globalProxyAgent = createGlobalProxyAgent();
 
   const proxyServer = await createProxyServer();
 
   globalProxyAgent.HTTP_PROXY = proxyServer.url;
   const globalAgent: any = https.globalAgent;
-  t.is(globalAgent.ca, undefined);
+  expect(globalAgent.ca).toBe(undefined);
   globalAgent.addCACertificates(['test-ca-certficate1', 'test-ca-certficate2']);
   globalAgent.addCACertificates(['test-ca-certficate3']);
   const result = ['test-ca-certficate1', 'test-ca-certficate2', 'test-ca-certficate3'];
-  t.is(globalAgent.ca.length, result.length);
-  t.is(JSON.stringify(globalAgent.ca), JSON.stringify(result));
+  expect(globalAgent.ca.length).toBe(result.length);
+  expect(JSON.stringify(globalAgent.ca)).toBe(JSON.stringify(result));
   globalAgent.clearCACertificates();
-  t.is(globalAgent.ca, undefined);
+  expect(globalAgent.ca).toBe(undefined);
 });
 
-serial('Test addCACertificates when passed ca is a string', async (t) => {
-  // eslint-disable-next-line node/no-process-env
+test('Test addCACertificates when passed ca is a string', async () => {
+  // oxlint-disable-next-line node/no-process-env
   process.env.NODE_TLS_REJECT_UNAUTHORIZED = '0';
   const globalProxyAgent = createGlobalProxyAgent();
 
@@ -464,18 +465,18 @@ serial('Test addCACertificates when passed ca is a string', async (t) => {
 
   globalProxyAgent.HTTP_PROXY = proxyServer.url;
   const globalAgent: any = https.globalAgent;
-  t.is(globalAgent.ca, undefined);
+  expect(globalAgent.ca).toBe(undefined);
   globalAgent.addCACertificates('test-ca-certficate1');
   globalAgent.addCACertificates('test-ca-certficate2');
-  t.is(globalAgent.ca, 'test-ca-certficate1test-ca-certficate2');
+  expect(globalAgent.ca).toBe('test-ca-certficate1test-ca-certficate2');
   const response: HttpResponseType = await new Promise((resolve) => {
     https.get('https://127.0.0.1', createHttpResponseResolver(resolve));
   });
-  t.is(response.body, 'OK');
+  expect(response.body).toBe('OK');
 });
 
-serial('Test addCACertificates when input ca is a string and existing ca is array', async (t) => {
-  // eslint-disable-next-line node/no-process-env
+test('Test addCACertificates when input ca is a string and existing ca is array', async () => {
+  // oxlint-disable-next-line node/no-process-env
   process.env.NODE_TLS_REJECT_UNAUTHORIZED = '0';
   const globalProxyAgent = createGlobalProxyAgent({ca: ['test-ca']});
 
@@ -483,18 +484,18 @@ serial('Test addCACertificates when input ca is a string and existing ca is arra
 
   globalProxyAgent.HTTP_PROXY = proxyServer.url;
   const globalAgent: any = https.globalAgent;
-  t.is(globalAgent.ca.length, 1);
+  expect(globalAgent.ca.length).toBe(1);
   globalAgent.addCACertificates('test-ca-certficate1');
-  t.is(globalAgent.ca.length, 1);
-  t.is(JSON.stringify(globalAgent.ca), JSON.stringify(['test-ca']));
+  expect(globalAgent.ca.length).toBe(1);
+  expect(JSON.stringify(globalAgent.ca)).toBe(JSON.stringify(['test-ca']));
   const response: HttpResponseType = await new Promise((resolve) => {
     https.get('https://127.0.0.1', createHttpResponseResolver(resolve));
   });
-  t.is(response.body, 'OK');
+  expect(response.body).toBe('OK');
 });
 
-serial('Test addCACertificates when input ca array is null or undefined', async (t) => {
-  // eslint-disable-next-line node/no-process-env
+test('Test addCACertificates when input ca array is null or undefined', async () => {
+  // oxlint-disable-next-line node/no-process-env
   process.env.NODE_TLS_REJECT_UNAUTHORIZED = '0';
   const globalProxyAgent = createGlobalProxyAgent();
 
@@ -502,18 +503,18 @@ serial('Test addCACertificates when input ca array is null or undefined', async
 
   globalProxyAgent.HTTP_PROXY = proxyServer.url;
   const globalAgent: any = https.globalAgent;
-  t.is(globalAgent.ca, undefined);
+  expect(globalAgent.ca).toBe(undefined);
   globalAgent.addCACertificates(undefined);
   globalAgent.addCACertificates(null);
-  t.is(globalAgent.ca, undefined);
+  expect(globalAgent.ca).toBe(undefined);
   const response: HttpResponseType = await new Promise((resolve) => {
     https.get('https://127.0.0.1', createHttpResponseResolver(resolve));
   });
-  t.is(response.body, 'OK');
+  expect(response.body).toBe('OK');
 });
 
-serial('Test initializing ca certificate property while creating global proxy agent', async (t) => {
-  // eslint-disable-next-line node/no-process-env
+test('Test initializing ca certificate property while creating global proxy agent', async () => {
+  // oxlint-disable-next-line node/no-process-env
   process.env.NODE_TLS_REJECT_UNAUTHORIZED = '0';
   const globalProxyAgent = createGlobalProxyAgent({ca: ['test-ca']});
 
@@ -521,19 +522,19 @@ serial('Test initializing ca certificate property while creating global proxy ag
 
   globalProxyAgent.HTTP_PROXY = proxyServer.url;
   const globalAgent: any = https.globalAgent;
-  t.is(globalAgent.ca.length, 1);
+  expect(globalAgent.ca.length).toBe(1);
   globalAgent.addCACertificates(['test-ca1']);
-  t.is(globalAgent.ca.length, 2);
-  t.is(globalAgent.ca[0], 'test-ca');
-  t.is(globalAgent.ca[1], 'test-ca1');
+  expect(globalAgent.ca.length).toBe(2);
+  expect(globalAgent.ca[0]).toBe('test-ca');
+  expect(globalAgent.ca[1]).toBe('test-ca1');
   const response: HttpResponseType = await new Promise((resolve) => {
     https.get('https://127.0.0.1', createHttpResponseResolver(resolve));
   });
-  t.is(response.body, 'OK');
+  expect(response.body).toBe('OK');
 });
 
-serial('proxies HTTPS request', async (t) => {
-  // eslint-disable-next-line node/no-process-env
+test('proxies HTTPS request', async () => {
+  // oxlint-disable-next-line node/no-process-env
   process.env.NODE_TLS_REJECT_UNAUTHORIZED = '0';
   const globalProxyAgent = createGlobalProxyAgent();
 
@@ -545,11 +546,11 @@ serial('proxies HTTPS request', async (t) => {
     https.get('https://127.0.0.1', createHttpResponseResolver(resolve));
   });
 
-  t.is(response.body, 'OK');
+  expect(response.body).toBe('OK');
 });
 
-serial('proxies HTTPS request with proxy-authorization header', async (t) => {
-  // eslint-disable-next-line node/no-process-env
+test('proxies HTTPS request with proxy-authorization header', async () => {
+  // oxlint-disable-next-line node/no-process-env
   process.env.NODE_TLS_REJECT_UNAUTHORIZED = '0';
   const globalProxyAgent = createGlobalProxyAgent();
 
@@ -565,23 +566,23 @@ serial('proxies HTTPS request with proxy-authorization header', async (t) => {
     https.get('https://127.0.0.1', createHttpResponseResolver(resolve));
   });
 
-  t.is(response.body, 'OK');
+  expect(response.body).toBe('OK');
 
-  t.is(onConnect.firstCall.args[0].headers['proxy-authorization'], 'Basic Zm9v');
+  expect(onConnect.firstCall.args[0].headers['proxy-authorization']).toBe('Basic Zm9v');
 });
 
-serial('does not produce unhandled rejection when cannot connect to proxy', async (t) => {
+test('does not produce unhandled rejection when cannot connect to proxy', async () => {
   const globalProxyAgent = createGlobalProxyAgent();
 
   const port = await getNextPort();
 
   globalProxyAgent.HTTP_PROXY = 'http://127.0.0.1:' + port;
 
-  await t.throwsAsync(got('http://127.0.0.1'));
+  await expect(got('http://127.0.0.1')).rejects.toThrow();
 });
 
-serial('proxies HTTPS request with dedicated proxy', async (t) => {
-  // eslint-disable-next-line node/no-process-env
+test('proxies HTTPS request with dedicated proxy', async () => {
+  // oxlint-disable-next-line node/no-process-env
   process.env.NODE_TLS_REJECT_UNAUTHORIZED = '0';
   const globalProxyAgent = createGlobalProxyAgent();
 
@@ -593,10 +594,10 @@ serial('proxies HTTPS request with dedicated proxy', async (t) => {
     https.get('https://127.0.0.1', createHttpResponseResolver(resolve));
   });
 
-  t.is(response.body, 'OK');
+  expect(response.body).toBe('OK');
 });
 
-serial('ignores dedicated HTTPS proxy for HTTP urls', async (t) => {
+test('ignores dedicated HTTPS proxy for HTTP urls', async () => {
   const globalProxyAgent = createGlobalProxyAgent();
 
   const proxyServer = await createProxyServer();
@@ -608,10 +609,10 @@ serial('ignores dedicated HTTPS proxy for HTTP urls', async (t) => {
     http.get('http://127.0.0.1', {}, createHttpResponseResolver(resolve));
   });
 
-  t.is(response.body, 'OK');
+  expect(response.body).toBe('OK');
 });
 
-serial('forwards requests matching NO_PROXY', async (t) => {
+test('forwards requests matching NO_PROXY', async () => {
   const globalProxyAgent = createGlobalProxyAgent();
 
   const proxyServer = await createProxyServer();
@@ -624,10 +625,10 @@ serial('forwards requests matching NO_PROXY', async (t) => {
     http.get(httpServer.url, createHttpResponseResolver(resolve));
   });
 
-  t.is(response.body, 'DIRECT');
+  expect(response.body).toBe('DIRECT');
 });
 
-serial('forwards requests that go to a socket', async (t) => {
+test('forwards requests that go to a socket', async () => {
   const globalProxyAgent = createGlobalProxyAgent();
 
   // not relevant as traffic shouldn't go through proxy
@@ -639,9 +640,6 @@ serial('forwards requests that go to a socket', async (t) => {
     serverResponse.end();
   });
 
-  t.teardown(() => {
-    server.close();
-  });
   server.listen('/tmp/test.sock');
 
   const response: HttpResponseType = await new Promise((resolve) => {
@@ -650,10 +648,13 @@ serial('forwards requests that go to a socket', async (t) => {
       socketPath: '/tmp/test.sock',
     }, createHttpResponseResolver(resolve));
   });
-  t.is(response.body, 'OK');
+
+  server.close();
+
+  expect(response.body).toBe('OK');
 });
 
-serial('proxies HTTP request (using http.get(host))', async (t) => {
+test('proxies HTTP request (using http.get(host))', async () => {
   const globalProxyAgent = createGlobalProxyAgent();
 
   const proxyServer = await createProxyServer();
@@ -666,10 +667,10 @@ serial('proxies HTTP request (using http.get(host))', async (t) => {
     }, createHttpResponseResolver(resolve));
   });
 
-  t.is(response.body, 'OK');
+  expect(response.body).toBe('OK');
 });
 
-serial('proxies HTTP request (using got)', async (t) => {
+test('proxies HTTP request (using got)', async () => {
   const globalProxyAgent = createGlobalProxyAgent();
 
   const proxyServer = await createProxyServer();
@@ -678,11 +679,11 @@ serial('proxies HTTP request (using got)', async (t) => {
 
   const response = await got('http://127.0.0.1');
 
-  t.is(response.body, 'OK');
+  expect(response.body).toBe('OK');
 });
 
-serial('proxies HTTPS request (using got)', async (t) => {
-  // eslint-disable-next-line node/no-process-env
+test('proxies HTTPS request (using got)', async () => {
+  // oxlint-disable-next-line node/no-process-env
   process.env.NODE_TLS_REJECT_UNAUTHORIZED = '0';
   const globalProxyAgent = createGlobalProxyAgent();
 
@@ -692,10 +693,10 @@ serial('proxies HTTPS request (using got)', async (t) => {
 
   const response = await got('https://127.0.0.1');
 
-  t.is(response.body, 'OK');
+  expect(response.body).toBe('OK');
 });
 
-serial('proxies HTTP request (using axios)', async (t) => {
+test('proxies HTTP request (using axios)', async () => {
   const globalProxyAgent = createGlobalProxyAgent();
 
   const proxyServer = await createProxyServer();
@@ -704,11 +705,11 @@ serial('proxies HTTP request (using axios)', async (t) => {
 
   const response = await axios.get('http://127.0.0.1');
 
-  t.is(response.data, 'OK');
+  expect(response.data).toBe('OK');
 });
 
-serial('proxies HTTPS request (using axios)', async (t) => {
-  // eslint-disable-next-line node/no-process-env
+test('proxies HTTPS request (using axios)', async () => {
+  // oxlint-disable-next-line node/no-process-env
   process.env.NODE_TLS_REJECT_UNAUTHORIZED = '0';
   const globalProxyAgent = createGlobalProxyAgent();
 
@@ -718,10 +719,10 @@ serial('proxies HTTPS request (using axios)', async (t) => {
 
   const response = await axios.get('https://127.0.0.1');
 
-  t.is(response.data, 'OK');
+  expect(response.data).toBe('OK');
 });
 
-serial('proxies HTTP request (using request)', async (t) => {
+test('proxies HTTP request (using request)', async () => {
   const globalProxyAgent = createGlobalProxyAgent();
 
   const proxyServer = await createProxyServer();
@@ -730,17 +731,17 @@ serial('proxies HTTP request (using request)', async (t) => {
 
   const response = await new Promise((resolve) => {
     makeRequest('http://127.0.0.1', (error, requestResponse, body) => {
-      t.is(error, null);
+      expect(error).toBe(null);
 
       resolve(body);
     });
   });
 
-  t.is(response, 'OK');
+  expect(response).toBe('OK');
 });
 
-serial('proxies HTTPS request (using request)', async (t) => {
-  // eslint-disable-next-line node/no-process-env
+test('proxies HTTPS request (using request)', async () => {
+  // oxlint-disable-next-line node/no-process-env
   process.env.NODE_TLS_REJECT_UNAUTHORIZED = '0';
   const globalProxyAgent = createGlobalProxyAgent();
 
@@ -750,11 +751,11 @@ serial('proxies HTTPS request (using request)', async (t) => {
 
   const response = await new Promise((resolve) => {
     makeRequest('https://127.0.0.1', (error, requestResponse, body) => {
-      t.is(error, null);
+      expect(error).toBe(null);
 
       resolve(body);
     });
   });
 
-  t.is(response, 'OK');
+  expect(response).toBe('OK');
 });

package/src/factories/createGlobalProxyAgent.ts

@@ -45,7 +45,7 @@ const defaultConfigurationInput = {
 };
 
 const createConfiguration = (configurationInput: ProxyAgentConfigurationInputType): ProxyAgentConfigurationType => {
-  // eslint-disable-next-line node/no-process-env
+  // oxlint-disable-next-line node/no-process-env
   const environment = process.env;
 
   const defaultConfiguration = {
@@ -69,13 +69,13 @@ export default (configurationInput: ProxyAgentConfigurationInputType = defaultCo
 
   const proxyController = createProxyController();
 
-  // eslint-disable-next-line node/no-process-env
+  // oxlint-disable-next-line node/no-process-env
   proxyController.HTTP_PROXY = process.env[configuration.environmentVariableNamespace + 'HTTP_PROXY'] ?? null;
 
-  // eslint-disable-next-line node/no-process-env
+  // oxlint-disable-next-line node/no-process-env
   proxyController.HTTPS_PROXY = process.env[configuration.environmentVariableNamespace + 'HTTPS_PROXY'] ?? null;
 
-  // eslint-disable-next-line node/no-process-env
+  // oxlint-disable-next-line node/no-process-env
   proxyController.NO_PROXY = process.env[configuration.environmentVariableNamespace + 'NO_PROXY'] ?? null;
 
   log.info({

package/src/factories/createProxyController.test.ts

@@ -0,0 +1,38 @@
+import {
+  expect,
+  test,
+} from 'vitest';
+import createProxyController from './createProxyController';
+
+test('sets HTTP_PROXY', () => {
+  const globalAgentGlobal = createProxyController();
+
+  globalAgentGlobal.HTTP_PROXY = 'http://127.0.0.1';
+
+  expect(globalAgentGlobal.HTTP_PROXY).toBe('http://127.0.0.1');
+});
+
+test('sets HTTPS_PROXY', () => {
+  const globalAgentGlobal = createProxyController();
+
+  globalAgentGlobal.HTTPS_PROXY = 'http://127.0.0.1';
+
+  expect(globalAgentGlobal.HTTPS_PROXY).toBe('http://127.0.0.1');
+});
+
+test('sets NO_PROXY', () => {
+  const globalAgentGlobal = createProxyController();
+
+  globalAgentGlobal.NO_PROXY = '*';
+
+  expect(globalAgentGlobal.NO_PROXY).toBe('*');
+});
+
+test('throws an error if unknown property is set', () => {
+  const globalAgentGlobal = createProxyController();
+
+  expect(() => {
+    // @ts-expect-error expected unknown property.
+    globalAgentGlobal.FOO = 'BAR';
+  }).toThrow('Cannot set an unmapped property "FOO".');
+});

package/src/factories/createProxyController.ts

@@ -19,7 +19,7 @@ const KNOWN_PROPERTY_NAMES = [
 ];
 
 export default (): ProxyController => {
-  // eslint-disable-next-line fp/no-proxy
+  // oxlint-disable-next-line fp/no-proxy
   return new Proxy({
     HTTP_PROXY: null,
     HTTPS_PROXY: null,

package/src/utilities/isUrlMatchingNoProxy.test.ts

@@ -0,0 +1,77 @@
+import {
+  expect,
+  test,
+} from 'vitest';
+import isUrlMatchingNoProxy from './isUrlMatchingNoProxy';
+
+test('returns `true` if hosts match', () => {
+  expect(isUrlMatchingNoProxy('http://foo.com/', 'foo.com')).toBe(true);
+});
+
+test('returns `true` if hosts match (IP)', () => {
+  expect(isUrlMatchingNoProxy('http://127.0.0.1/', '127.0.0.1')).toBe(true);
+});
+
+test('returns `true` if hosts match (using asterisk wildcard)', () => {
+  expect(isUrlMatchingNoProxy('http://bar.foo.com/', '*.foo.com')).toBe(true);
+});
+
+test('returns `true` if domain matches (using dot wildcard)', () => {
+  expect(isUrlMatchingNoProxy('http://foo.com/', '.foo.com')).toBe(true);
+});
+
+test('returns `true` if subdomain matches (using dot wildcard)', () => {
+  expect(isUrlMatchingNoProxy('http://bar.foo.com/', '.foo.com')).toBe(true);
+});
+
+test('returns `true` if hosts match (*) and ports match', () => {
+  expect(isUrlMatchingNoProxy('http://foo.com:8080/', '*:8080')).toBe(true);
+});
+
+test('returns `true` if hosts and ports match', () => {
+  expect(isUrlMatchingNoProxy('http://foo.com:8080/', 'foo.com:8080')).toBe(true);
+});
+
+test('returns `true` if hosts match and NO_PROXY does not define port', () => {
+  expect(isUrlMatchingNoProxy('http://foo.com:8080/', 'foo.com')).toBe(true);
+});
+
+test('returns `true` if hosts (IP) and ports match', () => {
+  expect(isUrlMatchingNoProxy('http://127.0.0.1:8080/', '127.0.0.1:8080')).toBe(true);
+});
+
+test('returns `false` if hosts match and ports do not match (diffferent port)', () => {
+  expect(isUrlMatchingNoProxy('http://foo.com:8080/', 'foo.com:8000')).toBe(false);
+});
+
+test('returns `false` if hosts match and ports do not match (port not present subject)', () => {
+  expect(isUrlMatchingNoProxy('http://foo.com/', 'foo.com:8000')).toBe(false);
+});
+
+test('returns `true` if hosts match and ports do not match (port not present NO_PROXY)', () => {
+  expect(isUrlMatchingNoProxy('http://foo.com:8000/', 'foo.com')).toBe(true);
+});
+
+test('returns `true` if hosts match in one of multiple rules separated with a comma', () => {
+  expect(isUrlMatchingNoProxy('http://foo.com/', 'bar.org,foo.com,baz.io')).toBe(true);
+});
+
+test('returns `true` if hosts match in one of multiple rules separated with a comma and a space', () => {
+  expect(isUrlMatchingNoProxy('http://foo.com/', 'bar.org, foo.com, baz.io')).toBe(true);
+});
+
+test('returns `true` if hosts match in one of multiple rules separated with a space', () => {
+  expect(isUrlMatchingNoProxy('http://foo.com/', 'bar.org foo.com baz.io')).toBe(true);
+});
+
+test('handles trailing newline in NO_PROXY', () => {
+  expect(isUrlMatchingNoProxy('http://foo.com/', 'foo.com\n')).toBe(true);
+});
+
+test('handles trailing whitespace in NO_PROXY', () => {
+  expect(isUrlMatchingNoProxy('http://foo.com/', 'foo.com   ')).toBe(true);
+});
+
+test('handles leading whitespace in NO_PROXY', () => {
+  expect(isUrlMatchingNoProxy('http://foo.com/', '  foo.com')).toBe(true);
+});

package/src/utilities/isUrlMatchingNoProxy.ts

@@ -6,7 +6,7 @@ import {
 export default (subjectUrl: string, noProxy: string) => {
   const subjectUrlTokens = new URL(subjectUrl);
 
-  const rules = noProxy.split(/[\s,]+/);
+  const rules = noProxy.split(/[\s,]+/).filter(Boolean);
 
   for (const rule of rules) {
     const ruleMatch = rule

package/src/utilities/parseProxyUrl.test.ts

@@ -0,0 +1,35 @@
+import {
+  expect,
+  test,
+} from 'vitest';
+import parseProxyUrl from './parseProxyUrl';
+
+test('extracts hostname', () => {
+  expect(parseProxyUrl('http://0.0.0.0').hostname).toBe('0.0.0.0');
+});
+
+test('extracts port', () => {
+  expect(parseProxyUrl('http://0.0.0.0:3000').port).toBe(3_000);
+});
+
+test('extracts authorization', () => {
+  expect(parseProxyUrl('http://foo:bar@0.0.0.0').authorization).toBe('foo:bar');
+});
+
+test('throws an error if protocol is not "http:"', () => {
+  expect(() => {
+    parseProxyUrl('https://0.0.0.0:3000');
+  }).toThrow('Unsupported `GLOBAL_AGENT.HTTP_PROXY` configuration value: URL protocol must be "http:".');
+});
+
+test('throws an error if query is present', () => {
+  expect(() => {
+    parseProxyUrl('http://0.0.0.0:3000/?foo=bar');
+  }).toThrow('Unsupported `GLOBAL_AGENT.HTTP_PROXY` configuration value: URL must not have query.');
+});
+
+test('throws an error if hash is present', () => {
+  expect(() => {
+    parseProxyUrl('http://0.0.0.0:3000/#foo');
+  }).toThrow('Unsupported `GLOBAL_AGENT.HTTP_PROXY` configuration value: URL must not have hash.');
+});

package/vitest.config.ts

@@ -0,0 +1,11 @@
+import {defineConfig} from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    include: ['src/**/*.test.ts'],
+    isolate: false,
+    sequence: {
+      concurrent: false,
+    },
+  },
+});

package/.eslintignore

@@ -1 +0,0 @@
-/bootstrap.js

package/.eslintrc

@@ -1,27 +0,0 @@
-{
-  "extends": [
-    "canonical",
-    "canonical/node",
-    "canonical/typescript"
-  ],
-  "parserOptions": {
-    "project": "./tsconfig.json"
-  },
-  "root": true,
-  "rules": {
-    "@typescript-eslint/prefer-regexp-exec": 0,
-    "class-methods-use-this": 0,
-    "fp/no-class": 0,
-    "fp/no-events": 0,
-    "fp/no-this": 0,
-    "import/no-cycle": 0,
-    "no-continue": 0,
-    "no-restricted-syntax": 0,
-    "no-unused-expressions": [
-      2,
-      {
-        "allowTaggedTemplates": true
-      }
-    ]
-  }
-}

package/test/.eslintrc

@@ -1,10 +0,0 @@
-{
-  "rules": {
-    "ava/use-test": 0,
-    "filenames/match-regex": 0,
-    "flowtype/no-flow-fix-me-comments": 0,
-    "flowtype/no-weak-types": 0,
-    "id-length": 0,
-    "node/no-unpublished-import": 0
-  }
-}

package/test/global-agent/factories/createProxyController.ts

@@ -1,37 +0,0 @@
-import test from 'ava';
-import createProxyController from '../../../src/factories/createProxyController';
-
-test('sets HTTP_PROXY', (t) => {
-  const globalAgentGlobal = createProxyController();
-
-  globalAgentGlobal.HTTP_PROXY = 'http://127.0.0.1';
-
-  t.is(globalAgentGlobal.HTTP_PROXY, 'http://127.0.0.1');
-});
-
-test('sets HTTPS_PROXY', (t) => {
-  const globalAgentGlobal = createProxyController();
-
-  globalAgentGlobal.HTTPS_PROXY = 'http://127.0.0.1';
-
-  t.is(globalAgentGlobal.HTTPS_PROXY, 'http://127.0.0.1');
-});
-
-test('sets NO_PROXY', (t) => {
-  const globalAgentGlobal = createProxyController();
-
-  globalAgentGlobal.NO_PROXY = '*';
-
-  t.is(globalAgentGlobal.NO_PROXY, '*');
-});
-
-test('throws an error if unknown property is set', (t) => {
-  const globalAgentGlobal = createProxyController();
-
-  const error = t.throws(() => {
-    // @ts-expect-error expected unknown property.
-    globalAgentGlobal.FOO = 'BAR';
-  });
-
-  t.is(error.message, 'Cannot set an unmapped property "FOO".');
-});

package/test/global-agent/utilities/isUrlMatchingNoProxy.ts

@@ -1,62 +0,0 @@
-import test from 'ava';
-import isUrlMatchingNoProxy from '../../../src/utilities/isUrlMatchingNoProxy';
-
-test('returns `true` if hosts match', (t) => {
-  t.assert(isUrlMatchingNoProxy('http://foo.com/', 'foo.com'));
-});
-
-test('returns `true` if hosts match (IP)', (t) => {
-  t.assert(isUrlMatchingNoProxy('http://127.0.0.1/', '127.0.0.1'));
-});
-
-test('returns `true` if hosts match (using asterisk wildcard)', (t) => {
-  t.assert(isUrlMatchingNoProxy('http://bar.foo.com/', '*.foo.com'));
-});
-
-test('returns `true` if domain matches (using dot wildcard)', (t) => {
-  t.assert(isUrlMatchingNoProxy('http://foo.com/', '.foo.com'));
-});
-
-test('returns `true` if subdomain matches (using dot wildcard)', (t) => {
-  t.assert(isUrlMatchingNoProxy('http://bar.foo.com/', '.foo.com'));
-});
-
-test('returns `true` if hosts match (*) and ports match', (t) => {
-  t.assert(isUrlMatchingNoProxy('http://foo.com:8080/', '*:8080'));
-});
-
-test('returns `true` if hosts and ports match', (t) => {
-  t.assert(isUrlMatchingNoProxy('http://foo.com:8080/', 'foo.com:8080'));
-});
-
-test('returns `true` if hosts match and NO_PROXY does not define port', (t) => {
-  t.assert(isUrlMatchingNoProxy('http://foo.com:8080/', 'foo.com'));
-});
-
-test('returns `true` if hosts (IP) and ports match', (t) => {
-  t.assert(isUrlMatchingNoProxy('http://127.0.0.1:8080/', '127.0.0.1:8080'));
-});
-
-test('returns `false` if hosts match and ports do not match (diffferent port)', (t) => {
-  t.assert(isUrlMatchingNoProxy('http://foo.com:8080/', 'foo.com:8000') === false);
-});
-
-test('returns `false` if hosts match and ports do not match (port not present subject)', (t) => {
-  t.assert(isUrlMatchingNoProxy('http://foo.com/', 'foo.com:8000') === false);
-});
-
-test('returns `true` if hosts match and ports do not match (port not present NO_PROXY)', (t) => {
-  t.assert(isUrlMatchingNoProxy('http://foo.com:8000/', 'foo.com'));
-});
-
-test('returns `true` if hosts match in one of multiple rules separated with a comma', (t) => {
-  t.assert(isUrlMatchingNoProxy('http://foo.com/', 'bar.org,foo.com,baz.io'));
-});
-
-test('returns `true` if hosts match in one of multiple rules separated with a comma and a space', (t) => {
-  t.assert(isUrlMatchingNoProxy('http://foo.com/', 'bar.org, foo.com, baz.io'));
-});
-
-test('returns `true` if hosts match in one of multiple rules separated with a space', (t) => {
-  t.assert(isUrlMatchingNoProxy('http://foo.com/', 'bar.org foo.com baz.io'));
-});

package/test/global-agent/utilities/parseProxyUrl.ts

@@ -1,38 +0,0 @@
-import test from 'ava';
-import parseProxyUrl from '../../../src/utilities/parseProxyUrl';
-
-test('extracts hostname', (t) => {
-  t.is(parseProxyUrl('http://0.0.0.0').hostname, '0.0.0.0');
-});
-
-test('extracts port', (t) => {
-  t.is(parseProxyUrl('http://0.0.0.0:3000').port, 3_000);
-});
-
-test('extracts authorization', (t) => {
-  t.is(parseProxyUrl('http://foo:bar@0.0.0.0').authorization, 'foo:bar');
-});
-
-test('throws an error if protocol is not "http:"', (t) => {
-  const error = t.throws(() => {
-    parseProxyUrl('https://0.0.0.0:3000');
-  });
-
-  t.is(error.message, 'Unsupported `GLOBAL_AGENT.HTTP_PROXY` configuration value: URL protocol must be "http:".');
-});
-
-test('throws an error if query is present', (t) => {
-  const error = t.throws(() => {
-    parseProxyUrl('http://0.0.0.0:3000/?foo=bar');
-  });
-
-  t.is(error.message, 'Unsupported `GLOBAL_AGENT.HTTP_PROXY` configuration value: URL must not have query.');
-});
-
-test('throws an error if hash is present', (t) => {
-  const error = t.throws(() => {
-    parseProxyUrl('http://0.0.0.0:3000/#foo');
-  });
-
-  t.is(error.message, 'Unsupported `GLOBAL_AGENT.HTTP_PROXY` configuration value: URL must not have hash.');
-});