cdk-ecr-deployment 2.2.0 → 2.3.0

package/node_modules/hpagent/test/https-https.test.js

@@ -0,0 +1,313 @@
+'use strict'
+
+const https = require('https')
+const test = require('ava')
+const { createSecureServer, createSecureProxy } = require('./utils')
+const { HttpsProxyAgent } = require('../')
+
+function request (opts) {
+  return new Promise((resolve, reject) => {
+    const req = https.request(opts, resolve)
+    req.on('error', reject)
+    req.end(opts.body)
+  })
+}
+
+test('Basic', async t => {
+  const server = await createSecureServer()
+  const proxy = await createSecureProxy()
+  server.on('request', (req, res) => res.end('ok'))
+
+  const response = await request({
+    method: 'GET',
+    hostname: server.address().address,
+    port: server.address().port,
+    path: '/',
+    agent: new HttpsProxyAgent({
+      keepAlive: true,
+      keepAliveMsecs: 1000,
+      maxSockets: 256,
+      maxFreeSockets: 256,
+      scheduling: 'lifo',
+      proxy: `https://${proxy.address().address}:${proxy.address().port}`
+    })
+  })
+
+  let body = ''
+  response.setEncoding('utf8')
+  for await (const chunk of response) {
+    body += chunk
+  }
+
+  t.is(body, 'ok')
+  t.is(response.statusCode, 200)
+
+  server.close()
+  proxy.close()
+})
+
+test('Connection header (keep-alive)', async t => {
+  const server = await createSecureServer()
+  const proxy = await createSecureProxy()
+  server.on('request', (req, res) => res.end('ok'))
+
+  proxy.authenticate = function (req, fn) {
+    t.is(req.headers.connection, 'keep-alive')
+    fn(null, true)
+  }
+
+  const response = await request({
+    method: 'GET',
+    hostname: server.address().address,
+    port: server.address().port,
+    path: '/',
+    agent: new HttpsProxyAgent({
+      keepAlive: true,
+      keepAliveMsecs: 1000,
+      maxSockets: 256,
+      maxFreeSockets: 256,
+      scheduling: 'lifo',
+      proxy: `https://${proxy.address().address}:${proxy.address().port}`
+    })
+  })
+
+  let body = ''
+  response.setEncoding('utf8')
+  for await (const chunk of response) {
+    body += chunk
+  }
+
+  t.is(body, 'ok')
+  t.is(response.statusCode, 200)
+
+  server.close()
+  proxy.close()
+})
+
+test('Connection header (close)', async t => {
+  const server = await createSecureServer()
+  const proxy = await createSecureProxy()
+  server.on('request', (req, res) => res.end('ok'))
+
+  proxy.authenticate = function (req, fn) {
+    t.is(req.headers.connection, 'close')
+    fn(null, true)
+  }
+
+  const response = await request({
+    method: 'GET',
+    hostname: server.address().address,
+    port: server.address().port,
+    path: '/',
+    agent: new HttpsProxyAgent({
+      keepAlive: false,
+      keepAliveMsecs: 1000,
+      maxSockets: Infinity,
+      maxFreeSockets: 256,
+      scheduling: 'lifo',
+      proxy: `https://${proxy.address().address}:${proxy.address().port}`
+    })
+  })
+
+  let body = ''
+  response.setEncoding('utf8')
+  for await (const chunk of response) {
+    body += chunk
+  }
+
+  t.is(body, 'ok')
+  t.is(response.statusCode, 200)
+
+  server.close()
+  proxy.close()
+})
+
+test('Proxy authentication (empty)', async t => {
+  const server = await createSecureServer()
+  const proxy = await createSecureProxy()
+  server.on('request', (req, res) => res.end('ok'))
+
+  proxy.authenticate = function (req, fn) {
+    fn(null, req.headers['proxy-authorization'] === undefined)
+  }
+
+  const response = await request({
+    method: 'GET',
+    hostname: server.address().address,
+    port: server.address().port,
+    path: '/',
+    agent: new HttpsProxyAgent({
+      keepAlive: true,
+      keepAliveMsecs: 1000,
+      maxSockets: 256,
+      maxFreeSockets: 256,
+      scheduling: 'lifo',
+      proxy: `https://${proxy.address().address}:${proxy.address().port}`
+    })
+  })
+
+  let body = ''
+  response.setEncoding('utf8')
+  for await (const chunk of response) {
+    body += chunk
+  }
+
+  t.is(body, 'ok')
+  t.is(response.statusCode, 200)
+
+  server.close()
+  proxy.close()
+})
+
+test('Proxy authentication', async t => {
+  const server = await createSecureServer()
+  const proxy = await createSecureProxy()
+  server.on('request', (req, res) => res.end('ok'))
+
+  proxy.authenticate = function (req, fn) {
+    fn(null, req.headers['proxy-authorization'] === `Basic ${Buffer.from('hello:world').toString('base64')}`)
+  }
+
+  const response = await request({
+    method: 'GET',
+    hostname: server.address().address,
+    port: server.address().port,
+    path: '/',
+    agent: new HttpsProxyAgent({
+      keepAlive: true,
+      keepAliveMsecs: 1000,
+      maxSockets: 256,
+      maxFreeSockets: 256,
+      scheduling: 'lifo',
+      proxy: `https://hello:world@${proxy.address().address}:${proxy.address().port}`
+    })
+  })
+
+  let body = ''
+  response.setEncoding('utf8')
+  for await (const chunk of response) {
+    body += chunk
+  }
+
+  t.is(body, 'ok')
+  t.is(response.statusCode, 200)
+
+  server.close()
+  proxy.close()
+})
+
+test('Configure the agent to reuse sockets', async t => {
+  const server = await createSecureServer()
+  const proxy = await createSecureProxy()
+  server.on('request', (req, res) => res.end('ok'))
+
+  let count = 0
+  proxy.on('connection', () => {
+    count += 1
+    t.is(count, 1)
+  })
+
+  const agent = new HttpsProxyAgent({
+    keepAlive: true,
+    keepAliveMsecs: 1000,
+    maxSockets: 256,
+    maxFreeSockets: 256,
+    scheduling: 'lifo',
+    proxy: `https://${proxy.address().address}:${proxy.address().port}`
+  })
+
+  let response = await request({
+    method: 'GET',
+    hostname: server.address().address,
+    port: server.address().port,
+    path: '/',
+    agent
+  })
+
+  let body = ''
+  response.setEncoding('utf8')
+  for await (const chunk of response) {
+    body += chunk
+  }
+
+  t.is(body, 'ok')
+  t.is(response.statusCode, 200)
+
+  response = await request({
+    method: 'GET',
+    hostname: server.address().address,
+    port: server.address().port,
+    path: '/',
+    agent
+  })
+
+  body = ''
+  response.setEncoding('utf8')
+  for await (const chunk of response) {
+    body += chunk
+  }
+
+  t.is(body, 'ok')
+  t.is(response.statusCode, 200)
+
+  server.close()
+  proxy.close()
+})
+
+test('Configure the agent to NOT reuse sockets', async t => {
+  const server = await createSecureServer()
+  const proxy = await createSecureProxy()
+  server.on('request', (req, res) => res.end('ok'))
+
+  const ports = []
+  proxy.on('connection', socket => {
+    t.false(ports.includes(socket.remotePort))
+    ports.push(socket.remotePort)
+  })
+
+  const agent = new HttpsProxyAgent({
+    keepAlive: false,
+    keepAliveMsecs: 1000,
+    maxSockets: Infinity,
+    maxFreeSockets: 256,
+    scheduling: 'lifo',
+    proxy: `https://${proxy.address().address}:${proxy.address().port}`
+  })
+
+  let response = await request({
+    method: 'GET',
+    hostname: server.address().address,
+    port: server.address().port,
+    path: '/',
+    agent
+  })
+
+  let body = ''
+  response.setEncoding('utf8')
+  for await (const chunk of response) {
+    body += chunk
+  }
+
+  t.is(body, 'ok')
+  t.is(response.statusCode, 200)
+
+  response = await request({
+    method: 'GET',
+    hostname: server.address().address,
+    port: server.address().port,
+    path: '/',
+    agent
+  })
+
+  body = ''
+  response.setEncoding('utf8')
+  for await (const chunk of response) {
+    body += chunk
+  }
+
+  t.is(body, 'ok')
+  t.is(response.statusCode, 200)
+
+  server.close()
+  proxy.close()
+})

