@wiajs/request 3.0.0 → 3.0.1

package/tests/test-pool.js

@@ -0,0 +1,148 @@
+'use strict'
+
+var request = require('../index')
+var http = require('http')
+var tape = require('tape')
+
+var s = http.createServer(function (req, res) {
+  res.statusCode = 200
+  res.end('asdf')
+})
+
+tape('setup', function (t) {
+  s.listen(0, function () {
+    s.url = 'http://localhost:' + this.address().port
+    t.end()
+  })
+})
+
+tape('pool', function (t) {
+  request({
+    url: s.url,
+    pool: false
+  }, function (err, res, body) {
+    t.equal(err, null)
+    t.equal(res.statusCode, 200)
+    t.equal(body, 'asdf')
+
+    var agent = res.request.agent
+    t.equal(agent, false)
+    t.end()
+  })
+})
+
+tape('forever', function (t) {
+  var r = request({
+    url: s.url,
+    forever: true,
+    pool: {maxSockets: 1024}
+  }, function (err, res, body) {
+    // explicitly shut down the agent
+    if (typeof r.agent.destroy === 'function') {
+      r.agent.destroy()
+    } else {
+      // node < 0.12
+      Object.keys(r.agent.sockets).forEach(function (name) {
+        r.agent.sockets[name].forEach(function (socket) {
+          socket.end()
+        })
+      })
+    }
+
+    t.equal(err, null)
+    t.equal(res.statusCode, 200)
+    t.equal(body, 'asdf')
+
+    var agent = res.request.agent
+    t.equal(agent.maxSockets, 1024)
+    t.end()
+  })
+})
+
+tape('forever, should use same agent in sequential requests', function (t) {
+  var r = request.defaults({
+    forever: true
+  })
+  var req1 = r(s.url)
+  var req2 = r(s.url + '/somepath')
+  req1.abort()
+  req2.abort()
+  if (typeof req1.agent.destroy === 'function') {
+    req1.agent.destroy()
+  }
+  if (typeof req2.agent.destroy === 'function') {
+    req2.agent.destroy()
+  }
+  t.equal(req1.agent, req2.agent)
+  t.end()
+})
+
+tape('forever, should use same agent in sequential requests(with pool.maxSockets)', function (t) {
+  var r = request.defaults({
+    forever: true,
+    pool: {maxSockets: 1024}
+  })
+  var req1 = r(s.url)
+  var req2 = r(s.url + '/somepath')
+  req1.abort()
+  req2.abort()
+  if (typeof req1.agent.destroy === 'function') {
+    req1.agent.destroy()
+  }
+  if (typeof req2.agent.destroy === 'function') {
+    req2.agent.destroy()
+  }
+  t.equal(req1.agent.maxSockets, 1024)
+  t.equal(req1.agent, req2.agent)
+  t.end()
+})
+
+tape('forever, should use same agent in request() and request.verb', function (t) {
+  var r = request.defaults({
+    forever: true,
+    pool: {maxSockets: 1024}
+  })
+  var req1 = r(s.url)
+  var req2 = r.get(s.url)
+  req1.abort()
+  req2.abort()
+  if (typeof req1.agent.destroy === 'function') {
+    req1.agent.destroy()
+  }
+  if (typeof req2.agent.destroy === 'function') {
+    req2.agent.destroy()
+  }
+  t.equal(req1.agent.maxSockets, 1024)
+  t.equal(req1.agent, req2.agent)
+  t.end()
+})
+
+tape('should use different agent if pool option specified', function (t) {
+  var r = request.defaults({
+    forever: true,
+    pool: {maxSockets: 1024}
+  })
+  var req1 = r(s.url)
+  var req2 = r.get({
+    url: s.url,
+    pool: {maxSockets: 20}
+  })
+  req1.abort()
+  req2.abort()
+  if (typeof req1.agent.destroy === 'function') {
+    req1.agent.destroy()
+  }
+  if (typeof req2.agent.destroy === 'function') {
+    req2.agent.destroy()
+  }
+  t.equal(req1.agent.maxSockets, 1024)
+  t.equal(req2.agent.maxSockets, 20)
+  t.notEqual(req1.agent, req2.agent)
+  t.end()
+})
+
+tape('cleanup', function (t) {
+  s.close(function () {
+    t.end()
+  })
+})

package/tests/test-promise.js

