@wiajs/request 3.0.0 → 3.0.1

package/tests/test-redirect-auth.js

@@ -0,0 +1,131 @@
+'use strict'
+
+var server = require('./server')
+var request = require('../index')
+var util = require('util')
+var tape = require('tape')
+var destroyable = require('server-destroy')
+
+var s = server.createServer()
+var ss = server.createSSLServer()
+
+destroyable(s)
+destroyable(ss)
+
+// always send basic auth and allow non-strict SSL
+request = request.defaults({
+  auth: {
+    user: 'test',
+    pass: 'testing'
+  },
+  rejectUnauthorized: false
+})
+
+// redirect.from(proto, host).to(proto, host) returns an object with keys:
+//   src : source URL
+//   dst : destination URL
+var redirect = {
+  from: function (fromProto, fromHost) {
+    return {
+      to: function (toProto, toHost) {
+        var fromPort = (fromProto === 'http' ? s.port : ss.port)
+        var toPort = (toProto === 'http' ? s.port : ss.port)
+        return {
+          src: util.format(
+            '%s://%s:%d/to/%s/%s',
+            fromProto, fromHost, fromPort, toProto, toHost),
+          dst: util.format(
+            '%s://%s:%d/from/%s/%s',
+            toProto, toHost, toPort, fromProto, fromHost)
+        }
+      }
+    }
+  }
+}
+
+function handleRequests (srv) {
+  ['http', 'https'].forEach(function (proto) {
+    ['localhost', '127.0.0.1'].forEach(function (host) {
+      srv.on(util.format('/to/%s/%s', proto, host), function (req, res) {
+        var r = redirect
+          .from(srv.protocol, req.headers.host.split(':')[0])
+          .to(proto, host)
+        res.writeHead(301, {
+          location: r.dst
+        })
+        res.end()
+      })
+
+      srv.on(util.format('/from/%s/%s', proto, host), function (req, res) {
+        res.end('auth: ' + (req.headers.authorization || '(nothing)'))
+      })
+    })
+  })
+}
+
+handleRequests(s)
+handleRequests(ss)
+
+function runTest (name, redir, expectAuth) {
+  tape('redirect to ' + name, function (t) {
+    request(redir.src, function (err, res, body) {
+      t.equal(err, null)
+      t.equal(res.request.uri.href, redir.dst)
+      t.equal(res.statusCode, 200)
+      t.equal(body, expectAuth
+        ? 'auth: Basic dGVzdDp0ZXN0aW5n'
+        : 'auth: (nothing)')
+      t.end()
+    })
+  })
+}
+
+function addTests () {
+  runTest('same host and protocol',
+    redirect.from('http', 'localhost').to('http', 'localhost'),
+    true)
+
+  runTest('same host different protocol',
+    redirect.from('http', 'localhost').to('https', 'localhost'),
+    true)
+
+  runTest('different host same protocol',
+    redirect.from('https', '127.0.0.1').to('https', 'localhost'),
+    false)
+
+  runTest('different host and protocol',
+    redirect.from('http', 'localhost').to('https', '127.0.0.1'),
+    false)
+}
+
+tape('setup', function (t) {
+  s.listen(0, function () {
+    ss.listen(0, function () {
+      addTests()
+      tape('cleanup', function (t) {
+        s.destroy(function () {
+          ss.destroy(function () {
+            t.end()
+          })
+        })
+      })
+      t.end()
+    })
+  })
+})
+
+tape('redirect URL helper', function (t) {
+  t.deepEqual(
+    redirect.from('http', 'localhost').to('https', '127.0.0.1'),
+    {
+      src: util.format('http://localhost:%d/to/https/127.0.0.1', s.port),
+      dst: util.format('https://127.0.0.1:%d/from/http/localhost', ss.port)
+    })
+  t.deepEqual(
+    redirect.from('https', 'localhost').to('http', 'localhost'),
+    {
+      src: util.format('https://localhost:%d/to/http/localhost', ss.port),
+      dst: util.format('http://localhost:%d/from/https/localhost', s.port)
+    })
+  t.end()
+})

package/tests/test-redirect-complex.js

