Copy over http-client files

packages/http-client/__tests__/auth.test.ts

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

packages/http-client/__tests__/basics.test.ts

@@ -0,0 +1,375 @@
+import * as httpm from '../_out'
+import * as ifm from '../_out/interfaces'
+import * as path from 'path'
+import * as fs from 'fs'
+
+let 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(() => {})
+
+  it('constructs', () => {
+    let http: httpm.HttpClient = new httpm.HttpClient('thttp-client-tests')
+    expect(http).toBeDefined()
+  })
+
+  // responses from httpbin return something like:
+  // {
+  //     "args": {},
+  //     "headers": {
+  //       "Connection": "close",
+  //       "Host": "httpbin.org",
+  //       "User-Agent": "typed-test-client-tests"
+  //     },
+  //     "origin": "173.95.152.44",
+  //     "url": "https://httpbin.org/get"
+  //  }
+
+  it('does basic http get request', async done => {
+    let res: httpm.HttpClientResponse = await _http.get(
+      'http://httpbin.org/get'
+    )
+    expect(res.message.statusCode).toBe(200)
+    let body: string = await res.readBody()
+    let obj: any = JSON.parse(body)
+    expect(obj.url).toBe('http://httpbin.org/get')
+    expect(obj.headers['User-Agent']).toBeTruthy()
+    done()
+  })
+
+  it('does basic http get request with no user agent', async done => {
+    let http: httpm.HttpClient = new httpm.HttpClient()
+    let res: httpm.HttpClientResponse = await http.get('http://httpbin.org/get')
+    expect(res.message.statusCode).toBe(200)
+    let body: string = await res.readBody()
+    let obj: any = JSON.parse(body)
+    expect(obj.url).toBe('http://httpbin.org/get')
+    expect(obj.headers['User-Agent']).toBeFalsy()
+    done()
+  })
+
+  it('does basic https get request', async done => {
+    let res: httpm.HttpClientResponse = await _http.get(
+      'https://httpbin.org/get'
+    )
+    expect(res.message.statusCode).toBe(200)
+    let body: string = await res.readBody()
+    let obj: any = JSON.parse(body)
+    expect(obj.url).toBe('https://httpbin.org/get')
+    done()
+  })
+
+  it('does basic http get request with default headers', async done => {
+    let http: httpm.HttpClient = new httpm.HttpClient('http-client-tests', [], {
+      headers: {
+        Accept: 'application/json',
+        'Content-Type': 'application/json'
+      }
+    })
+    let res: httpm.HttpClientResponse = await http.get('http://httpbin.org/get')
+    expect(res.message.statusCode).toBe(200)
+    let body: string = await res.readBody()
+    let obj: any = JSON.parse(body)
+    expect(obj.headers.Accept).toBe('application/json')
+    expect(obj.headers['Content-Type']).toBe('application/json')
+    expect(obj.url).toBe('http://httpbin.org/get')
+    done()
+  })
+
+  it('does basic http get request with merged headers', async done => {
+    let http: httpm.HttpClient = new httpm.HttpClient('http-client-tests', [], {
+      headers: {
+        Accept: 'application/json',
+        'Content-Type': 'application/json'
+      }
+    })
+    let res: httpm.HttpClientResponse = await http.get(
+      'http://httpbin.org/get',
+      {
+        'content-type': 'application/x-www-form-urlencoded'
+      }
+    )
+    expect(res.message.statusCode).toBe(200)
+    let body: string = await res.readBody()
+    let obj: any = 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('http://httpbin.org/get')
+    done()
+  })
+
+  it('pipes a get request', () => {
+    return new Promise<string>(async (resolve, reject) => {
+      let file: NodeJS.WritableStream = fs.createWriteStream(sampleFilePath)
+      ;(await _http.get('https://httpbin.org/get')).message
+        .pipe(file)
+        .on('close', () => {
+          let body: string = fs.readFileSync(sampleFilePath).toString()
+          let obj: any = JSON.parse(body)
+          expect(obj.url).toBe('https://httpbin.org/get')
+          resolve()
+        })
+    })
+  })
+
+  it('does basic get request with redirects', async done => {
+    let res: httpm.HttpClientResponse = await _http.get(
+      'https://httpbin.org/redirect-to?url=' +
+        encodeURIComponent('https://httpbin.org/get')
+    )
+    expect(res.message.statusCode).toBe(200)
+    let body: string = await res.readBody()
+    let obj: any = JSON.parse(body)
+    expect(obj.url).toBe('https://httpbin.org/get')
+    done()
+  })
+
+  it('does basic get request with redirects (303)', async done => {
+    let res: httpm.HttpClientResponse = await _http.get(
+      'https://httpbin.org/redirect-to?url=' +
+        encodeURIComponent('https://httpbin.org/get') +
+        '&status_code=303'
+    )
+    expect(res.message.statusCode).toBe(200)
+    let body: string = await res.readBody()
+    let obj: any = JSON.parse(body)
+    expect(obj.url).toBe('https://httpbin.org/get')
+    done()
+  })
+
+  it('returns 404 for not found get request on redirect', async done => {
+    let res: httpm.HttpClientResponse = await _http.get(
+      'https://httpbin.org/redirect-to?url=' +
+        encodeURIComponent('https://httpbin.org/status/404') +
+        '&status_code=303'
+    )
+    expect(res.message.statusCode).toBe(404)
+    let body: string = await res.readBody()
+    done()
+  })
+
+  it('does not follow redirects if disabled', async done => {
+    let http: httpm.HttpClient = new httpm.HttpClient(
+      'typed-test-client-tests',
+      null,
+      {allowRedirects: false}
+    )
+    let res: httpm.HttpClientResponse = await http.get(
+      'https://httpbin.org/redirect-to?url=' +
+        encodeURIComponent('https://httpbin.org/get')
+    )
+    expect(res.message.statusCode).toBe(302)
+    let body: string = await res.readBody()
+    done()
+  })
+
+  it('does not pass auth with diff hostname redirects', async done => {
+    let headers = {
+      accept: 'application/json',
+      authorization: 'shhh'
+    }
+    let res: httpm.HttpClientResponse = await _http.get(
+      'https://httpbin.org/redirect-to?url=' +
+        encodeURIComponent('https://www.httpbin.org/get'),
+      headers
+    )
+
+    expect(res.message.statusCode).toBe(200)
+    let body: string = await res.readBody()
+    let obj: any = JSON.parse(body)
+    // httpbin "fixes" the casing
+    expect(obj.headers['Accept']).toBe('application/json')
+    expect(obj.headers['Authorization']).toBeUndefined()
+    expect(obj.headers['authorization']).toBeUndefined()
+    expect(obj.url).toBe('https://www.httpbin.org/get')
+
+    done()
+  })
+
+  it('does not pass Auth with diff hostname redirects', async done => {
+    let headers = {
+      Accept: 'application/json',
+      Authorization: 'shhh'
+    }
+    let res: httpm.HttpClientResponse = await _http.get(
+      'https://httpbin.org/redirect-to?url=' +
+        encodeURIComponent('https://www.httpbin.org/get'),
+      headers
+    )
+
+    expect(res.message.statusCode).toBe(200)
+    let body: string = await res.readBody()
+    let obj: any = JSON.parse(body)
+    // httpbin "fixes" the casing
+    expect(obj.headers['Accept']).toBe('application/json')
+    expect(obj.headers['Authorization']).toBeUndefined()
+    expect(obj.headers['authorization']).toBeUndefined()
+    expect(obj.url).toBe('https://www.httpbin.org/get')
+
+    done()
+  })
+
+  it('does basic head request', async done => {
+    let res: httpm.HttpClientResponse = await _http.head(
+      'http://httpbin.org/get'
+    )
+    expect(res.message.statusCode).toBe(200)
+    done()
+  })
+
+  it('does basic http delete request', async done => {
+    let res: httpm.HttpClientResponse = await _http.del(
+      'http://httpbin.org/delete'
+    )
+    expect(res.message.statusCode).toBe(200)
+    let body: string = await res.readBody()
+    let obj: any = JSON.parse(body)
+    done()
+  })
+
+  it('does basic http post request', async done => {
+    let b: string = 'Hello World!'
+    let res: httpm.HttpClientResponse = await _http.post(
+      'http://httpbin.org/post',
+      b
+    )
+    expect(res.message.statusCode).toBe(200)
+    let body: string = await res.readBody()
+    let obj: any = JSON.parse(body)
+    expect(obj.data).toBe(b)
+    expect(obj.url).toBe('http://httpbin.org/post')
+    done()
+  })
+
+  it('does basic http patch request', async done => {
+    let b: string = 'Hello World!'
+    let res: httpm.HttpClientResponse = await _http.patch(
+      'http://httpbin.org/patch',
+      b
+    )
+    expect(res.message.statusCode).toBe(200)
+    let body: string = await res.readBody()
+    let obj: any = JSON.parse(body)
+    expect(obj.data).toBe(b)
+    expect(obj.url).toBe('http://httpbin.org/patch')
+    done()
+  })
+
+  it('does basic http options request', async done => {
+    let res: httpm.HttpClientResponse = await _http.options(
+      'http://httpbin.org'
+    )
+    expect(res.message.statusCode).toBe(200)
+    let body: string = await res.readBody()
+    done()
+  })
+
+  it('returns 404 for not found get request', async done => {
+    let res: httpm.HttpClientResponse = await _http.get(
+      'http://httpbin.org/status/404'
+    )
+    expect(res.message.statusCode).toBe(404)
+    let body: string = await res.readBody()
+    done()
+  })
+
+  it('gets a json object', async () => {
+    let jsonObj: ifm.ITypedResponse<HttpBinData> = await _http.getJson<
+      HttpBinData
+    >('https://httpbin.org/get')
+    expect(jsonObj.statusCode).toBe(200)
+    expect(jsonObj.result).toBeDefined()
+    expect(jsonObj.result.url).toBe('https://httpbin.org/get')
+    expect(jsonObj.result.headers['Accept']).toBe(
+      httpm.MediaTypes.ApplicationJson
+    )
+    expect(jsonObj.headers[httpm.Headers.ContentType]).toBe(
+      httpm.MediaTypes.ApplicationJson
+    )
+  })
+
+  it('getting a non existent json object returns null', async () => {
+    let jsonObj: ifm.ITypedResponse<HttpBinData> = await _http.getJson<
+      HttpBinData
+    >('https://httpbin.org/status/404')
+    expect(jsonObj.statusCode).toBe(404)
+    expect(jsonObj.result).toBeNull()
+  })
+
+  it('posts a json object', async () => {
+    let res: any = {name: 'foo'}
+    let restRes: ifm.ITypedResponse<HttpBinData> = await _http.postJson<
+      HttpBinData
+    >('https://httpbin.org/post', res)
+    expect(restRes.statusCode).toBe(200)
+    expect(restRes.result).toBeDefined()
+    expect(restRes.result.url).toBe('https://httpbin.org/post')
+    expect(restRes.result.json.name).toBe('foo')
+    expect(restRes.result.headers['Accept']).toBe(
+      httpm.MediaTypes.ApplicationJson
+    )
+    expect(restRes.result.headers['Content-Type']).toBe(
+      httpm.MediaTypes.ApplicationJson
+    )
+    expect(restRes.headers[httpm.Headers.ContentType]).toBe(
+      httpm.MediaTypes.ApplicationJson
+    )
+  })
+
+  it('puts a json object', async () => {
+    let res: any = {name: 'foo'}
+    let restRes: ifm.ITypedResponse<HttpBinData> = await _http.putJson<
+      HttpBinData
+    >('https://httpbin.org/put', res)
+    expect(restRes.statusCode).toBe(200)
+    expect(restRes.result).toBeDefined()
+    expect(restRes.result.url).toBe('https://httpbin.org/put')
+    expect(restRes.result.json.name).toBe('foo')
+
+    expect(restRes.result.headers['Accept']).toBe(
+      httpm.MediaTypes.ApplicationJson
+    )
+    expect(restRes.result.headers['Content-Type']).toBe(
+      httpm.MediaTypes.ApplicationJson
+    )
+    expect(restRes.headers[httpm.Headers.ContentType]).toBe(
+      httpm.MediaTypes.ApplicationJson
+    )
+  })
+
+  it('patch a json object', async () => {
+    let res: any = {name: 'foo'}
+    let restRes: ifm.ITypedResponse<HttpBinData> = await _http.patchJson<
+      HttpBinData
+    >('https://httpbin.org/patch', res)
+    expect(restRes.statusCode).toBe(200)
+    expect(restRes.result).toBeDefined()
+    expect(restRes.result.url).toBe('https://httpbin.org/patch')
+    expect(restRes.result.json.name).toBe('foo')
+    expect(restRes.result.headers['Accept']).toBe(
+      httpm.MediaTypes.ApplicationJson
+    )
+    expect(restRes.result.headers['Content-Type']).toBe(
+      httpm.MediaTypes.ApplicationJson
+    )
+    expect(restRes.headers[httpm.Headers.ContentType]).toBe(
+      httpm.MediaTypes.ApplicationJson
+    )
+  })
+})