package/node_modules/hpagent/test/index.test-d.ts

@@ -0,0 +1,45 @@
+import * as http from 'http'
+import * as https from 'https'
+import { expectType } from 'tsd'
+import {
+  HttpProxyAgent,
+  HttpProxyAgentOptions,
+  HttpsProxyAgent,
+  HttpsProxyAgentOptions
+} from '../'
+
+{
+  const agent = new HttpProxyAgent({
+    keepAlive: true,
+    keepAliveMsecs: 1000,
+    maxSockets: 256,
+    maxFreeSockets: 256,
+    proxy: 'http://localhost:8080'
+  })
+
+  expectType<HttpProxyAgent>(agent)
+  http.request({
+    method: 'GET',
+    hostname: 'localhost',
+    port: 9200,
+    agent
+  })
+}
+
+{
+  const agent = new HttpsProxyAgent({
+    keepAlive: true,
+    keepAliveMsecs: 1000,
+    maxSockets: 256,
+    maxFreeSockets: 256,
+    proxy: 'http://localhost:8080'
+  })
+
+  expectType<HttpsProxyAgent>(agent)
+  https.request({
+    method: 'GET',
+    hostname: 'localhost',
+    port: 9200,
+    agent
+  })
+}

package/node_modules/hpagent/test/needle.test.js

