[LevK]: Build and test as a standalone package

Split out of actions/toolkit (packages/http-client, history kept by filter-repo).
Brings the 2024 [LevK] packaging edits forward onto current upstream:

- tsconfig.json: the monorepo root's compiler options inlined, no extends
- jest.config.cjs: the root's ts-jest transform, rooted at tests/
  (isolatedModules: ESM lib/ and sources run through CommonJS)
- __tests__/ -> tests/
- package.json: test = jest, build = tsc; jest/ts-jest/typescript as
  devDependencies; repository, homepage, bugs on git.levk.dev
- .gitignore: node_modules/, lib/, audit.json
- HttpCodes.PayloadTooLarge = 413 (the 2024 edit; still missing upstream)

Not carried over from 2024: the _getExistingOrDefaultHeader type
narrowing (upstream has since fixed it properly), version reset to 1.0.0 (dependents' ranges
need upstream's numbering) and the Unlicense field (the code is MIT).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01UHXzGrsxfkGk8LmwrBbHNZ

tests/auth.test.ts

@@ -0,0 +1,72 @@
+import * as httpm from '../lib'
+import * as am from '../lib/auth'
+
+describe('auth', () => {
+  beforeEach(() => {})
+
+  afterEach(() => {})
+
+  it('does basic http get request with basic auth', async () => {
+    const bh: am.BasicCredentialHandler = new am.BasicCredentialHandler(
+      'johndoe',
+      'password'
+    )
+    const http: httpm.HttpClient = new httpm.HttpClient('http-client-tests', [
+      bh
+    ])
+    const res: httpm.HttpClientResponse = await http.get(
+      'https://postman-echo.com/get'
+    )
+    expect(res.message.statusCode).toBe(200)
+    const body: string = await res.readBody()
+    const obj = JSON.parse(body)
+    const auth: string = obj.headers.authorization
+    const creds: string = Buffer.from(
+      auth.substring('Basic '.length),
+      'base64'
+    ).toString()
+    expect(creds).toBe('johndoe:password')
+    expect(obj.url).toBe('https://postman-echo.com/get')
+  })
+
+  it('does basic http get request with pat token auth', async () => {
+    const token = 'scbfb44vxzku5l4xgc3qfazn3lpk4awflfryc76esaiq7aypcbhs'
+    const ph: am.PersonalAccessTokenCredentialHandler =
+      new am.PersonalAccessTokenCredentialHandler(token)
+
+    const http: httpm.HttpClient = new httpm.HttpClient('http-client-tests', [
+      ph
+    ])
+    const res: httpm.HttpClientResponse = await http.get(
+      'https://postman-echo.com/get'
+    )
+    expect(res.message.statusCode).toBe(200)
+    const body: string = await res.readBody()
+    const obj = JSON.parse(body)
+    const auth: string = obj.headers.authorization
+    const creds: string = Buffer.from(
+      auth.substring('Basic '.length),
+      'base64'
+    ).toString()
+    expect(creds).toBe(`PAT:${token}`)
+    expect(obj.url).toBe('https://postman-echo.com/get')
+  })
+
+  it('does basic http get request with pat token auth', async () => {
+    const token = 'scbfb44vxzku5l4xgc3qfazn3lpk4awflfryc76esaiq7aypcbhs'
+    const ph: am.BearerCredentialHandler = new am.BearerCredentialHandler(token)
+
+    const http: httpm.HttpClient = new httpm.HttpClient('http-client-tests', [
+      ph
+    ])
+    const res: httpm.HttpClientResponse = await http.get(
+      'https://postman-echo.com/get'
+    )
+    expect(res.message.statusCode).toBe(200)
+    const body: string = await res.readBody()
+    const obj = JSON.parse(body)
+    const auth: string = obj.headers.authorization
+    expect(auth).toBe(`Bearer ${token}`)
+    expect(obj.url).toBe('https://postman-echo.com/get')
+  })
+})

tests/basics.test.ts

@@ -0,0 +1,444 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+import * as httpm from '..'
+import * as path from 'path'
+import * as fs from 'fs'
+
+const sampleFilePath: string = path.join(__dirname, 'testoutput.txt')
+
+interface HttpBinData {
+  url: string
+  data: any
+  json: any
+  headers: any
+  args?: any
+}
+
+describe('basics', () => {
+  let _http: httpm.HttpClient
+
+  beforeEach(() => {
+    _http = new httpm.HttpClient('http-client-tests')
+  })
+
+  afterEach(() => {
+    // Clean up environment variable to prevent test pollution
+    delete process.env['ACTIONS_ORCHESTRATION_ID']
+  })
+
+  it('constructs', () => {
+    const http: httpm.HttpClient = new httpm.HttpClient('thttp-client-tests')
+    expect(http).toBeDefined()
+  })
+
+  // responses from httpbin return something like:
+  // {
+  //     "args": {},
+  //     "headers": {
+  //       "Connection": "close",
+  //       "Host": "postman-echo.com",
+  //       "user-agent": "typed-test-client-tests"
+  //     },
+  //     "origin": "173.95.152.44",
+  //     "url": "https://postman-echo.com/get"
+  //  }
+
+  it('does basic http get request', async () => {
+    const res: httpm.HttpClientResponse = await _http.get(
+      'https://postman-echo.com/get'
+    )
+    expect(res.message.statusCode).toBe(200)
+    const body: string = await res.readBody()
+    const obj = JSON.parse(body)
+    expect(obj.url).toBe('https://postman-echo.com/get')
+    expect(obj.headers['user-agent']).toBeTruthy()
+  })
+
+  it('does basic http get request with no user agent', async () => {
+    const http: httpm.HttpClient = new httpm.HttpClient()
+    const res: httpm.HttpClientResponse = await http.get(
+      'https://postman-echo.com/get'
+    )
+    expect(res.message.statusCode).toBe(200)
+    const body: string = await res.readBody()
+    const obj = JSON.parse(body)
+    expect(obj.url).toBe('https://postman-echo.com/get')
+    expect(obj.headers['user-agent']).toBe('actions/http-client')
+  })
+
+  /* TODO write a mock rather then relying on a third party
+  it('does basic https get request', async () => {
+    const res: httpm.HttpClientResponse = await _http.get(
+      'https://postman-echo.com/get'
+    )
+    expect(res.message.statusCode).toBe(200)
+    const body: string = await res.readBody()
+    const obj = JSON.parse(body)
+    expect(obj.url).toBe('https://postman-echo.com/get')
+  })
+*/
+  it('does basic http get request with default headers', async () => {
+    const http: httpm.HttpClient = new httpm.HttpClient(
+      'http-client-tests',
+      [],
+      {
+        headers: {
+          Accept: 'application/json',
+          'Content-Type': 'application/json'
+        }
+      }
+    )
+    const res: httpm.HttpClientResponse = await http.get(
+      'https://postman-echo.com/get'
+    )
+    expect(res.message.statusCode).toBe(200)
+    const body: string = await res.readBody()
+    const obj = JSON.parse(body)
+    expect(obj.headers.accept).toBe('application/json')
+    expect(obj.headers['content-type']).toBe('application/json')
+    expect(obj.url).toBe('https://postman-echo.com/get')
+  })
+
+  it('does basic http get request with merged headers', async () => {
+    const http: httpm.HttpClient = new httpm.HttpClient(
+      'http-client-tests',
+      [],
+      {
+        headers: {
+          Accept: 'application/json',
+          'Content-Type': 'application/json'
+        }
+      }
+    )
+    const res: httpm.HttpClientResponse = await http.get(
+      'https://postman-echo.com/get',
+      {
+        'content-type': 'application/x-www-form-urlencoded'
+      }
+    )
+    expect(res.message.statusCode).toBe(200)
+    const body: string = await res.readBody()
+    const obj = JSON.parse(body)
+    expect(obj.headers.accept).toBe('application/json')
+    expect(obj.headers['content-type']).toBe(
+      'application/x-www-form-urlencoded'
+    )
+    expect(obj.url).toBe('https://postman-echo.com/get')
+  })
+
+  it('pipes a get request', async () => {
+    return new Promise<void>(async resolve => {
+      const file = fs.createWriteStream(sampleFilePath)
+      ;(await _http.get('https://postman-echo.com/get')).message
+        .pipe(file)
+        .on('close', () => {
+          const body: string = fs.readFileSync(sampleFilePath).toString()
+          const obj = JSON.parse(body)
+          expect(obj.url).toBe('https://postman-echo.com/get')
+          resolve()
+        })
+    })
+  })
+
+  it('does basic get request with redirects', async () => {
+    const res: httpm.HttpClientResponse = await _http.get(
+      `https://postman-echo.com/redirect-to?url=${encodeURIComponent(
+        'https://postman-echo.com/get'
+      )}`
+    )
+    expect(res.message.statusCode).toBe(200)
+    const body: string = await res.readBody()
+    const obj = JSON.parse(body)
+    expect(obj.url).toBe('https://postman-echo.com/get')
+  })
+
+  it('does basic get request with redirects (303)', async () => {
+    const res: httpm.HttpClientResponse = await _http.get(
+      `https://postman-echo.com/redirect-to?url=${encodeURIComponent(
+        'https://postman-echo.com/get'
+      )}&status_code=303`
+    )
+    expect(res.message.statusCode).toBe(200)
+    const body: string = await res.readBody()
+    const obj = JSON.parse(body)
+    expect(obj.url).toBe('https://postman-echo.com/get')
+  })
+
+  it('returns 404 for not found get request on redirect', async () => {
+    const res: httpm.HttpClientResponse = await _http.get(
+      `https://postman-echo.com/redirect-to?url=${encodeURIComponent(
+        'https://postman-echo.com/status/404'
+      )}&status_code=303`
+    )
+    expect(res.message.statusCode).toBe(404)
+    await res.readBody()
+  })
+
+  it('does not follow redirects if disabled', async () => {
+    const http: httpm.HttpClient = new httpm.HttpClient(
+      'typed-test-client-tests',
+      undefined,
+      {allowRedirects: false}
+    )
+    const res: httpm.HttpClientResponse = await http.get(
+      `https://postman-echo.com/redirect-to?url=${encodeURIComponent(
+        'https://postman-echo.com/get'
+      )}`
+    )
+    expect(res.message.statusCode).toBe(302)
+    await res.readBody()
+  })
+
+  it('does not pass auth with diff hostname redirects', async () => {
+    const headers = {
+      accept: 'application/json',
+      authorization: 'shhh'
+    }
+    const res: httpm.HttpClientResponse = await _http.get(
+      `https://postman-echo.com/redirect-to?url=${encodeURIComponent(
+        'https://www.postman-echo.com/get'
+      )}`,
+      headers
+    )
+
+    expect(res.message.statusCode).toBe(200)
+    const body: string = await res.readBody()
+    const obj = JSON.parse(body)
+    // httpbin "fixes" the casing
+    expect(obj.headers[httpm.Headers.Accept]).toBe('application/json')
+    expect(obj.headers['Authorization']).toBeUndefined()
+    expect(obj.headers['authorization']).toBeUndefined()
+    expect(obj.url).toBe('https://www.postman-echo.com/get')
+  })
+
+  it('does not pass Auth with diff hostname redirects', async () => {
+    const headers = {
+      Accept: 'application/json',
+      Authorization: 'shhh'
+    }
+    const res: httpm.HttpClientResponse = await _http.get(
+      `https://postman-echo.com/redirect-to?url=${encodeURIComponent(
+        'https://www.postman-echo.com/get'
+      )}`,
+      headers
+    )
+
+    expect(res.message.statusCode).toBe(200)
+    const body: string = await res.readBody()
+    const obj = JSON.parse(body)
+    // httpbin "fixes" the casing
+    expect(obj.headers[httpm.Headers.Accept]).toBe('application/json')
+    expect(obj.headers['Authorization']).toBeUndefined()
+    expect(obj.headers['authorization']).toBeUndefined()
+    expect(obj.url).toBe('https://www.postman-echo.com/get')
+  })
+
+  it('does basic head request', async () => {
+    const res: httpm.HttpClientResponse = await _http.head(
+      'https://postman-echo.com/get'
+    )
+    expect(res.message.statusCode).toBe(200)
+    // Consume the response to close the socket
+    res.message.destroy()
+  })
+
+  it('does basic http delete request', async () => {
+    const res: httpm.HttpClientResponse = await _http.del(
+      'https://postman-echo.com/delete'
+    )
+    expect(res.message.statusCode).toBe(200)
+    const body: string = await res.readBody()
+    JSON.parse(body)
+  })
+
+  it('does basic http post request', async () => {
+    const b = 'Hello World!'
+    const res: httpm.HttpClientResponse = await _http.post(
+      'https://postman-echo.com/post',
+      b
+    )
+    expect(res.message.statusCode).toBe(200)
+    const body: string = await res.readBody()
+    const obj = JSON.parse(body)
+    expect(obj.data).toBe(b)
+    expect(obj.url).toBe('https://postman-echo.com/post')
+  })
+
+  it('does basic http patch request', async () => {
+    const b = 'Hello World!'
+    const res: httpm.HttpClientResponse = await _http.patch(
+      'https://postman-echo.com/patch',
+      b
+    )
+    expect(res.message.statusCode).toBe(200)
+    const body: string = await res.readBody()
+    const obj = JSON.parse(body)
+    expect(obj.data).toBe(b)
+    expect(obj.url).toBe('https://postman-echo.com/patch')
+  })
+
+  it('does basic http options request', async () => {
+    const res: httpm.HttpClientResponse = await _http.options(
+      'https://postman-echo.com'
+    )
+    expect(res.message.statusCode).toBe(200)
+    await res.readBody()
+  })
+
+  it('returns 404 for not found get request', async () => {
+    const res: httpm.HttpClientResponse = await _http.get(
+      'https://postman-echo.com/status/404'
+    )
+    expect(res.message.statusCode).toBe(404)
+    await res.readBody()
+  })
+
+  it('gets a json object', async () => {
+    const jsonObj = await _http.getJson<HttpBinData>(
+      'https://postman-echo.com/get'
+    )
+    expect(jsonObj.statusCode).toBe(200)
+    expect(jsonObj.result).toBeDefined()
+    expect(jsonObj.result?.url).toBe('https://postman-echo.com/get')
+    expect(jsonObj.result?.headers[httpm.Headers.Accept]).toBe(
+      httpm.MediaTypes.ApplicationJson
+    )
+    expect(jsonObj.headers['content-type']).toContain(
+      httpm.MediaTypes.ApplicationJson
+    )
+  })
+
+  it('getting a non existent json object returns null', async () => {
+    const jsonObj = await _http.getJson<HttpBinData>(
+      'https://postman-echo.com/status/404'
+    )
+    expect(jsonObj.statusCode).toBe(404)
+    expect(jsonObj.result).toBeNull()
+  })
+
+  it('posts a json object', async () => {
+    const res = {name: 'foo'}
+    const restRes = await _http.postJson<HttpBinData>(
+      'https://postman-echo.com/post',
+      res
+    )
+    expect(restRes.statusCode).toBe(200)
+    expect(restRes.result).toBeDefined()
+    expect(restRes.result?.url).toBe('https://postman-echo.com/post')
+    expect(restRes.result?.json.name).toBe('foo')
+    expect(restRes.result?.headers[httpm.Headers.Accept]).toBe(
+      httpm.MediaTypes.ApplicationJson
+    )
+    expect(restRes.result?.headers['content-type']).toBe(
+      httpm.MediaTypes.ApplicationJson
+    )
+    expect(restRes.headers['content-type']).toContain(
+      httpm.MediaTypes.ApplicationJson
+    )
+  })
+
+  it('puts a json object', async () => {
+    const res = {name: 'foo'}
+    const restRes = await _http.putJson<HttpBinData>(
+      'https://postman-echo.com/put',
+      res
+    )
+    expect(restRes.statusCode).toBe(200)
+    expect(restRes.result).toBeDefined()
+    expect(restRes.result?.url).toBe('https://postman-echo.com/put')
+    expect(restRes.result?.json.name).toBe('foo')
+
+    expect(restRes.result?.headers[httpm.Headers.Accept]).toBe(
+      httpm.MediaTypes.ApplicationJson
+    )
+    expect(restRes.result?.headers['content-type']).toBe(
+      httpm.MediaTypes.ApplicationJson
+    )
+    expect(restRes.headers['content-type']).toContain(
+      httpm.MediaTypes.ApplicationJson
+    )
+  })
+
+  it('patch a json object', async () => {
+    const res = {name: 'foo'}
+    const restRes = await _http.patchJson<HttpBinData>(
+      'https://postman-echo.com/patch',
+      res
+    )
+    expect(restRes.statusCode).toBe(200)
+    expect(restRes.result).toBeDefined()
+    expect(restRes.result?.url).toBe('https://postman-echo.com/patch')
+    expect(restRes.result?.json.name).toBe('foo')
+    expect(restRes.result?.headers[httpm.Headers.Accept]).toBe(
+      httpm.MediaTypes.ApplicationJson
+    )
+    expect(restRes.result?.headers['content-type']).toBe(
+      httpm.MediaTypes.ApplicationJson
+    )
+    expect(restRes.headers['content-type']).toContain(
+      httpm.MediaTypes.ApplicationJson
+    )
+  })
+
+  it('appends orchestration ID to user-agent when ACTIONS_ORCHESTRATION_ID is set', async () => {
+    const orchId = 'test-orch-id-12345'
+    process.env['ACTIONS_ORCHESTRATION_ID'] = orchId
+
+    const http: httpm.HttpClient = new httpm.HttpClient('http-client-tests')
+    const res: httpm.HttpClientResponse = await http.get(
+      'https://postman-echo.com/get'
+    )
+    expect(res.message.statusCode).toBe(200)
+    const body: string = await res.readBody()
+    const obj = JSON.parse(body)
+    expect(obj.headers['user-agent']).toBe(
+      `http-client-tests actions_orchestration_id/${orchId}`
+    )
+  })
+
+  it('sanitizes invalid characters in orchestration ID', async () => {
+    const orchId = 'test (with) special/chars'
+    process.env['ACTIONS_ORCHESTRATION_ID'] = orchId
+
+    const http: httpm.HttpClient = new httpm.HttpClient('http-client-tests')
+    const res: httpm.HttpClientResponse = await http.get(
+      'https://postman-echo.com/get'
+    )
+    expect(res.message.statusCode).toBe(200)
+    const body: string = await res.readBody()
+    const obj = JSON.parse(body)
+    // Spaces, parentheses, and slashes should be replaced with underscores
+    expect(obj.headers['user-agent']).toBe(
+      'http-client-tests actions_orchestration_id/test__with__special_chars'
+    )
+  })
+
+  it('does not modify user-agent when ACTIONS_ORCHESTRATION_ID is not set', async () => {
+    delete process.env['ACTIONS_ORCHESTRATION_ID']
+
+    const http: httpm.HttpClient = new httpm.HttpClient('http-client-tests')
+    const res: httpm.HttpClientResponse = await http.get(
+      'https://postman-echo.com/get'
+    )
+    expect(res.message.statusCode).toBe(200)
+    const body: string = await res.readBody()
+    const obj = JSON.parse(body)
+    expect(obj.headers['user-agent']).toBe('http-client-tests')
+  })
+
+  it('uses default user-agent with orchestration ID when no custom user-agent provided', async () => {
+    const orchId = 'test-default-id-12345'
+    process.env['ACTIONS_ORCHESTRATION_ID'] = orchId
+
+    const http: httpm.HttpClient = new httpm.HttpClient()
+    const res: httpm.HttpClientResponse = await http.get(
+      'https://postman-echo.com/get'
+    )
+    expect(res.message.statusCode).toBe(200)
+    const body: string = await res.readBody()
+    const obj = JSON.parse(body)
+    expect(obj.headers['user-agent']).toBe(
+      `actions/http-client actions_orchestration_id/${orchId}`
+    )
+  })
+})

tests/headers.test.ts

@@ -0,0 +1,119 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+import * as httpm from '..'
+
+describe('headers', () => {
+  let _http: httpm.HttpClient
+
+  beforeEach(() => {
+    _http = new httpm.HttpClient('http-client-tests')
+  })
+
+  it('preserves existing headers on getJson', async () => {
+    const additionalHeaders = {[httpm.Headers.Accept]: 'foo'}
+    let jsonObj = await _http.getJson<any>(
+      'https://postman-echo.com/get',
+      additionalHeaders
+    )
+    expect(jsonObj.result.headers[httpm.Headers.Accept]).toBe('foo')
+    expect(jsonObj.headers[httpm.Headers.ContentType]).toContain(
+      httpm.MediaTypes.ApplicationJson
+    )
+
+    const httpWithHeaders = new httpm.HttpClient()
+    httpWithHeaders.requestOptions = {
+      headers: {
+        [httpm.Headers.Accept]: 'baz'
+      }
+    }
+    jsonObj = await httpWithHeaders.getJson<any>('https://postman-echo.com/get')
+    expect(jsonObj.result.headers[httpm.Headers.Accept]).toBe('baz')
+    expect(jsonObj.headers[httpm.Headers.ContentType]).toContain(
+      httpm.MediaTypes.ApplicationJson
+    )
+  })
+
+  it('preserves existing headers on postJson', async () => {
+    const additionalHeaders = {[httpm.Headers.Accept]: 'foo'}
+    let jsonObj = await _http.postJson<any>(
+      'https://postman-echo.com/post',
+      {},
+      additionalHeaders
+    )
+    expect(jsonObj.result.headers[httpm.Headers.Accept]).toBe('foo')
+    expect(jsonObj.headers[httpm.Headers.ContentType]).toContain(
+      httpm.MediaTypes.ApplicationJson
+    )
+
+    const httpWithHeaders = new httpm.HttpClient()
+    httpWithHeaders.requestOptions = {
+      headers: {
+        [httpm.Headers.Accept]: 'baz'
+      }
+    }
+    jsonObj = await httpWithHeaders.postJson<any>(
+      'https://postman-echo.com/post',
+      {}
+    )
+    expect(jsonObj.result.headers[httpm.Headers.Accept]).toBe('baz')
+    expect(jsonObj.headers[httpm.Headers.ContentType]).toContain(
+      httpm.MediaTypes.ApplicationJson
+    )
+  })
+
+  it('preserves existing headers on putJson', async () => {
+    const additionalHeaders = {[httpm.Headers.Accept]: 'foo'}
+    let jsonObj = await _http.putJson<any>(
+      'https://postman-echo.com/put',
+      {},
+      additionalHeaders
+    )
+    expect(jsonObj.result.headers[httpm.Headers.Accept]).toBe('foo')
+    expect(jsonObj.headers[httpm.Headers.ContentType]).toContain(
+      httpm.MediaTypes.ApplicationJson
+    )
+
+    const httpWithHeaders = new httpm.HttpClient()
+    httpWithHeaders.requestOptions = {
+      headers: {
+        [httpm.Headers.Accept]: 'baz'
+      }
+    }
+    jsonObj = await httpWithHeaders.putJson<any>(
+      'https://postman-echo.com/put',
+      {}
+    )
+    expect(jsonObj.result.headers[httpm.Headers.Accept]).toBe('baz')
+    expect(jsonObj.headers[httpm.Headers.ContentType]).toContain(
+      httpm.MediaTypes.ApplicationJson
+    )
+  })
+
+  it('preserves existing headers on patchJson', async () => {
+    const additionalHeaders = {[httpm.Headers.Accept]: 'foo'}
+    let jsonObj = await _http.patchJson<any>(
+      'https://postman-echo.com/patch',
+      {},
+      additionalHeaders
+    )
+    expect(jsonObj.result.headers[httpm.Headers.Accept]).toBe('foo')
+    expect(jsonObj.headers[httpm.Headers.ContentType]).toContain(
+      httpm.MediaTypes.ApplicationJson
+    )
+
+    const httpWithHeaders = new httpm.HttpClient()
+    httpWithHeaders.requestOptions = {
+      headers: {
+        [httpm.Headers.Accept]: 'baz'
+      }
+    }
+    jsonObj = await httpWithHeaders.patchJson<any>(
+      'https://postman-echo.com/patch',
+      {}
+    )
+    expect(jsonObj.result.headers[httpm.Headers.Accept]).toBe('baz')
+    expect(jsonObj.headers[httpm.Headers.ContentType]).toContain(
+      httpm.MediaTypes.ApplicationJson
+    )
+  })
+})

tests/keepalive.test.ts

@@ -0,0 +1,79 @@
+import * as httpm from '../lib'
+
+describe('basics', () => {
+  let _http: httpm.HttpClient
+
+  beforeEach(() => {
+    _http = new httpm.HttpClient('http-client-tests', [], {keepAlive: true})
+  })
+
+  afterEach(() => {
+    _http.dispose()
+  })
+
+  it.each([true, false])('creates Agent with keepAlive %s', keepAlive => {
+    const http = new httpm.HttpClient('http-client-tests', [], {keepAlive})
+    const agent = http.getAgent('https://postman-echo.com')
+    expect(agent).toHaveProperty('keepAlive', keepAlive)
+  })
+
+  it('does basic http get request with keepAlive true', async () => {
+    const res: httpm.HttpClientResponse = await _http.get(
+      'https://postman-echo.com/get'
+    )
+    expect(res.message.statusCode).toBe(200)
+    const body: string = await res.readBody()
+    const obj = JSON.parse(body)
+    expect(obj.url).toBe('https://postman-echo.com/get')
+  })
+
+  it('does basic head request with keepAlive true', async () => {
+    const res: httpm.HttpClientResponse = await _http.head(
+      'https://postman-echo.com/get'
+    )
+    expect(res.message.statusCode).toBe(200)
+  })
+
+  it('does basic http delete request with keepAlive true', async () => {
+    const res: httpm.HttpClientResponse = await _http.del(
+      'https://postman-echo.com/delete'
+    )
+    expect(res.message.statusCode).toBe(200)
+    const body: string = await res.readBody()
+    JSON.parse(body)
+  })
+
+  it('does basic http post request with keepAlive true', async () => {
+    const b = 'Hello World!'
+    const res: httpm.HttpClientResponse = await _http.post(
+      'https://postman-echo.com/post',
+      b
+    )
+    expect(res.message.statusCode).toBe(200)
+    const body: string = await res.readBody()
+    const obj = JSON.parse(body)
+    expect(obj.data).toBe(b)
+    expect(obj.url).toBe('https://postman-echo.com/post')
+  })
+
+  it('does basic http patch request with keepAlive true', async () => {
+    const b = 'Hello World!'
+    const res: httpm.HttpClientResponse = await _http.patch(
+      'https://postman-echo.com/patch',
+      b
+    )
+    expect(res.message.statusCode).toBe(200)
+    const body: string = await res.readBody()
+    const obj = JSON.parse(body)
+    expect(obj.data).toBe(b)
+    expect(obj.url).toBe('https://postman-echo.com/patch')
+  })
+
+  it('does basic http options request with keepAlive true', async () => {
+    const res: httpm.HttpClientResponse = await _http.options(
+      'https://postman-echo.com'
+    )
+    expect(res.message.statusCode).toBe(200)
+    await res.readBody()
+  })
+})

tests/proxy.test.ts

@@ -0,0 +1,331 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+import * as http from 'http'
+import * as httpm from '../lib/'
+import * as pm from '../lib/proxy'
+import {ProxyAgent} from 'undici'
+// eslint-disable-next-line @typescript-eslint/no-var-requires, @typescript-eslint/no-require-imports
+const proxy = require('proxy')
+
+let _proxyConnects: string[]
+let _proxyServer: http.Server
+const _proxyUrl = 'http://127.0.0.1:8080'
+
+describe('proxy', () => {
+  beforeAll(async () => {
+    // Start proxy server
+    _proxyServer = proxy.createProxy()
+    await new Promise<void>(resolve => {
+      const port = Number(_proxyUrl.split(':')[2])
+      _proxyServer.listen(port, () => resolve())
+    })
+    _proxyServer.on('connect', req => {
+      _proxyConnects.push(req.url ?? '')
+    })
+  })
+
+  beforeEach(() => {
+    _proxyConnects = []
+    _clearVars()
+  })
+
+  afterEach(() => {})
+
+  afterAll(async () => {
+    _clearVars()
+
+    // Stop proxy server
+    await new Promise<void>(resolve => {
+      _proxyServer.once('close', () => resolve())
+      _proxyServer.close()
+    })
+  })
+
+  it('getProxyUrl does not return proxyUrl if variables not set', () => {
+    const proxyUrl = pm.getProxyUrl(new URL('https://github.com'))
+    expect(proxyUrl).toBeUndefined()
+  })
+
+  it('getProxyUrl returns proxyUrl if https_proxy set for https url', () => {
+    process.env['https_proxy'] = 'https://myproxysvr'
+    const proxyUrl = pm.getProxyUrl(new URL('https://github.com'))
+    expect(proxyUrl).toBeDefined()
+  })
+
+  it('getProxyUrl does not return proxyUrl if http_proxy set for https url', () => {
+    process.env['http_proxy'] = 'https://myproxysvr'
+    const proxyUrl = pm.getProxyUrl(new URL('https://github.com'))
+    expect(proxyUrl).toBeUndefined()
+  })
+
+  it('getProxyUrl returns proxyUrl if http_proxy set for http url', () => {
+    process.env['http_proxy'] = 'http://myproxysvr'
+    const proxyUrl = pm.getProxyUrl(new URL('http://github.com'))
+    expect(proxyUrl).toBeDefined()
+  })
+
+  it('getProxyUrl does not return proxyUrl if https_proxy set and in no_proxy list', () => {
+    process.env['https_proxy'] = 'https://myproxysvr'
+    process.env['no_proxy'] = 'otherserver,myserver,anotherserver:8080'
+    const proxyUrl = pm.getProxyUrl(new URL('https://myserver'))
+    expect(proxyUrl).toBeUndefined()
+  })
+
+  it('getProxyUrl returns proxyUrl if https_proxy set and not in no_proxy list', () => {
+    process.env['https_proxy'] = 'https://myproxysvr'
+    process.env['no_proxy'] = 'otherserver,myserver,anotherserver:8080'
+    const proxyUrl = pm.getProxyUrl(new URL('https://github.com'))
+    expect(proxyUrl).toBeDefined()
+  })
+
+  it('getProxyUrl does not return proxyUrl if http_proxy set and in no_proxy list', () => {
+    process.env['http_proxy'] = 'http://myproxysvr'
+    process.env['no_proxy'] = 'otherserver,myserver,anotherserver:8080'
+    const proxyUrl = pm.getProxyUrl(new URL('http://myserver'))
+    expect(proxyUrl).toBeUndefined()
+  })
+
+  it('getProxyUrl returns proxyUrl if http_proxy set and not in no_proxy list', () => {
+    process.env['http_proxy'] = 'http://myproxysvr'
+    process.env['no_proxy'] = 'otherserver,myserver,anotherserver:8080'
+    const proxyUrl = pm.getProxyUrl(new URL('http://github.com'))
+    expect(proxyUrl).toBeDefined()
+  })
+
+  it('getProxyUrl returns proxyUrl if http_proxy has no protocol', () => {
+    process.env['http_proxy'] = 'myproxysvr'
+    const proxyUrl = pm.getProxyUrl(new URL('http://github.com'))
+    expect(proxyUrl?.toString()).toBe('http://myproxysvr/')
+  })
+
+  it('checkBypass returns true if host as no_proxy list', () => {
+    process.env['no_proxy'] = 'myserver'
+    const bypass = pm.checkBypass(new URL('https://myserver'))
+    expect(bypass).toBeTruthy()
+  })
+
+  it('checkBypass returns true if host in no_proxy list', () => {
+    process.env['no_proxy'] = 'otherserver,myserver,anotherserver:8080'
+    const bypass = pm.checkBypass(new URL('https://myserver'))
+    expect(bypass).toBeTruthy()
+  })
+
+  it('checkBypass returns true if host in no_proxy list with spaces', () => {
+    process.env['no_proxy'] = 'otherserver, myserver ,anotherserver:8080'
+    const bypass = pm.checkBypass(new URL('https://myserver'))
+    expect(bypass).toBeTruthy()
+  })
+
+  it('checkBypass returns true if host in no_proxy list with port', () => {
+    process.env['no_proxy'] = 'otherserver, myserver:8080 ,anotherserver'
+    const bypass = pm.checkBypass(new URL('https://myserver:8080'))
+    expect(bypass).toBeTruthy()
+  })
+
+  it('checkBypass returns true if host with port in no_proxy list without port', () => {
+    process.env['no_proxy'] = 'otherserver, myserver ,anotherserver'
+    const bypass = pm.checkBypass(new URL('https://myserver:8080'))
+    expect(bypass).toBeTruthy()
+  })
+
+  it('checkBypass returns true if host in no_proxy list with default https port', () => {
+    process.env['no_proxy'] = 'otherserver, myserver:443 ,anotherserver'
+    const bypass = pm.checkBypass(new URL('https://myserver'))
+    expect(bypass).toBeTruthy()
+  })
+
+  it('checkBypass returns true if host in no_proxy list with default http port', () => {
+    process.env['no_proxy'] = 'otherserver, myserver:80 ,anotherserver'
+    const bypass = pm.checkBypass(new URL('http://myserver'))
+    expect(bypass).toBeTruthy()
+  })
+
+  it('checkBypass returns false if host not in no_proxy list', () => {
+    process.env['no_proxy'] = 'otherserver, myserver ,anotherserver:8080'
+    const bypass = pm.checkBypass(new URL('https://github.com'))
+    expect(bypass).toBeFalsy()
+  })
+
+  it('checkBypass returns false if empty no_proxy', () => {
+    process.env['no_proxy'] = ''
+    const bypass = pm.checkBypass(new URL('https://github.com'))
+    expect(bypass).toBeFalsy()
+  })
+
+  it('checkBypass returns true if host with subdomain in no_proxy', () => {
+    process.env['no_proxy'] = 'myserver.com'
+    const bypass = pm.checkBypass(new URL('https://sub.myserver.com'))
+    expect(bypass).toBeTruthy()
+  })
+
+  it('checkBypass returns false if no_proxy is subdomain', () => {
+    process.env['no_proxy'] = 'myserver.com'
+    const bypass = pm.checkBypass(new URL('https://myserver.com.evil.org'))
+    expect(bypass).toBeFalsy()
+  })
+
+  it('checkBypass returns false if no_proxy is part of domain', () => {
+    process.env['no_proxy'] = 'myserver.com'
+    const bypass = pm.checkBypass(new URL('https://evilmyserver.com'))
+    expect(bypass).toBeFalsy()
+  })
+
+  // Do not strip leading dots as per https://github.com/actions/runner/blob/97195bad5870e2ad0915ebfef1616083aacf5818/docs/adrs/0263-proxy-support.md
+  it('checkBypass returns false if host with leading dot in no_proxy', () => {
+    process.env['no_proxy'] = '.myserver.com'
+    const bypass = pm.checkBypass(new URL('https://myserver.com'))
+    expect(bypass).toBeFalsy()
+  })
+
+  it('checkBypass returns true if host with subdomain in no_proxy defined with leading "."', () => {
+    process.env['no_proxy'] = '.myserver.com'
+    const bypass = pm.checkBypass(new URL('https://sub.myserver.com'))
+    expect(bypass).toBeTruthy()
+  })
+
+  it('checkBypass returns true if no_proxy is "*"', () => {
+    process.env['no_proxy'] = '*'
+    const bypass = pm.checkBypass(new URL('https://anything.whatsoever.com'))
+    expect(bypass).toBeTruthy()
+  })
+
+  it('checkBypass returns true if no_proxy contains comma separated "*"', () => {
+    process.env['no_proxy'] = 'domain.com,* , example.com'
+    const bypass = pm.checkBypass(new URL('https://anything.whatsoever.com'))
+    expect(bypass).toBeTruthy()
+  })
+
+  it('HttpClient does basic http get request through proxy', async () => {
+    process.env['https_proxy'] = _proxyUrl
+    const httpClient = new httpm.HttpClient()
+    const res: httpm.HttpClientResponse = await httpClient.get(
+      'https://postman-echo.com/get'
+    )
+    expect(res.message.statusCode).toBe(200)
+    const body: string = await res.readBody()
+    const obj = JSON.parse(body)
+    expect(obj.url).toBe('https://postman-echo.com/get')
+    expect(_proxyConnects).toEqual(['postman-echo.com:443'])
+  })
+
+  it('HttpClient does basic http get request when bypass proxy', async () => {
+    process.env['http_proxy'] = _proxyUrl
+    process.env['no_proxy'] = 'postman-echo.com'
+    const httpClient = new httpm.HttpClient()
+    const res: httpm.HttpClientResponse = await httpClient.get(
+      'https://postman-echo.com/get'
+    )
+    expect(res.message.statusCode).toBe(200)
+    const body: string = await res.readBody()
+    const obj = JSON.parse(body)
+    expect(obj.url).toBe('https://postman-echo.com/get')
+    expect(_proxyConnects).toHaveLength(0)
+  })
+
+  // TODO mock this out so we don't rely on a third party
+  /*
+  it('HttpClient does basic https get request through proxy', async () => {
+    process.env['https_proxy'] = _proxyUrl
+    const httpClient = new httpm.HttpClient()
+    const res: httpm.HttpClientResponse = await httpClient.get(
+      'https://postman-echo.com/get'
+    )
+    expect(res.message.statusCode).toBe(200)
+    const body: string = await res.readBody()
+    const obj = JSON.parse(body)
+    expect(obj.url).toBe('https://postman-echo.com/get')
+    expect(_proxyConnects).toEqual(['postman-echo.com:443'])
+  })
+  */
+
+  it('HttpClient does basic http get request when bypass proxy', async () => {
+    process.env['http_proxy'] = _proxyUrl
+    process.env['no_proxy'] = 'postman-echo.com'
+    const httpClient = new httpm.HttpClient()
+    const res: httpm.HttpClientResponse = await httpClient.get(
+      'https://postman-echo.com/get'
+    )
+    expect(res.message.statusCode).toBe(200)
+    const body: string = await res.readBody()
+    const obj = JSON.parse(body)
+    expect(obj.url).toBe('https://postman-echo.com/get')
+    expect(_proxyConnects).toHaveLength(0)
+  })
+
+  it('HttpClient bypasses proxy for loopback addresses (localhost, ::1, 127.*)', async () => {
+    // setup a server listening on localhost:8091
+    const server = http.createServer((request, response) => {
+      response.writeHead(200)
+      request.pipe(response)
+    })
+    server.listen(8091)
+    try {
+      process.env['http_proxy'] = _proxyUrl
+      const httpClient = new httpm.HttpClient()
+      let res = await httpClient.get('http://localhost:8091')
+      expect(res.message.statusCode).toBe(200)
+      res = await httpClient.get('http://127.0.0.1:8091')
+      expect(res.message.statusCode).toBe(200)
+
+      // no support for ipv6 for now
+      expect(httpClient.get('http://[::1]:8091')).rejects.toThrow()
+
+      // proxy at _proxyUrl was ignored
+      expect(_proxyConnects).toEqual([])
+    } finally {
+      server.close()
+    }
+  })
+
+  it('proxyAuth not set in tunnel agent when authentication is not provided', async () => {
+    process.env['https_proxy'] = 'http://127.0.0.1:8080'
+    const httpClient = new httpm.HttpClient()
+    const agent: any = httpClient.getAgent('https://some-url')
+    // eslint-disable-next-line no-console
+    console.log(agent)
+    expect(agent.proxyOptions.host).toBe('127.0.0.1')
+    expect(agent.proxyOptions.port).toBe('8080')
+    expect(agent.proxyOptions.proxyAuth).toBe(undefined)
+  })
+
+  it('proxyAuth is set in tunnel agent when authentication is provided', async () => {
+    process.env['https_proxy'] = 'http://user:password@127.0.0.1:8080'
+    const httpClient = new httpm.HttpClient()
+    const agent: any = httpClient.getAgent('https://some-url')
+    // eslint-disable-next-line no-console
+    console.log(agent)
+    expect(agent.proxyOptions.host).toBe('127.0.0.1')
+    expect(agent.proxyOptions.port).toBe('8080')
+    expect(agent.proxyOptions.proxyAuth).toBe('user:password')
+  })
+
+  it('ProxyAgent is returned when proxy setting are provided', async () => {
+    process.env['https_proxy'] = 'http://127.0.0.1:8080'
+    const httpClient = new httpm.HttpClient()
+    const agent = httpClient.getAgentDispatcher('https://some-url')
+    // eslint-disable-next-line no-console
+    console.log(agent)
+    expect(agent instanceof ProxyAgent).toBe(true)
+  })
+
+  it('proxyAuth is set in tunnel agent when authentication is provided with URIencoding', async () => {
+    process.env['https_proxy'] =
+      'http://user%40github.com:p%40ssword@127.0.0.1:8080'
+    const httpClient = new httpm.HttpClient()
+    const agent: any = httpClient.getAgent('https://some-url')
+    // eslint-disable-next-line no-console
+    console.log(agent)
+    expect(agent.proxyOptions.host).toBe('127.0.0.1')
+    expect(agent.proxyOptions.port).toBe('8080')
+    expect(agent.proxyOptions.proxyAuth).toBe('user@github.com:p@ssword')
+  })
+})
+
+function _clearVars(): void {
+  delete process.env.http_proxy
+  delete process.env.HTTP_PROXY
+  delete process.env.https_proxy
+  delete process.env.HTTPS_PROXY
+  delete process.env.no_proxy
+  delete process.env.NO_PROXY
+}