packages/http-client/__tests__/headers.test.ts

@@ -0,0 +1,115 @@
+import * as httpm from '../_out'
+import * as ifm from '../_out/interfaces'
+
+describe('headers', () => {
+  let _http: httpm.HttpClient
+
+  beforeEach(() => {
+    _http = new httpm.HttpClient('http-client-tests')
+  })
+
+  it('preserves existing headers on getJson', async () => {
+    let additionalHeaders = {[httpm.Headers.Accept]: 'foo'}
+    let jsonObj: ifm.ITypedResponse<any> = await _http.getJson<any>(
+      'https://httpbin.org/get',
+      additionalHeaders
+    )
+    expect(jsonObj.result.headers['Accept']).toBe('foo')
+    expect(jsonObj.headers[httpm.Headers.ContentType]).toBe(
+      httpm.MediaTypes.ApplicationJson
+    )
+
+    let httpWithHeaders = new httpm.HttpClient()
+    httpWithHeaders.requestOptions = {
+      headers: {
+        [httpm.Headers.Accept]: 'baz'
+      }
+    }
+    jsonObj = await httpWithHeaders.getJson<any>('https://httpbin.org/get')
+    expect(jsonObj.result.headers['Accept']).toBe('baz')
+    expect(jsonObj.headers[httpm.Headers.ContentType]).toBe(
+      httpm.MediaTypes.ApplicationJson
+    )
+  })
+
+  it('preserves existing headers on postJson', async () => {
+    let additionalHeaders = {[httpm.Headers.Accept]: 'foo'}
+    let jsonObj: ifm.ITypedResponse<any> = await _http.postJson<any>(
+      'https://httpbin.org/post',
+      {},
+      additionalHeaders
+    )
+    expect(jsonObj.result.headers['Accept']).toBe('foo')
+    expect(jsonObj.headers[httpm.Headers.ContentType]).toBe(
+      httpm.MediaTypes.ApplicationJson
+    )
+
+    let httpWithHeaders = new httpm.HttpClient()
+    httpWithHeaders.requestOptions = {
+      headers: {
+        [httpm.Headers.Accept]: 'baz'
+      }
+    }
+    jsonObj = await httpWithHeaders.postJson<any>(
+      'https://httpbin.org/post',
+      {}
+    )
+    expect(jsonObj.result.headers['Accept']).toBe('baz')
+    expect(jsonObj.headers[httpm.Headers.ContentType]).toBe(
+      httpm.MediaTypes.ApplicationJson
+    )
+  })
+
+  it('preserves existing headers on putJson', async () => {
+    let additionalHeaders = {[httpm.Headers.Accept]: 'foo'}
+    let jsonObj: ifm.ITypedResponse<any> = await _http.putJson<any>(
+      'https://httpbin.org/put',
+      {},
+      additionalHeaders
+    )
+    expect(jsonObj.result.headers['Accept']).toBe('foo')
+    expect(jsonObj.headers[httpm.Headers.ContentType]).toBe(
+      httpm.MediaTypes.ApplicationJson
+    )
+
+    let httpWithHeaders = new httpm.HttpClient()
+    httpWithHeaders.requestOptions = {
+      headers: {
+        [httpm.Headers.Accept]: 'baz'
+      }
+    }
+    jsonObj = await httpWithHeaders.putJson<any>('https://httpbin.org/put', {})
+    expect(jsonObj.result.headers['Accept']).toBe('baz')
+    expect(jsonObj.headers[httpm.Headers.ContentType]).toBe(
+      httpm.MediaTypes.ApplicationJson
+    )
+  })
+
+  it('preserves existing headers on patchJson', async () => {
+    let additionalHeaders = {[httpm.Headers.Accept]: 'foo'}
+    let jsonObj: ifm.ITypedResponse<any> = await _http.patchJson<any>(
+      'https://httpbin.org/patch',
+      {},
+      additionalHeaders
+    )
+    expect(jsonObj.result.headers['Accept']).toBe('foo')
+    expect(jsonObj.headers[httpm.Headers.ContentType]).toBe(
+      httpm.MediaTypes.ApplicationJson
+    )
+
+    let httpWithHeaders = new httpm.HttpClient()
+    httpWithHeaders.requestOptions = {
+      headers: {
+        [httpm.Headers.Accept]: 'baz'
+      }
+    }
+    jsonObj = await httpWithHeaders.patchJson<any>(
+      'https://httpbin.org/patch',
+      {}
+    )
+    expect(jsonObj.result.headers['Accept']).toBe('baz')
+    expect(jsonObj.headers[httpm.Headers.ContentType]).toBe(
+      httpm.MediaTypes.ApplicationJson
+    )
+  })
+})