@@ -0,0 +1,103 @@
+'use strict'
+
+const needle = require('needle')
+const test = require('ava')
+const {
+  createServer,
+  createSecureServer,
+  createProxy,
+  createSecureProxy
+} = require('./utils')
+const { HttpProxyAgent, HttpsProxyAgent } = require('../')
+
+test('http to http', async t => {
+  const server = await createServer()
+  const proxy = await createProxy()
+  server.on('request', (req, res) => res.end('ok'))
+
+  const response = await needle('get', `http://${server.address().address}:${server.address().port}`, {
+    agent: new HttpProxyAgent({
+      keepAlive: true,
+      keepAliveMsecs: 1000,
+      maxSockets: 256,
+      maxFreeSockets: 256,
+      scheduling: 'lifo',
+      proxy: `http://${proxy.address().address}:${proxy.address().port}`
+    })
+  })
+
+  t.is(response.body.toString(), 'ok')
+  t.is(response.statusCode, 200)
+
+  server.close()
+  proxy.close()
+})
+
+test('https to http', async t => {
+  const server = await createServer()
+  const proxy = await createSecureProxy()
+  server.on('request', (req, res) => res.end('ok'))
+
+  const response = await needle('get', `http://${server.address().address}:${server.address().port}`, {
+    agent: new HttpProxyAgent({
+      keepAlive: true,
+      keepAliveMsecs: 1000,
+      maxSockets: 256,
+      maxFreeSockets: 256,
+      scheduling: 'lifo',
+      proxy: `https://${proxy.address().address}:${proxy.address().port}`
+    })
+  })
+
+  t.is(response.body.toString(), 'ok')
+  t.is(response.statusCode, 200)
+
+  server.close()
+  proxy.close()
+})
+
+test('http to https', async t => {
+  const server = await createSecureServer()
+  const proxy = await createProxy()
+  server.on('request', (req, res) => res.end('ok'))
+
+  const response = await needle('get', `https://${server.address().address}:${server.address().port}`, {
+    agent: new HttpsProxyAgent({
+      keepAlive: true,
+      keepAliveMsecs: 1000,
+      maxSockets: 256,
+      maxFreeSockets: 256,
+      scheduling: 'lifo',
+      proxy: `http://${proxy.address().address}:${proxy.address().port}`
+    })
+  })
+
+  t.is(response.body.toString(), 'ok')
+  t.is(response.statusCode, 200)
+
+  server.close()
+  proxy.close()
+})
+
+test('https to https', async t => {
+  const server = await createSecureServer()
+  const proxy = await createSecureProxy()
+  server.on('request', (req, res) => res.end('ok'))
+
+  const response = await needle('get', `https://${server.address().address}:${server.address().port}`, {
+    agent: new HttpsProxyAgent({
+      keepAlive: true,
+      keepAliveMsecs: 1000,
+      maxSockets: 256,
+      maxFreeSockets: 256,
+      scheduling: 'lifo',
+      proxy: `https://${proxy.address().address}:${proxy.address().port}`
+    })
+  })
+
+  t.is(response.body.toString(), 'ok')
+  t.is(response.statusCode, 200)
+
+  server.close()
+  proxy.close()
+})

