@wiajs/request 3.0.0 → 3.0.1

package/tests/test-defaults.js

@@ -0,0 +1,340 @@
+'use strict'
+
+var server = require('./server')
+var request = require('../index')
+var qs = require('qs')
+var tape = require('tape')
+
+var s = server.createServer()
+
+tape('setup', function (t) {
+  s.listen(0, function () {
+    s.on('/', function (req, res) {
+      res.writeHead(200, {'content-type': 'application/json'})
+      res.end(JSON.stringify({
+        method: req.method,
+        headers: req.headers,
+        qs: qs.parse(req.url.replace(/.*\?(.*)/, '$1'))
+      }))
+    })
+
+    s.on('/head', function (req, res) {
+      res.writeHead(200, {'x-data': JSON.stringify({method: req.method, headers: req.headers})})
+      res.end()
+    })
+
+    s.on('/set-undefined', function (req, res) {
+      var data = ''
+      req.on('data', function (d) {
+        data += d
+      })
+      req.on('end', function () {
+        res.writeHead(200, {'Content-Type': 'application/json'})
+        res.end(JSON.stringify({
+          method: req.method, headers: req.headers, data: JSON.parse(data)
+        }))
+      })
+    })
+
+    t.end()
+  })
+})
+
+tape('get(string, function)', function (t) {
+  request.defaults({
+    headers: { foo: 'bar' }
+  })(s.url + '/', function (e, r, b) {
+    b = JSON.parse(b)
+    t.equal(b.method, 'GET')
+    t.equal(b.headers.foo, 'bar')
+    t.end()
+  })
+})
+
+tape('merge headers', function (t) {
+  request.defaults({
+    headers: { foo: 'bar', merged: 'no' }
+  })(s.url + '/', {
+    headers: { merged: 'yes' }, json: true
+  }, function (e, r, b) {
+    t.equal(b.headers.foo, 'bar')
+    t.equal(b.headers.merged, 'yes')
+    t.end()
+  })
+})
+
+tape('deep extend', function (t) {
+  request.defaults({
+    headers: { a: 1, b: 2 },
+    qs: { a: 1, b: 2 }
+  })(s.url + '/', {
+    headers: { b: 3, c: 4 },
+    qs: { b: 3, c: 4 },
+    json: true
+  }, function (e, r, b) {
+    delete b.headers.host
+    delete b.headers.accept
+    delete b.headers.connection
+    t.deepEqual(b.headers, { a: '1', b: '3', c: '4' })
+    t.deepEqual(b.qs, { a: '1', b: '3', c: '4' })
+    t.end()
+  })
+})
+
+tape('default undefined header', function (t) {
+  request.defaults({
+    headers: { foo: 'bar', test: undefined }, json: true
+  })(s.url + '/', function (e, r, b) {
+    t.equal(b.method, 'GET')
+    t.equal(b.headers.foo, 'bar')
+    t.equal(b.headers.test, undefined)
+    t.end()
+  })
+})
+
+tape('post(string, object, function)', function (t) {
+  request.defaults({
+    headers: { foo: 'bar' }
+  }).post(s.url + '/', { json: true }, function (e, r, b) {
+    t.equal(b.method, 'POST')
+    t.equal(b.headers.foo, 'bar')
+    t.equal(b.headers['content-type'], undefined)
+    t.end()
+  })
+})
+
+tape('patch(string, object, function)', function (t) {
+  request.defaults({
+    headers: { foo: 'bar' }
+  }).patch(s.url + '/', { json: true }, function (e, r, b) {
+    t.equal(b.method, 'PATCH')
+    t.equal(b.headers.foo, 'bar')
+    t.equal(b.headers['content-type'], undefined)
+    t.end()
+  })
+})
+
+tape('post(string, object, function) with body', function (t) {
+  request.defaults({
+    headers: { foo: 'bar' }
+  }).post(s.url + '/', {
+    json: true,
+    body: { bar: 'baz' }
+  }, function (e, r, b) {
+    t.equal(b.method, 'POST')
+    t.equal(b.headers.foo, 'bar')
+    t.equal(b.headers['content-type'], 'application/json')
+    t.end()
+  })
+})
+
+tape('del(string, function)', function (t) {
+  request.defaults({
+    headers: {foo: 'bar'},
+    json: true
+  }).del(s.url + '/', function (e, r, b) {
+    t.equal(b.method, 'DELETE')
+    t.equal(b.headers.foo, 'bar')
+    t.end()
+  })
+})
+
+tape('delete(string, function)', function (t) {
+  request.defaults({
+    headers: {foo: 'bar'},
+    json: true
+  }).delete(s.url + '/', function (e, r, b) {
+    t.equal(b.method, 'DELETE')
+    t.equal(b.headers.foo, 'bar')
+    t.end()
+  })
+})
+
+tape('head(object, function)', function (t) {
+  request.defaults({
+    headers: { foo: 'bar' }
+  }).head({ uri: s.url + '/head' }, function (e, r, b) {
+    b = JSON.parse(r.headers['x-data'])
+    t.equal(b.method, 'HEAD')
+    t.equal(b.headers.foo, 'bar')
+    t.end()
+  })
+})
+
+tape('recursive defaults', function (t) {
+  t.plan(11)
+
+  var defaultsOne = request.defaults({ headers: { foo: 'bar1' } })
+  var defaultsTwo = defaultsOne.defaults({ headers: { baz: 'bar2' } })
+  var defaultsThree = defaultsTwo.defaults({}, function (options, callback) {
+    options.headers = {
+      foo: 'bar3'
+    }
+    defaultsTwo(options, callback)
+  })
+
+  defaultsOne(s.url + '/', {json: true}, function (e, r, b) {
+    t.equal(b.method, 'GET')
+    t.equal(b.headers.foo, 'bar1')
+  })
+
+  defaultsTwo(s.url + '/', {json: true}, function (e, r, b) {
+    t.equal(b.method, 'GET')
+    t.equal(b.headers.foo, 'bar1')
+    t.equal(b.headers.baz, 'bar2')
+  })
+
+  // requester function on recursive defaults
+  defaultsThree(s.url + '/', {json: true}, function (e, r, b) {
+    t.equal(b.method, 'GET')
+    t.equal(b.headers.foo, 'bar3')
+    t.equal(b.headers.baz, 'bar2')
+  })
+
+  defaultsTwo.get(s.url + '/', {json: true}, function (e, r, b) {
+    t.equal(b.method, 'GET')
+    t.equal(b.headers.foo, 'bar1')
+    t.equal(b.headers.baz, 'bar2')
+  })
+})
+
+tape('recursive defaults requester', function (t) {
+  t.plan(5)
+
+  var defaultsOne = request.defaults({}, function (options, callback) {
+    var headers = options.headers || {}
+    headers.foo = 'bar1'
+    options.headers = headers
+
+    request(options, callback)
+  })
+
+  var defaultsTwo = defaultsOne.defaults({}, function (options, callback) {
+    var headers = options.headers || {}
+    headers.baz = 'bar2'
+    options.headers = headers
+
+    defaultsOne(options, callback)
+  })
+
+  defaultsOne.get(s.url + '/', {json: true}, function (e, r, b) {
+    t.equal(b.method, 'GET')
+    t.equal(b.headers.foo, 'bar1')
+  })
+
+  defaultsTwo.get(s.url + '/', {json: true}, function (e, r, b) {
+    t.equal(b.method, 'GET')
+    t.equal(b.headers.foo, 'bar1')
+    t.equal(b.headers.baz, 'bar2')
+  })
+})
+
+tape('test custom request handler function', function (t) {
+  t.plan(3)
+
+  var requestWithCustomHandler = request.defaults({
+    headers: { foo: 'bar' },
+    body: 'TESTING!'
+  }, function (uri, options, callback) {
+    var params = request.initParams(uri, options, callback)
+    params.headers.x = 'y'
+    return request(params.uri, params, params.callback)
+  })
+
+  t.throws(function () {
+    requestWithCustomHandler.head(s.url + '/', function (e, r, b) {
+      throw new Error('We should never get here')
+    })
+  }, /HTTP HEAD requests MUST NOT include a request body/)
+
+  requestWithCustomHandler.get(s.url + '/', function (e, r, b) {
+    b = JSON.parse(b)
+    t.equal(b.headers.foo, 'bar')
+    t.equal(b.headers.x, 'y')
+  })
+})
+
+tape('test custom request handler function without options', function (t) {
+  t.plan(2)
+
+  var customHandlerWithoutOptions = request.defaults(function (uri, options, callback) {
+    var params = request.initParams(uri, options, callback)
+    var headers = params.headers || {}
+    headers.x = 'y'
+    headers.foo = 'bar'
+    params.headers = headers
+    return request(params.uri, params, params.callback)
+  })
+
+  customHandlerWithoutOptions.get(s.url + '/', function (e, r, b) {
+    b = JSON.parse(b)
+    t.equal(b.headers.foo, 'bar')
+    t.equal(b.headers.x, 'y')
+  })
+})
+
+tape('test only setting undefined properties', function (t) {
+  request.defaults({
+    method: 'post',
+    json: true,
+    headers: { 'x-foo': 'bar' }
+  })({
+    uri: s.url + '/set-undefined',
+    json: {foo: 'bar'},
+    headers: {'x-foo': 'baz'}
+  }, function (e, r, b) {
+    t.equal(b.method, 'POST')
+    t.equal(b.headers['content-type'], 'application/json')
+    t.equal(b.headers['x-foo'], 'baz')
+    t.deepEqual(b.data, { foo: 'bar' })
+    t.end()
+  })
+})
+
+tape('test only function', function (t) {
+  var post = request.post
+  t.doesNotThrow(function () {
+    post(s.url + '/', function (e, r, b) {
+      t.equal(r.statusCode, 200)
+      t.end()
+    })
+  })
+})
+
+tape('invoke defaults', function (t) {
+  var d = request.defaults({
+    uri: s.url + '/',
+    headers: { foo: 'bar' }
+  })
+  d({json: true}, function (e, r, b) {
+    t.equal(b.method, 'GET')
+    t.equal(b.headers.foo, 'bar')
+    t.end()
+  })
+})
+
+tape('invoke convenience method from defaults', function (t) {
+  var d = request.defaults({
+    uri: s.url + '/',
+    headers: { foo: 'bar' }
+  })
+  d.get({json: true}, function (e, r, b) {
+    t.equal(b.method, 'GET')
+    t.equal(b.headers.foo, 'bar')
+    t.end()
+  })
+})
+
+tape('defaults without options', function (t) {
+  var d = request.defaults()
+  d.get(s.url + '/', {json: true}, function (e, r, b) {
+    t.equal(r.statusCode, 200)
+    t.end()
+  })
+})
+
+tape('cleanup', function (t) {
+  s.close(function () {
+    t.end()
+  })
+})