packages/http-client/__tests__/keepalive.test.ts

@@ -0,0 +1,79 @@
+import * as httpm from '../_out'
+
+describe('basics', () => {
+  let _http: httpm.HttpClient
+
+  beforeEach(() => {
+    _http = new httpm.HttpClient('http-client-tests', [], {keepAlive: true})
+  })
+
+  afterEach(() => {
+    _http.dispose()
+  })
+
+  it('does basic http get request with keepAlive true', async done => {
+    let res: httpm.HttpClientResponse = await _http.get(
+      'http://httpbin.org/get'
+    )
+    expect(res.message.statusCode).toBe(200)
+    let body: string = await res.readBody()
+    let obj: any = JSON.parse(body)
+    expect(obj.url).toBe('http://httpbin.org/get')
+    done()
+  })
+
+  it('does basic head request with keepAlive true', async done => {
+    let res: httpm.HttpClientResponse = await _http.head(
+      'http://httpbin.org/get'
+    )
+    expect(res.message.statusCode).toBe(200)
+    done()
+  })
+
+  it('does basic http delete request with keepAlive true', async done => {
+    let res: httpm.HttpClientResponse = await _http.del(
+      'http://httpbin.org/delete'
+    )
+    expect(res.message.statusCode).toBe(200)
+    let body: string = await res.readBody()
+    let obj: any = JSON.parse(body)
+    done()
+  })
+
+  it('does basic http post request with keepAlive true', async done => {
+    let b: string = 'Hello World!'
+    let res: httpm.HttpClientResponse = await _http.post(
+      'http://httpbin.org/post',
+      b
+    )
+    expect(res.message.statusCode).toBe(200)
+    let body: string = await res.readBody()
+    let obj: any = JSON.parse(body)
+    expect(obj.data).toBe(b)
+    expect(obj.url).toBe('http://httpbin.org/post')
+    done()
+  })
+
+  it('does basic http patch request with keepAlive true', async done => {
+    let b: string = 'Hello World!'
+    let res: httpm.HttpClientResponse = await _http.patch(
+      'http://httpbin.org/patch',
+      b
+    )
+    expect(res.message.statusCode).toBe(200)
+    let body: string = await res.readBody()
+    let obj: any = JSON.parse(body)
+    expect(obj.data).toBe(b)
+    expect(obj.url).toBe('http://httpbin.org/patch')
+    done()
+  })
+
+  it('does basic http options request with keepAlive true', async done => {
+    let res: httpm.HttpClientResponse = await _http.options(
+      'http://httpbin.org'
+    )
+    expect(res.message.statusCode).toBe(200)
+    let body: string = await res.readBody()
+    done()
+  })
+})