package/node_modules/hpagent/test/node-fetch.test.js

@@ -0,0 +1,103 @@
+'use strict'
+
+const fetch = require('node-fetch')
+const test = require('ava')
+const {
+  createServer,
+  createSecureServer,
+  createProxy,
+  createSecureProxy
+} = require('./utils')
+const { HttpProxyAgent, HttpsProxyAgent } = require('../')
+
+test('http to http', async t => {
+  const server = await createServer()
+  const proxy = await createProxy()
+  server.on('request', (req, res) => res.end('ok'))
+
+  const response = await fetch(`http://${server.address().address}:${server.address().port}`, {
+    agent: new HttpProxyAgent({
+      keepAlive: true,
+      keepAliveMsecs: 1000,
+      maxSockets: 256,
+      maxFreeSockets: 256,
+      scheduling: 'lifo',
+      proxy: `http://${proxy.address().address}:${proxy.address().port}`
+    })
+  })
+
+  t.is(await response.text(), 'ok')
+  t.is(response.status, 200)
+
+  server.close()
+  proxy.close()
+})
+
+test('https to http', async t => {
+  const server = await createServer()
+  const proxy = await createSecureProxy()
+  server.on('request', (req, res) => res.end('ok'))
+
+  const response = await fetch(`http://${server.address().address}:${server.address().port}`, {
+    agent: new HttpProxyAgent({
+      keepAlive: true,
+      keepAliveMsecs: 1000,
+      maxSockets: 256,
+      maxFreeSockets: 256,
+      scheduling: 'lifo',
+      proxy: `https://${proxy.address().address}:${proxy.address().port}`
+    })
+  })
+
+  t.is(await response.text(), 'ok')
+  t.is(response.status, 200)
+
+  server.close()
+  proxy.close()
+})
+
+test('http to https', async t => {
+  const server = await createSecureServer()
+  const proxy = await createProxy()
+  server.on('request', (req, res) => res.end('ok'))
+
+  const response = await fetch(`https://${server.address().address}:${server.address().port}`, {
+    agent: new HttpsProxyAgent({
+      keepAlive: true,
+      keepAliveMsecs: 1000,
+      maxSockets: 256,
+      maxFreeSockets: 256,
+      scheduling: 'lifo',
+      proxy: `http://${proxy.address().address}:${proxy.address().port}`
+    })
+  })
+
+  t.is(await response.text(), 'ok')
+  t.is(response.status, 200)
+
+  server.close()
+  proxy.close()
+})
+
+test('https to https', async t => {
+  const server = await createSecureServer()
+  const proxy = await createSecureProxy()
+  server.on('request', (req, res) => res.end('ok'))
+
+  const response = await fetch(`https://${server.address().address}:${server.address().port}`, {
+    agent: new HttpsProxyAgent({
+      keepAlive: true,
+      keepAliveMsecs: 1000,
+      maxSockets: 256,
+      maxFreeSockets: 256,
+      scheduling: 'lifo',
+      proxy: `https://${proxy.address().address}:${proxy.address().port}`
+    })
+  })
+
+  t.is(await response.text(), 'ok')
+  t.is(response.status, 200)
+
+  server.close()
+  proxy.close()
+})