@@ -0,0 +1,93 @@
+'use strict'
+
+var server = require('./server')
+var request = require('../index')
+var events = require('events')
+var tape = require('tape')
+var destroyable = require('server-destroy')
+
+var s = server.createServer()
+var ss = server.createSSLServer()
+var e = new events.EventEmitter()
+
+destroyable(s)
+destroyable(ss)
+
+function bouncy (s, serverUrl) {
+  var redirs = {
+    a: 'b',
+    b: 'c',
+    c: 'd',
+    d: 'e',
+    e: 'f',
+    f: 'g',
+    g: 'h',
+    h: 'end'
+  }
+
+  var perm = true
+  Object.keys(redirs).forEach(function (p) {
+    var t = redirs[p]
+
+    // switch type each time
+    var type = perm ? 301 : 302
+    perm = !perm
+    s.on('/' + p, function (req, res) {
+      setTimeout(function () {
+        res.writeHead(type, { location: serverUrl + '/' + t })
+        res.end()
+      }, Math.round(Math.random() * 25))
+    })
+  })
+
+  s.on('/end', function (req, res) {
+    var key = req.headers['x-test-key']
+    e.emit('hit-' + key, key)
+    res.writeHead(200)
+    res.end(key)
+  })
+}
+
+tape('setup', function (t) {
+  s.listen(0, function () {
+    ss.listen(0, function () {
+      bouncy(s, ss.url)
+      bouncy(ss, s.url)
+      t.end()
+    })
+  })
+})
+
+tape('lots of redirects', function (t) {
+  var n = 10
+  t.plan(n * 4)
+
+  function doRedirect (i) {
+    var key = 'test_' + i
+    request({
+      url: (i % 2 ? s.url : ss.url) + '/a',
+      headers: { 'x-test-key': key },
+      rejectUnauthorized: false
+    }, function (err, res, body) {
+      t.equal(err, null)
+      t.equal(res.statusCode, 200)
+      t.equal(body, key)
+    })
+
+    e.once('hit-' + key, function (v) {
+      t.equal(v, key)
+    })
+  }
+
+  for (var i = 0; i < n; i++) {
+    doRedirect(i)
+  }
+})
+
+tape('cleanup', function (t) {
+  s.destroy(function () {
+    ss.destroy(function () {
+      t.end()
+    })
+  })
+})

package/tests/test-redirect.js