package/tests/test-digest-auth.js

@@ -0,0 +1,232 @@
+'use strict'
+
+var http = require('http')
+var request = require('../index')
+var tape = require('tape')
+var crypto = require('crypto')
+
+function makeHeader () {
+  return [].join.call(arguments, ', ')
+}
+
+function makeHeaderRegex () {
+  return new RegExp('^' + makeHeader.apply(null, arguments) + '$')
+}
+
+function md5 (str) {
+  return crypto.createHash('md5').update(str).digest('hex')
+}
+
+var digestServer = http.createServer(function (req, res) {
+  var ok,
+    testHeader
+
+  if (req.url === '/test/') {
+    if (req.headers.authorization) {
+      testHeader = makeHeaderRegex(
+        'Digest username="test"',
+        'realm="Private"',
+        'nonce="WpcHS2/TBAA=dffcc0dbd5f96d49a5477166649b7c0ae3866a93"',
+        'uri="/test/"',
+        'qop=auth',
+        'response="[a-f0-9]{32}"',
+        'nc=00000001',
+        'cnonce="[a-f0-9]{32}"',
+        'algorithm=MD5',
+        'opaque="5ccc069c403ebaf9f0171e9517f40e41"'
+      )
+      if (testHeader.test(req.headers.authorization)) {
+        ok = true
+      } else {
+        // Bad auth header, don't send back WWW-Authenticate header
+        ok = false
+      }
+    } else {
+      // No auth header, send back WWW-Authenticate header
+      ok = false
+      res.setHeader('www-authenticate', makeHeader(
+        'Digest realm="Private"',
+        'nonce="WpcHS2/TBAA=dffcc0dbd5f96d49a5477166649b7c0ae3866a93"',
+        'algorithm=MD5',
+        'qop="auth"',
+        'opaque="5ccc069c403ebaf9f0171e9517f40e41"'
+      ))
+    }
+  } else if (req.url === '/test/md5-sess') { // RFC 2716 MD5-sess w/ qop=auth
+    var user = 'test'
+    var realm = 'Private'
+    var pass = 'testing'
+    var nonce = 'WpcHS2/TBAA=dffcc0dbd5f96d49a5477166649b7c0ae3866a93'
+    var nonceCount = '00000001'
+    var qop = 'auth'
+    var algorithm = 'MD5-sess'
+    if (req.headers.authorization) {
+      // HA1=MD5(MD5(username:realm:password):nonce:cnonce)
+      // HA2=MD5(method:digestURI)
+      // response=MD5(HA1:nonce:nonceCount:clientNonce:qop:HA2)
+
+      var cnonce = /cnonce="(.*)"/.exec(req.headers.authorization)[1]
+      var ha1 = md5(md5(user + ':' + realm + ':' + pass) + ':' + nonce + ':' + cnonce)
+      var ha2 = md5('GET:/test/md5-sess')
+      var response = md5(ha1 + ':' + nonce + ':' + nonceCount + ':' + cnonce + ':' + qop + ':' + ha2)
+
+      testHeader = makeHeaderRegex(
+        'Digest username="' + user + '"',
+        'realm="' + realm + '"',
+        'nonce="' + nonce + '"',
+        'uri="/test/md5-sess"',
+        'qop=' + qop,
+        'response="' + response + '"',
+        'nc=' + nonceCount,
+        'cnonce="' + cnonce + '"',
+        'algorithm=' + algorithm
+      )
+
+      ok = testHeader.test(req.headers.authorization)
+    } else {
+      // No auth header, send back WWW-Authenticate header
+      ok = false
+      res.setHeader('www-authenticate', makeHeader(
+        'Digest realm="' + realm + '"',
+        'nonce="' + nonce + '"',
+        'algorithm=' + algorithm,
+        'qop="' + qop + '"'
+      ))
+    }
+  } else if (req.url === '/dir/index.html') {
+    // RFC2069-compatible mode
+    // check: http://www.rfc-editor.org/errata_search.php?rfc=2069
+    if (req.headers.authorization) {
+      testHeader = makeHeaderRegex(
+        'Digest username="Mufasa"',
+        'realm="testrealm@host.com"',
+        'nonce="dcd98b7102dd2f0e8b11d0f600bfb0c093"',
+        'uri="/dir/index.html"',
+        'response="[a-f0-9]{32}"',
+        'opaque="5ccc069c403ebaf9f0171e9517f40e41"'
+      )
+      if (testHeader.test(req.headers.authorization)) {
+        ok = true
+      } else {
+        // Bad auth header, don't send back WWW-Authenticate header
+        ok = false
+      }
+    } else {
+      // No auth header, send back WWW-Authenticate header
+      ok = false
+      res.setHeader('www-authenticate', makeHeader(
+        'Digest realm="testrealm@host.com"',
+        'nonce="dcd98b7102dd2f0e8b11d0f600bfb0c093"',
+        'opaque="5ccc069c403ebaf9f0171e9517f40e41"'
+      ))
+    }
+  }
+
+  if (ok) {
+    res.end('ok')
+  } else {
+    res.statusCode = 401
+    res.end('401')
+  }
+})
+
+tape('setup', function (t) {
+  digestServer.listen(0, function () {
+    digestServer.url = 'http://localhost:' + this.address().port
+    t.end()
+  })
+})
+
+tape('with sendImmediately = false', function (t) {
+  var numRedirects = 0
+
+  request({
+    method: 'GET',
+    uri: digestServer.url + '/test/',
+    auth: {
+      user: 'test',
+      pass: 'testing',
+      sendImmediately: false
+    }
+  }, function (error, response, body) {
+    t.equal(error, null)
+    t.equal(response.statusCode, 200)
+    t.equal(numRedirects, 1)
+    t.end()
+  }).on('redirect', function () {
+    t.equal(this.response.statusCode, 401)
+    numRedirects++
+  })
+})
+
+tape('with MD5-sess algorithm', function (t) {
+  var numRedirects = 0
+
+  request({
+    method: 'GET',
+    uri: digestServer.url + '/test/md5-sess',
+    auth: {
+      user: 'test',
+      pass: 'testing',
+      sendImmediately: false
+    }
+  }, function (error, response, body) {
+    t.equal(error, null)
+    t.equal(response.statusCode, 200)
+    t.equal(numRedirects, 1)
+    t.end()
+  }).on('redirect', function () {
+    t.equal(this.response.statusCode, 401)
+    numRedirects++
+  })
+})
+
+tape('without sendImmediately = false', function (t) {
+  var numRedirects = 0
+
+  // If we don't set sendImmediately = false, request will send basic auth
+  request({
+    method: 'GET',
+    uri: digestServer.url + '/test/',
+    auth: {
+      user: 'test',
+      pass: 'testing'
+    }
+  }, function (error, response, body) {
+    t.equal(error, null)
+    t.equal(response.statusCode, 401)
+    t.equal(numRedirects, 0)
+    t.end()
+  }).on('redirect', function () {
+    t.equal(this.response.statusCode, 401)
+    numRedirects++
+  })
+})
+
+tape('with different credentials', function (t) {
+  var numRedirects = 0
+
+  request({
+    method: 'GET',
+    uri: digestServer.url + '/dir/index.html',
+    auth: {
+      user: 'Mufasa',
+      pass: 'CircleOfLife',
+      sendImmediately: false
+    }
+  }, function (error, response, body) {
+    t.equal(error, null)
+    t.equal(response.statusCode, 200)
+    t.equal(numRedirects, 1)
+    t.end()
+  }).on('redirect', function () {
+    t.equal(this.response.statusCode, 401)
+    numRedirects++
+  })
+})
+
+tape('cleanup', function (t) {
+  digestServer.close(function () {
+    t.end()
+  })
+})