package/node_modules/hpagent/test/simple-get.test.js

@@ -0,0 +1,139 @@
+'use strict'
+
+const sget = require('simple-get')
+const test = require('ava')
+const {
+  createServer,
+  createSecureServer,
+  createProxy,
+  createSecureProxy
+} = require('./utils')
+const { HttpProxyAgent, HttpsProxyAgent } = require('..')
+
+test('http to http', async t => {
+  const server = await createServer()
+  const proxy = await createProxy()
+  server.on('request', (req, res) => res.end('ok'))
+
+  const response = await new Promise((resolve, reject) => {
+    sget.concat({
+      url: `http://${server.address().address}:${server.address().port}`,
+      agent: new HttpProxyAgent({
+        keepAlive: true,
+        keepAliveMsecs: 1000,
+        maxSockets: 256,
+        maxFreeSockets: 256,
+        scheduling: 'lifo',
+        proxy: `http://${proxy.address().address}:${proxy.address().port}`
+      })
+    }, function (err, response, data) {
+      if (err) {
+        return reject(err)
+      }
+      t.is(data.toString(), 'ok')
+
+      return resolve(response)
+    })
+  })
+
+  t.is(response.statusCode, 200)
+
+  server.close()
+  proxy.close()
+})
+
+test('https to http', async t => {
+  const server = await createServer()
+  const proxy = await createSecureProxy()
+  server.on('request', (req, res) => res.end('ok'))
+
+  const response = await new Promise((resolve, reject) => {
+    sget.concat({
+      url: `http://${server.address().address}:${server.address().port}`,
+      agent: new HttpProxyAgent({
+        keepAlive: true,
+        keepAliveMsecs: 1000,
+        maxSockets: 256,
+        maxFreeSockets: 256,
+        scheduling: 'lifo',
+        proxy: `https://${proxy.address().address}:${proxy.address().port}`
+      })
+    }, function (err, response, data) {
+      if (err) {
+        return reject(err)
+      }
+      t.is(data.toString(), 'ok')
+
+      return resolve(response)
+    })
+  })
+
+  t.is(response.statusCode, 200)
+
+  server.close()
+  proxy.close()
+})
+
+test('http to https', async t => {
+  const server = await createSecureServer()
+  const proxy = await createProxy()
+  server.on('request', (req, res) => res.end('ok'))
+
+  const response = await new Promise((resolve, reject) => {
+    sget.concat({
+      url: `https://${server.address().address}:${server.address().port}`,
+      agent: new HttpsProxyAgent({
+        keepAlive: true,
+        keepAliveMsecs: 1000,
+        maxSockets: 256,
+        maxFreeSockets: 256,
+        scheduling: 'lifo',
+        proxy: `http://${proxy.address().address}:${proxy.address().port}`
+      })
+    }, function (err, response, data) {
+      if (err) {
+        return reject(err)
+      }
+      t.is(data.toString(), 'ok')
+
+      return resolve(response)
+    })
+  })
+
+  t.is(response.statusCode, 200)
+
+  server.close()
+  proxy.close()
+})
+
+test('https to https', async t => {
+  const server = await createSecureServer()
+  const proxy = await createSecureProxy()
+  server.on('request', (req, res) => res.end('ok'))
+
+  const response = await new Promise((resolve, reject) => {
+    sget.concat({
+      url: `https://${server.address().address}:${server.address().port}`,
+      agent: new HttpsProxyAgent({
+        keepAlive: true,
+        keepAliveMsecs: 1000,
+        maxSockets: 256,
+        maxFreeSockets: 256,
+        scheduling: 'lifo',
+        proxy: `https://${proxy.address().address}:${proxy.address().port}`
+      })
+    }, function (err, response, data) {
+      if (err) {
+        return reject(err)
+      }
+      t.is(data.toString(), 'ok')
+
+      return resolve(response)
+    })
+  })
+
+  t.is(response.statusCode, 200)
+
+  server.close()
+  proxy.close()
+})