@@ -0,0 +1,53 @@
+'use strict'
+
+var http = require('http')
+var request = require('../index')
+var tape = require('tape')
+var Promise = require('bluebird')
+
+var s = http.createServer(function (req, res) {
+  res.writeHead(200, {})
+  res.end('ok')
+})
+
+tape('setup', function (t) {
+  s.listen(0, function () {
+    s.url = 'http://localhost:' + this.address().port
+    t.end()
+  })
+})
+
+tape('promisify convenience method', function (t) {
+  var get = request.get
+  var p = Promise.promisify(get, {multiArgs: true})
+  p(s.url)
+    .then(function (results) {
+      var res = results[0]
+      t.equal(res.statusCode, 200)
+      t.end()
+    })
+})
+
+tape('promisify request function', function (t) {
+  var p = Promise.promisify(request, {multiArgs: true})
+  p(s.url)
+    .spread(function (res, body) {
+      t.equal(res.statusCode, 200)
+      t.end()
+    })
+})
+
+tape('promisify all methods', function (t) {
+  Promise.promisifyAll(request, {multiArgs: true})
+  request.getAsync(s.url)
+    .spread(function (res, body) {
+      t.equal(res.statusCode, 200)
+      t.end()
+    })
+})
+
+tape('cleanup', function (t) {
+  s.close(function () {
+    t.end()
+  })
+})

package/tests/test-proxy-connect.js

@@ -0,0 +1,80 @@
+'use strict'
+
+var request = require('../index')
+var tape = require('tape')
+
+var called = false
+var proxiedHost = 'google.com'
+var data = ''
+
+var s = require('net').createServer(function (sock) {
+  called = true
+  sock.once('data', function (c) {
+    data += c
+
+    sock.write('HTTP/1.1 200 OK\r\n\r\n')
+
+    sock.once('data', function (c) {
+      data += c
+
+      sock.write('HTTP/1.1 200 OK\r\n')
+      sock.write('content-type: text/plain\r\n')
+      sock.write('content-length: 5\r\n')
+      sock.write('\r\n')
+      sock.end('derp\n')
+    })
+  })
+})
+
+tape('setup', function (t) {
+  s.listen(0, function () {
+    s.url = 'http://localhost:' + this.address().port
+    t.end()
+  })
+})
+
+tape('proxy', function (t) {
+  request({
+    tunnel: true,
+    url: 'http://' + proxiedHost,
+    proxy: s.url,
+    headers: {
+      'Proxy-Authorization': 'Basic dXNlcjpwYXNz',
+      'authorization': 'Token deadbeef',
+      'dont-send-to-proxy': 'ok',
+      'dont-send-to-dest': 'ok',
+      'accept': 'yo',
+      'user-agent': 'just another foobar'
+    },
+    proxyHeaderExclusiveList: ['Dont-send-to-dest']
+  }, function (err, res, body) {
+    t.equal(err, null)
+    t.equal(res.statusCode, 200)
+    t.equal(body, 'derp\n')
+    var re = new RegExp([
+      'CONNECT google.com:80 HTTP/1.1',
+      'Proxy-Authorization: Basic dXNlcjpwYXNz',
+      'dont-send-to-dest: ok',
+      'accept: yo',
+      'user-agent: just another foobar',
+      'host: google.com:80',
+      'Connection: close',
+      '',
+      'GET / HTTP/1.1',
+      'authorization: Token deadbeef',
+      'dont-send-to-proxy: ok',
+      'accept: yo',
+      'user-agent: just another foobar',
+      'host: google.com'
+    ].join('\r\n'))
+    t.equal(true, re.test(data))
+    t.equal(called, true, 'the request must be made to the proxy server')
+    t.end()
+  })
+})
+
+tape('cleanup', function (t) {
+  s.close(function () {
+    t.end()
+  })
+})

package/tests/test-proxy.js