package/tests/test-emptyBody.js

@@ -0,0 +1,56 @@
+'use strict'
+
+var request = require('../index')
+var http = require('http')
+var tape = require('tape')
+
+var s = http.createServer(function (req, resp) {
+  resp.statusCode = 200
+  resp.end('')
+})
+
+tape('setup', function (t) {
+  s.listen(0, function () {
+    s.url = 'http://localhost:' + this.address().port
+    t.end()
+  })
+})
+
+tape('empty body with encoding', function (t) {
+  request(s.url, function (err, res, body) {
+    t.equal(err, null)
+    t.equal(res.statusCode, 200)
+    t.equal(body, '')
+    t.end()
+  })
+})
+
+tape('empty body without encoding', function (t) {
+  request({
+    url: s.url,
+    encoding: null
+  }, function (err, res, body) {
+    t.equal(err, null)
+    t.equal(res.statusCode, 200)
+    t.same(body, Buffer.alloc(0))
+    t.end()
+  })
+})
+
+tape('empty JSON body', function (t) {
+  request({
+    url: s.url,
+    json: {}
+  }, function (err, res, body) {
+    t.equal(err, null)
+    t.equal(res.statusCode, 200)
+    t.equal(body, undefined)
+    t.end()
+  })
+})
+
+tape('cleanup', function (t) {
+  s.close(function () {
+    t.end()
+  })
+})