@@ -0,0 +1,449 @@
+'use strict'
+
+var server = require('./server')
+var assert = require('assert')
+var request = require('../index')
+var tape = require('tape')
+var http = require('http')
+var destroyable = require('server-destroy')
+
+var s = server.createServer()
+var ss = server.createSSLServer()
+var hits = {}
+var jar = request.jar()
+
+destroyable(s)
+destroyable(ss)
+
+s.on('/ssl', function (req, res) {
+  res.writeHead(302, {
+    location: ss.url + '/'
+  })
+  res.end()
+})
+
+ss.on('/', function (req, res) {
+  res.writeHead(200)
+  res.end('SSL')
+})
+
+function createRedirectEndpoint (code, label, landing) {
+  s.on('/' + label, function (req, res) {
+    hits[label] = true
+    res.writeHead(code, {
+      'location': s.url + '/' + landing,
+      'set-cookie': 'ham=eggs'
+    })
+    res.end()
+  })
+}
+
+function createLandingEndpoint (landing) {
+  s.on('/' + landing, function (req, res) {
+    // Make sure the cookie doesn't get included twice, see #139:
+    // Make sure cookies are set properly after redirect
+    assert.equal(req.headers.cookie, 'foo=bar; quux=baz; ham=eggs')
+    hits[landing] = true
+    res.writeHead(200, {'x-response': req.method.toUpperCase() + ' ' + landing})
+    res.end(req.method.toUpperCase() + ' ' + landing)
+  })
+}
+
+function bouncer (code, label, hops) {
+  var hop
+  var landing = label + '_landing'
+  var currentLabel
+  var currentLanding
+
+  hops = hops || 1
+
+  if (hops === 1) {
+    createRedirectEndpoint(code, label, landing)
+  } else {
+    for (hop = 0; hop < hops; hop++) {
+      currentLabel = (hop === 0) ? label : label + '_' + (hop + 1)
+      currentLanding = (hop === hops - 1) ? landing : label + '_' + (hop + 2)
+
+      createRedirectEndpoint(code, currentLabel, currentLanding)
+    }
+  }
+
+  createLandingEndpoint(landing)
+}
+
+tape('setup', function (t) {
+  s.listen(0, function () {
+    ss.listen(0, function () {
+      bouncer(301, 'temp')
+      bouncer(301, 'double', 2)
+      bouncer(301, 'treble', 3)
+      bouncer(302, 'perm')
+      bouncer(302, 'nope')
+      bouncer(307, 'fwd')
+      t.end()
+    })
+  })
+})
+
+tape('permanent bounce', function (t) {
+  jar.setCookie('quux=baz', s.url)
+  hits = {}
+  request({
+    uri: s.url + '/perm',
+    jar: jar,
+    headers: { cookie: 'foo=bar' }
+  }, function (err, res, body) {
+    t.equal(err, null)
+    t.equal(res.statusCode, 200)
+    t.ok(hits.perm, 'Original request is to /perm')
+    t.ok(hits.perm_landing, 'Forward to permanent landing URL')
+    t.equal(body, 'GET perm_landing', 'Got permanent landing content')
+    t.end()
+  })
+})
+
+tape('preserve HEAD method when using followAllRedirects', function (t) {
+  jar.setCookie('quux=baz', s.url)
+  hits = {}
+  request({
+    method: 'HEAD',
+    uri: s.url + '/perm',
+    followAllRedirects: true,
+    jar: jar,
+    headers: { cookie: 'foo=bar' }
+  }, function (err, res, body) {
+    t.equal(err, null)
+    t.equal(res.statusCode, 200)
+    t.ok(hits.perm, 'Original request is to /perm')
+    t.ok(hits.perm_landing, 'Forward to permanent landing URL')
+    t.equal(res.headers['x-response'], 'HEAD perm_landing', 'Got permanent landing content')
+    t.end()
+  })
+})
+
+tape('temporary bounce', function (t) {
+  hits = {}
+  request({
+    uri: s.url + '/temp',
+    jar: jar,
+    headers: { cookie: 'foo=bar' }
+  }, function (err, res, body) {
+    t.equal(err, null)
+    t.equal(res.statusCode, 200)
+    t.ok(hits.temp, 'Original request is to /temp')
+    t.ok(hits.temp_landing, 'Forward to temporary landing URL')
+    t.equal(body, 'GET temp_landing', 'Got temporary landing content')
+    t.end()
+  })
+})
+
+tape('prevent bouncing', function (t) {
+  hits = {}
+  request({
+    uri: s.url + '/nope',
+    jar: jar,
+    headers: { cookie: 'foo=bar' },
+    followRedirect: false
+  }, function (err, res, body) {
+    t.equal(err, null)
+    t.equal(res.statusCode, 302)
+    t.ok(hits.nope, 'Original request to /nope')
+    t.ok(!hits.nope_landing, 'No chasing the redirect')
+    t.equal(res.statusCode, 302, 'Response is the bounce itself')
+    t.end()
+  })
+})
+
+tape('should not follow post redirects by default', function (t) {
+  hits = {}
+  request.post(s.url + '/temp', {
+    jar: jar,
+    headers: { cookie: 'foo=bar' }
+  }, function (err, res, body) {
+    t.equal(err, null)
+    t.equal(res.statusCode, 301)
+    t.ok(hits.temp, 'Original request is to /temp')
+    t.ok(!hits.temp_landing, 'No chasing the redirect when post')
+    t.equal(res.statusCode, 301, 'Response is the bounce itself')
+    t.end()
+  })
+})
+
+tape('should follow post redirects when followallredirects true', function (t) {
+  hits = {}
+  request.post({
+    uri: s.url + '/temp',
+    followAllRedirects: true,
+    jar: jar,
+    headers: { cookie: 'foo=bar' }
+  }, function (err, res, body) {
+    t.equal(err, null)
+    t.equal(res.statusCode, 200)
+    t.ok(hits.temp, 'Original request is to /temp')
+    t.ok(hits.temp_landing, 'Forward to temporary landing URL')
+    t.equal(body, 'GET temp_landing', 'Got temporary landing content')
+    t.end()
+  })
+})
+
+tape('should follow post redirects when followallredirects true and followOriginalHttpMethod is enabled', function (t) {
+  hits = {}
+  request.post({
+    uri: s.url + '/temp',
+    followAllRedirects: true,
+    followOriginalHttpMethod: true,
+    jar: jar,
+    headers: { cookie: 'foo=bar' }
+  }, function (err, res, body) {
+    t.equal(err, null)
+    t.equal(res.statusCode, 200)
+    t.ok(hits.temp, 'Original request is to /temp')
+    t.ok(hits.temp_landing, 'Forward to temporary landing URL')
+    t.equal(body, 'POST temp_landing', 'Got temporary landing content')
+    t.end()
+  })
+})
+
+tape('should not follow post redirects when followallredirects false', function (t) {
+  hits = {}
+  request.post({
+    uri: s.url + '/temp',
+    followAllRedirects: false,
+    jar: jar,
+    headers: { cookie: 'foo=bar' }
+  }, function (err, res, body) {
+    t.equal(err, null)
+    t.equal(res.statusCode, 301)
+    t.ok(hits.temp, 'Original request is to /temp')
+    t.ok(!hits.temp_landing, 'No chasing the redirect')
+    t.equal(res.statusCode, 301, 'Response is the bounce itself')
+    t.end()
+  })
+})
+
+tape('should not follow delete redirects by default', function (t) {
+  hits = {}
+  request.del(s.url + '/temp', {
+    jar: jar,
+    headers: { cookie: 'foo=bar' }
+  }, function (err, res, body) {
+    t.equal(err, null)
+    t.ok(res.statusCode >= 301 && res.statusCode < 400, 'Status is a redirect')
+    t.ok(hits.temp, 'Original request is to /temp')
+    t.ok(!hits.temp_landing, 'No chasing the redirect when delete')
+    t.equal(res.statusCode, 301, 'Response is the bounce itself')
+    t.end()
+  })
+})
+
+tape('should not follow delete redirects even if followredirect is set to true', function (t) {
+  hits = {}
+  request.del(s.url + '/temp', {
+    followRedirect: true,
+    jar: jar,
+    headers: { cookie: 'foo=bar' }
+  }, function (err, res, body) {
+    t.equal(err, null)
+    t.equal(res.statusCode, 301)
+    t.ok(hits.temp, 'Original request is to /temp')
+    t.ok(!hits.temp_landing, 'No chasing the redirect when delete')
+    t.equal(res.statusCode, 301, 'Response is the bounce itself')
+    t.end()
+  })
+})
+
+tape('should follow delete redirects when followallredirects true', function (t) {
+  hits = {}
+  request.del(s.url + '/temp', {
+    followAllRedirects: true,
+    jar: jar,
+    headers: { cookie: 'foo=bar' }
+  }, function (err, res, body) {
+    t.equal(err, null)
+    t.equal(res.statusCode, 200)
+    t.ok(hits.temp, 'Original request is to /temp')
+    t.ok(hits.temp_landing, 'Forward to temporary landing URL')
+    t.equal(body, 'GET temp_landing', 'Got temporary landing content')
+    t.end()
+  })
+})
+
+tape('should follow 307 delete redirects when followallredirects true', function (t) {
+  hits = {}
+  request.del(s.url + '/fwd', {
+    followAllRedirects: true,
+    jar: jar,
+    headers: { cookie: 'foo=bar' }
+  }, function (err, res, body) {
+    t.equal(err, null)
+    t.equal(res.statusCode, 200)
+    t.ok(hits.fwd, 'Original request is to /fwd')
+    t.ok(hits.fwd_landing, 'Forward to temporary landing URL')
+    t.equal(body, 'DELETE fwd_landing', 'Got temporary landing content')
+    t.end()
+  })
+})
+
+tape('double bounce', function (t) {
+  hits = {}
+  request({
+    uri: s.url + '/double',
+    jar: jar,
+    headers: { cookie: 'foo=bar' }
+  }, function (err, res, body) {
+    t.equal(err, null)
+    t.equal(res.statusCode, 200)
+    t.ok(hits.double, 'Original request is to /double')
+    t.ok(hits.double_2, 'Forward to temporary landing URL')
+    t.ok(hits.double_landing, 'Forward to landing URL')
+    t.equal(body, 'GET double_landing', 'Got temporary landing content')
+    t.end()
+  })
+})
+
+tape('double bounce terminated after first redirect', function (t) {
+  function filterDouble (response) {
+    return (response.headers.location || '').indexOf('double_2') === -1
+  }
+
+  hits = {}
+  request({
+    uri: s.url + '/double',
+    jar: jar,
+    headers: { cookie: 'foo=bar' },
+    followRedirect: filterDouble
+  }, function (err, res, body) {
+    t.equal(err, null)
+    t.equal(res.statusCode, 301)
+    t.ok(hits.double, 'Original request is to /double')
+    t.equal(res.headers.location, s.url + '/double_2', 'Current location should be ' + s.url + '/double_2')
+    t.end()
+  })
+})
+
+tape('triple bounce terminated after second redirect', function (t) {
+  function filterTreble (response) {
+    return (response.headers.location || '').indexOf('treble_3') === -1
+  }
+
+  hits = {}
+  request({
+    uri: s.url + '/treble',
+    jar: jar,
+    headers: { cookie: 'foo=bar' },
+    followRedirect: filterTreble
+  }, function (err, res, body) {
+    t.equal(err, null)
+    t.equal(res.statusCode, 301)
+    t.ok(hits.treble, 'Original request is to /treble')
+    t.equal(res.headers.location, s.url + '/treble_3', 'Current location should be ' + s.url + '/treble_3')
+    t.end()
+  })
+})
+
+tape('http to https redirect', function (t) {
+  hits = {}
+  request.get({
+    uri: require('url').parse(s.url + '/ssl'),
+    rejectUnauthorized: false
+  }, function (err, res, body) {
+    t.equal(err, null)
+    t.equal(res.statusCode, 200)
+    t.equal(body, 'SSL', 'Got SSL redirect')
+    t.end()
+  })
+})
+
+tape('should have referer header by default when following redirect', function (t) {
+  request.post({
+    uri: s.url + '/temp',
+    jar: jar,
+    followAllRedirects: true,
+    headers: { cookie: 'foo=bar' }
+  }, function (err, res, body) {
+    t.equal(err, null)
+    t.equal(res.statusCode, 200)
+    t.end()
+  })
+  .on('redirect', function () {
+    t.equal(this.headers.referer, s.url + '/temp')
+  })
+})
+
+tape('should not have referer header when removeRefererHeader is true', function (t) {
+  request.post({
+    uri: s.url + '/temp',
+    jar: jar,
+    followAllRedirects: true,
+    removeRefererHeader: true,
+    headers: { cookie: 'foo=bar' }
+  }, function (err, res, body) {
+    t.equal(err, null)
+    t.equal(res.statusCode, 200)
+    t.end()
+  })
+  .on('redirect', function () {
+    t.equal(this.headers.referer, undefined)
+  })
+})
+
+tape('should preserve referer header set in the initial request when removeRefererHeader is true', function (t) {
+  request.post({
+    uri: s.url + '/temp',
+    jar: jar,
+    followAllRedirects: true,
+    removeRefererHeader: true,
+    headers: { cookie: 'foo=bar', referer: 'http://awesome.com' }
+  }, function (err, res, body) {
+    t.equal(err, null)
+    t.equal(res.statusCode, 200)
+    t.end()
+  })
+  .on('redirect', function () {
+    t.equal(this.headers.referer, 'http://awesome.com')
+  })
+})
+
+tape('should use same agent class on redirect', function (t) {
+  var agent
+  var calls = 0
+  var agentOptions = {}
+
+  function FakeAgent (agentOptions) {
+    var createConnection
+
+    agent = new http.Agent(agentOptions)
+    createConnection = agent.createConnection
+    agent.createConnection = function () {
+      calls++
+      return createConnection.apply(agent, arguments)
+    }
+
+    return agent
+  }
+
+  hits = {}
+  request.get({
+    uri: s.url + '/temp',
+    jar: jar,
+    headers: { cookie: 'foo=bar' },
+    agentOptions: agentOptions,
+    agentClass: FakeAgent
+  }, function (err, res, body) {
+    t.equal(err, null)
+    t.equal(res.statusCode, 200)
+    t.equal(body, 'GET temp_landing', 'Got temporary landing content')
+    t.equal(calls, 2)
+    t.ok(this.agent === agent, 'Reinstantiated the user-specified agent')
+    t.ok(this.agentOptions === agentOptions, 'Reused agent options')
+    t.end()
+  })
+})
+
+tape('cleanup', function (t) {
+  s.destroy(function () {
+    ss.destroy(function () {
+      t.end()
+    })
+  })
+})