@@ -0,0 +1,304 @@
+'use strict'
+
+var server = require('./server')
+var request = require('../index')
+var tape = require('tape')
+
+var s = server.createServer()
+var currResponseHandler
+
+['http://google.com/', 'https://google.com/'].forEach(function (url) {
+  s.on(url, function (req, res) {
+    currResponseHandler(req, res)
+    res.writeHeader(200)
+    res.end('ok')
+  })
+})
+
+var proxyEnvVars = [
+  'http_proxy',
+  'HTTP_PROXY',
+  'https_proxy',
+  'HTTPS_PROXY',
+  'no_proxy',
+  'NO_PROXY'
+]
+
+// Set up and run a proxy test.  All environment variables pertaining to
+// proxies will be deleted before each test.  Specify environment variables as
+// `options.env`; all other keys on `options` will be passed as additional
+// options to `request`.
+//
+// If `responseHandler` is a function, it should perform asserts on the server
+// response.  It will be called with parameters (t, req, res).  Otherwise,
+// `responseHandler` should be truthy to indicate that the proxy should be used
+// for this request, or falsy to indicate that the proxy should not be used for
+// this request.
+function runTest (name, options, responseHandler) {
+  tape(name, function (t) {
+    proxyEnvVars.forEach(function (v) {
+      delete process.env[v]
+    })
+    if (options.env) {
+      for (var v in options.env) {
+        process.env[v] = options.env[v]
+      }
+      delete options.env
+    }
+
+    var called = false
+    currResponseHandler = function (req, res) {
+      if (responseHandler) {
+        called = true
+        t.equal(req.headers.host, 'google.com')
+        if (typeof responseHandler === 'function') {
+          responseHandler(t, req, res)
+        }
+      } else {
+        t.fail('proxy response should not be called')
+      }
+    }
+
+    options.url = options.url || 'http://google.com'
+    request(options, function (err, res, body) {
+      if (responseHandler && !called) {
+        t.fail('proxy response should be called')
+      }
+      t.equal(err, null)
+      t.equal(res.statusCode, 200)
+      if (responseHandler) {
+        if (body.length > 100) {
+          body = body.substring(0, 100)
+        }
+        t.equal(body, 'ok')
+      } else {
+        t.equal(/^<!doctype html>/i.test(body), true)
+      }
+      t.end()
+    })
+  })
+}
+
+function addTests () {
+  // If the `runTest` function is changed, run the following command and make
+  // sure both of these tests fail:
+  //
+  //   TEST_PROXY_HARNESS=y node tests/test-proxy.js
+
+  if (process.env.TEST_PROXY_HARNESS) {
+    runTest('should fail with "proxy response should not be called"', {
+      proxy: s.url
+    }, false)
+
+    runTest('should fail with "proxy response should be called"', {
+      proxy: null
+    }, true)
+  } else {
+    // Run the real tests
+
+    runTest('basic proxy', {
+      proxy: s.url,
+      headers: {
+        'proxy-authorization': 'Token Fooblez'
+      }
+    }, function (t, req, res) {
+      t.equal(req.headers['proxy-authorization'], 'Token Fooblez')
+    })
+
+    runTest('proxy auth without uri auth', {
+      proxy: 'http://user:pass@localhost:' + s.port
+    }, function (t, req, res) {
+      t.equal(req.headers['proxy-authorization'], 'Basic dXNlcjpwYXNz')
+    })
+
+    // http: urls and basic proxy settings
+
+    runTest('HTTP_PROXY environment variable and http: url', {
+      env: { HTTP_PROXY: s.url }
+    }, true)
+
+    runTest('http_proxy environment variable and http: url', {
+      env: { http_proxy: s.url }
+    }, true)
+
+    runTest('HTTPS_PROXY environment variable and http: url', {
+      env: { HTTPS_PROXY: s.url }
+    }, false)
+
+    runTest('https_proxy environment variable and http: url', {
+      env: { https_proxy: s.url }
+    }, false)
+
+    // https: urls and basic proxy settings
+
+    runTest('HTTP_PROXY environment variable and https: url', {
+      env: { HTTP_PROXY: s.url },
+      url: 'https://google.com',
+      tunnel: false,
+      pool: false
+    }, true)
+
+    runTest('http_proxy environment variable and https: url', {
+      env: { http_proxy: s.url },
+      url: 'https://google.com',
+      tunnel: false
+    }, true)
+
+    runTest('HTTPS_PROXY environment variable and https: url', {
+      env: { HTTPS_PROXY: s.url },
+      url: 'https://google.com',
+      tunnel: false
+    }, true)
+
+    runTest('https_proxy environment variable and https: url', {
+      env: { https_proxy: s.url },
+      url: 'https://google.com',
+      tunnel: false
+    }, true)
+
+    runTest('multiple environment variables and https: url', {
+      env: {
+        HTTPS_PROXY: s.url,
+        HTTP_PROXY: 'http://localhost:0/'
+      },
+      url: 'https://google.com',
+      tunnel: false
+    }, true)
+
+    // no_proxy logic
+
+    runTest('NO_PROXY hostnames are case insensitive', {
+      env: {
+        HTTP_PROXY: s.url,
+        NO_PROXY: 'GOOGLE.COM'
+      }
+    }, false)
+
+    runTest('NO_PROXY hostnames are case insensitive 2', {
+      env: {
+        http_proxy: s.url,
+        NO_PROXY: 'GOOGLE.COM'
+      }
+    }, false)
+
+    runTest('NO_PROXY hostnames are case insensitive 3', {
+      env: {
+        HTTP_PROXY: s.url,
+        no_proxy: 'GOOGLE.COM'
+      }
+    }, false)
+
+    runTest('NO_PROXY ignored with explicit proxy passed', {
+      env: { NO_PROXY: '*' },
+      proxy: s.url
+    }, true)
+
+    runTest('NO_PROXY overrides HTTP_PROXY for specific hostname', {
+      env: {
+        HTTP_PROXY: s.url,
+        NO_PROXY: 'google.com'
+      }
+    }, false)
+
+    runTest('no_proxy overrides HTTP_PROXY for specific hostname', {
+      env: {
+        HTTP_PROXY: s.url,
+        no_proxy: 'google.com'
+      }
+    }, false)
+
+    runTest('NO_PROXY does not override HTTP_PROXY if no hostnames match', {
+      env: {
+        HTTP_PROXY: s.url,
+        NO_PROXY: 'foo.bar,bar.foo'
+      }
+    }, true)
+
+    runTest('NO_PROXY overrides HTTP_PROXY if a hostname matches', {
+      env: {
+        HTTP_PROXY: s.url,
+        NO_PROXY: 'foo.bar,google.com'
+      }
+    }, false)
+
+    runTest('NO_PROXY allows an explicit port', {
+      env: {
+        HTTP_PROXY: s.url,
+        NO_PROXY: 'google.com:80'
+      }
+    }, false)
+
+    runTest('NO_PROXY only overrides HTTP_PROXY if the port matches', {
+      env: {
+        HTTP_PROXY: s.url,
+        NO_PROXY: 'google.com:1234'
+      }
+    }, true)
+
+    runTest('NO_PROXY=* should override HTTP_PROXY for all hosts', {
+      env: {
+        HTTP_PROXY: s.url,
+        NO_PROXY: '*'
+      }
+    }, false)
+
+    runTest('NO_PROXY should override HTTP_PROXY for all subdomains', {
+      env: {
+        HTTP_PROXY: s.url,
+        NO_PROXY: 'google.com'
+      },
+      headers: { host: 'www.google.com' }
+    }, false)
+
+    runTest('NO_PROXY should not override HTTP_PROXY for partial domain matches', {
+      env: {
+        HTTP_PROXY: s.url,
+        NO_PROXY: 'oogle.com'
+      }
+    }, true)
+
+    runTest('NO_PROXY with port should not override HTTP_PROXY for partial domain matches', {
+      env: {
+        HTTP_PROXY: s.url,
+        NO_PROXY: 'oogle.com:80'
+      }
+    }, true)
+
+    // misc
+
+    // this fails if the check 'isMatchedAt > -1' in lib/getProxyFromURI.js is
+    // missing or broken
+    runTest('http_proxy with length of one more than the URL', {
+      env: {
+        HTTP_PROXY: s.url,
+        NO_PROXY: 'elgoog1.com' // one more char than google.com
+      }
+    }, true)
+
+    runTest('proxy: null should override HTTP_PROXY', {
+      env: { HTTP_PROXY: s.url },
+      proxy: null,
+      timeout: 500
+    }, false)
+
+    runTest('uri auth without proxy auth', {
+      url: 'http://user:pass@google.com',
+      proxy: s.url
+    }, function (t, req, res) {
+      t.equal(req.headers['proxy-authorization'], undefined)
+      t.equal(req.headers.authorization, 'Basic dXNlcjpwYXNz')
+    })
+  }
+}
+
+tape('setup', function (t) {
+  s.listen(0, function () {
+    addTests()
+    tape('cleanup', function (t) {
+      s.close(function () {
+        t.end()
+      })
+    })
+    t.end()
+  })
+})