packages/http-client/__tests__/proxy.test.ts

@@ -0,0 +1,228 @@
+import * as http from 'http'
+import * as httpm from '../_out'
+import * as pm from '../_out/proxy'
+import * as proxy from 'proxy'
+import * as tunnelm from 'tunnel'
+
+let _proxyConnects: string[]
+let _proxyServer: http.Server
+let _proxyUrl = 'http://127.0.0.1:8080'
+
+describe('proxy', () => {
+  beforeAll(async () => {
+    // Start proxy server
+    _proxyServer = proxy()
+    await new Promise(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(resolve => {
+      _proxyServer.once('close', () => resolve())
+      _proxyServer.close()
+    })
+  })
+
+  it('getProxyUrl does not return proxyUrl if variables not set', () => {
+    let 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'
+    let 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'
+    let 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'
+    let 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'
+    let 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'
+    let 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'
+    let 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'
+    let proxyUrl = pm.getProxyUrl(new URL('http://github.com'))
+    expect(proxyUrl).toBeDefined()
+  })
+
+  it('checkBypass returns true if host as no_proxy list', () => {
+    process.env['no_proxy'] = 'myserver'
+    let 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'
+    let 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'
+    let 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'
+    let 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'
+    let 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'
+    let 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'
+    let 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'
+    let bypass = pm.checkBypass(new URL('https://github.com'))
+    expect(bypass).toBeFalsy()
+  })
+
+  it('checkBypass returns false if empty no_proxy', () => {
+    process.env['no_proxy'] = ''
+    let bypass = pm.checkBypass(new URL('https://github.com'))
+    expect(bypass).toBeFalsy()
+  })
+
+  it('HttpClient does basic http get request through proxy', async () => {
+    process.env['http_proxy'] = _proxyUrl
+    const httpClient = new httpm.HttpClient()
+    let res: httpm.HttpClientResponse = await httpClient.get(
+      'http://httpbin.org/get'
+    )
+    expect(res.message.statusCode).toBe(200)
+    let body: string = await res.readBody()
+    let obj: any = JSON.parse(body)
+    expect(obj.url).toBe('http://httpbin.org/get')
+    expect(_proxyConnects).toEqual(['httpbin.org:80'])
+  })
+
+  it('HttoClient does basic http get request when bypass proxy', async () => {
+    process.env['http_proxy'] = _proxyUrl
+    process.env['no_proxy'] = 'httpbin.org'
+    const httpClient = new httpm.HttpClient()
+    let res: httpm.HttpClientResponse = await httpClient.get(
+      'http://httpbin.org/get'
+    )
+    expect(res.message.statusCode).toBe(200)
+    let body: string = await res.readBody()
+    let obj: any = JSON.parse(body)
+    expect(obj.url).toBe('http://httpbin.org/get')
+    expect(_proxyConnects).toHaveLength(0)
+  })
+
+  it('HttpClient does basic https get request through proxy', async () => {
+    process.env['https_proxy'] = _proxyUrl
+    const httpClient = new httpm.HttpClient()
+    let res: httpm.HttpClientResponse = await httpClient.get(
+      'https://httpbin.org/get'
+    )
+    expect(res.message.statusCode).toBe(200)
+    let body: string = await res.readBody()
+    let obj: any = JSON.parse(body)
+    expect(obj.url).toBe('https://httpbin.org/get')
+    expect(_proxyConnects).toEqual(['httpbin.org:443'])
+  })
+
+  it('HttpClient does basic https get request when bypass proxy', async () => {
+    process.env['https_proxy'] = _proxyUrl
+    process.env['no_proxy'] = 'httpbin.org'
+    const httpClient = new httpm.HttpClient()
+    let res: httpm.HttpClientResponse = await httpClient.get(
+      'https://httpbin.org/get'
+    )
+    expect(res.message.statusCode).toBe(200)
+    let body: string = await res.readBody()
+    let obj: any = JSON.parse(body)
+    expect(obj.url).toBe('https://httpbin.org/get')
+    expect(_proxyConnects).toHaveLength(0)
+  })
+
+  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()
+    let agent: tunnelm.TunnelingAgent = httpClient.getAgent('https://some-url')
+    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()
+    let agent: tunnelm.TunnelingAgent = httpClient.getAgent('https://some-url')
+    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')
+  })
+})
+
+function _clearVars() {
+  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
+}