package/tests/test-qs.js

@@ -0,0 +1,135 @@
+'use strict'
+
+var request = require('../index')
+var tape = require('tape')
+
+// Run a querystring test.  `options` can have the following keys:
+//   - suffix              : a string to be added to the URL
+//   - qs                  : an object to be passed to request's `qs` option
+//   - qsParseOptions      : an object to be passed to request's `qsParseOptions` option
+//   - qsStringifyOptions  : an object to be passed to request's `qsStringifyOptions` option
+//   - afterRequest        : a function to execute after creating the request
+//   - expected            : the expected path of the request
+//   - expectedQuerystring : expected path when using the querystring library
+function runTest (name, options) {
+  var uri = 'http://www.google.com' + (options.suffix || '')
+  var opts = {
+    uri: uri,
+    qsParseOptions: options.qsParseOptions,
+    qsStringifyOptions: options.qsStringifyOptions
+  }
+
+  if (options.qs) {
+    opts.qs = options.qs
+  }
+
+  tape(name + ' - using qs', function (t) {
+    var r = request.get(opts)
+    if (typeof options.afterRequest === 'function') {
+      options.afterRequest(r)
+    }
+    process.nextTick(function () {
+      t.equal(r.path, options.expected)
+      r.abort()
+      t.end()
+    })
+  })
+
+  tape(name + ' - using querystring', function (t) {
+    opts.useQuerystring = true
+    var r = request.get(opts)
+    if (typeof options.afterRequest === 'function') {
+      options.afterRequest(r)
+    }
+    process.nextTick(function () {
+      t.equal(r.path, options.expectedQuerystring || options.expected)
+      r.abort()
+      t.end()
+    })
+  })
+}
+
+function esc (str) {
+  return str
+    .replace(/\[/g, '%5B')
+    .replace(/\]/g, '%5D')
+}
+
+runTest('adding a querystring', {
+  qs: { q: 'search' },
+  expected: '/?q=search'
+})
+
+runTest('replacing a querystring value', {
+  suffix: '?q=abc',
+  qs: { q: 'search' },
+  expected: '/?q=search'
+})
+
+runTest('appending a querystring value to the ones present in the uri', {
+  suffix: '?x=y',
+  qs: { q: 'search' },
+  expected: '/?x=y&q=search'
+})
+
+runTest('leaving a querystring alone', {
+  suffix: '?x=y',
+  expected: '/?x=y'
+})
+
+runTest('giving empty qs property', {
+  qs: {},
+  expected: '/'
+})
+
+runTest('modifying the qs after creating the request', {
+  qs: {},
+  afterRequest: function (r) {
+    r.qs({ q: 'test' })
+  },
+  expected: '/?q=test'
+})
+
+runTest('a query with an object for a value', {
+  qs: { where: { foo: 'bar' } },
+  expected: esc('/?where[foo]=bar'),
+  expectedQuerystring: '/?where='
+})
+
+runTest('a query with an array for a value', {
+  qs: { order: ['bar', 'desc'] },
+  expected: esc('/?order[0]=bar&order[1]=desc'),
+  expectedQuerystring: '/?order=bar&order=desc'
+})
+
+runTest('pass options to the qs module via the qsParseOptions key', {
+  suffix: '?a=1;b=2',
+  qs: {},
+  qsParseOptions: { delimiter: ';' },
+  qsStringifyOptions: { delimiter: ';' },
+  expected: esc('/?a=1;b=2'),
+  expectedQuerystring: '/?a=1%3Bb%3D2'
+})
+
+runTest('pass options to the qs module via the qsStringifyOptions key', {
+  qs: { order: ['bar', 'desc'] },
+  qsStringifyOptions: { arrayFormat: 'brackets' },
+  expected: esc('/?order[]=bar&order[]=desc'),
+  expectedQuerystring: '/?order=bar&order=desc'
+})
+
+runTest('pass options to the querystring module via the qsParseOptions key', {
+  suffix: '?a=1;b=2',
+  qs: {},
+  qsParseOptions: { sep: ';' },
+  qsStringifyOptions: { sep: ';' },
+  expected: esc('/?a=1%3Bb%3D2'),
+  expectedQuerystring: '/?a=1;b=2'
+})
+
+runTest('pass options to the querystring module via the qsStringifyOptions key', {
+  qs: { order: ['bar', 'desc'] },
+  qsStringifyOptions: { sep: ';' },
+  expected: esc('/?order[0]=bar&order[1]=desc'),
+  expectedQuerystring: '/?order=bar;order=desc'
+})