@wiajs/request 3.0.0 → 3.0.1

package/tests/test-basic-auth.js

@@ -0,0 +1,221 @@
+'use strict'
+
+var assert = require('assert')
+var http = require('http')
+var request = require('../index')
+var tape = require('tape')
+
+var numBasicRequests = 0
+var basicServer
+
+tape('setup', function (t) {
+  basicServer = http.createServer(function (req, res) {
+    numBasicRequests++
+
+    var ok
+
+    if (req.headers.authorization) {
+      if (req.headers.authorization === 'Basic ' + Buffer.from('user:pass').toString('base64')) {
+        ok = true
+      } else if (req.headers.authorization === 'Basic ' + Buffer.from('user:').toString('base64')) {
+        ok = true
+      } else if (req.headers.authorization === 'Basic ' + Buffer.from(':pass').toString('base64')) {
+        ok = true
+      } else if (req.headers.authorization === 'Basic ' + Buffer.from('user:pâss').toString('base64')) {
+        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', 'Basic realm="Private"')
+    }
+
+    if (req.url === '/post/') {
+      var expectedContent = 'key=value'
+      req.on('data', function (data) {
+        assert.equal(data, expectedContent)
+      })
+      assert.equal(req.method, 'POST')
+      assert.equal(req.headers['content-length'], '' + expectedContent.length)
+      assert.equal(req.headers['content-type'], 'application/x-www-form-urlencoded')
+    }
+
+    if (ok) {
+      res.end('ok')
+    } else {
+      res.statusCode = 401
+      res.end('401')
+    }
+  }).listen(0, function () {
+    basicServer.port = this.address().port
+    basicServer.url = 'http://localhost:' + basicServer.port
+    t.end()
+  })
+})
+
+tape('sendImmediately - false', function (t) {
+  var r = request({
+    'method': 'GET',
+    'uri': basicServer.url + '/test/',
+    'auth': {
+      'user': 'user',
+      'pass': 'pass',
+      'sendImmediately': false
+    }
+  }, function (error, res, body) {
+    t.error(error)
+    t.equal(r._auth.user, 'user')
+    t.equal(res.statusCode, 200)
+    t.equal(numBasicRequests, 2)
+    t.end()
+  })
+})
+
+tape('sendImmediately - true', function (t) {
+  // If we don't set sendImmediately = false, request will send basic auth
+  var r = request({
+    'method': 'GET',
+    'uri': basicServer.url + '/test2/',
+    'auth': {
+      'user': 'user',
+      'pass': 'pass'
+    }
+  }, function (error, res, body) {
+    t.error(error)
+    t.equal(r._auth.user, 'user')
+    t.equal(res.statusCode, 200)
+    t.equal(numBasicRequests, 3)
+    t.end()
+  })
+})
+
+tape('credentials in url', function (t) {
+  var r = request({
+    'method': 'GET',
+    'uri': basicServer.url.replace(/:\/\//, '$&user:pass@') + '/test2/'
+  }, function (error, res, body) {
+    t.error(error)
+    t.equal(r._auth.user, 'user')
+    t.equal(res.statusCode, 200)
+    t.equal(numBasicRequests, 4)
+    t.end()
+  })
+})
+
+tape('POST request', function (t) {
+  var r = request({
+    'method': 'POST',
+    'form': { 'key': 'value' },
+    'uri': basicServer.url + '/post/',
+    'auth': {
+      'user': 'user',
+      'pass': 'pass',
+      'sendImmediately': false
+    }
+  }, function (error, res, body) {
+    t.error(error)
+    t.equal(r._auth.user, 'user')
+    t.equal(res.statusCode, 200)
+    t.equal(numBasicRequests, 6)
+    t.end()
+  })
+})
+
+tape('user - empty string', function (t) {
+  t.doesNotThrow(function () {
+    var r = request({
+      'method': 'GET',
+      'uri': basicServer.url + '/allow_empty_user/',
+      'auth': {
+        'user': '',
+        'pass': 'pass',
+        'sendImmediately': false
+      }
+    }, function (error, res, body) {
+      t.error(error)
+      t.equal(r._auth.user, '')
+      t.equal(res.statusCode, 200)
+      t.equal(numBasicRequests, 8)
+      t.end()
+    })
+  })
+})
+
+tape('pass - undefined', function (t) {
+  t.doesNotThrow(function () {
+    var r = request({
+      'method': 'GET',
+      'uri': basicServer.url + '/allow_undefined_password/',
+      'auth': {
+        'user': 'user',
+        'pass': undefined,
+        'sendImmediately': false
+      }
+    }, function (error, res, body) {
+      t.error(error)
+      t.equal(r._auth.user, 'user')
+      t.equal(res.statusCode, 200)
+      t.equal(numBasicRequests, 10)
+      t.end()
+    })
+  })
+})
+
+tape('pass - utf8', function (t) {
+  t.doesNotThrow(function () {
+    var r = request({
+      'method': 'GET',
+      'uri': basicServer.url + '/allow_undefined_password/',
+      'auth': {
+        'user': 'user',
+        'pass': 'pâss',
+        'sendImmediately': false
+      }
+    }, function (error, res, body) {
+      t.error(error)
+      t.equal(r._auth.user, 'user')
+      t.equal(r._auth.pass, 'pâss')
+      t.equal(res.statusCode, 200)
+      t.equal(numBasicRequests, 12)
+      t.end()
+    })
+  })
+})
+
+tape('auth method', function (t) {
+  var r = request
+    .get(basicServer.url + '/test/')
+    .auth('user', '', false)
+    .on('response', function (res) {
+      t.equal(r._auth.user, 'user')
+      t.equal(res.statusCode, 200)
+      t.equal(numBasicRequests, 14)
+      t.end()
+    })
+})
+
+tape('get method', function (t) {
+  var r = request.get(basicServer.url + '/test/',
+    {
+      auth: {
+        user: 'user',
+        pass: '',
+        sendImmediately: false
+      }
+    }, function (err, res) {
+      t.equal(r._auth.user, 'user')
+      t.equal(err, null)
+      t.equal(res.statusCode, 200)
+      t.equal(numBasicRequests, 16)
+      t.end()
+    })
+})
+
+tape('cleanup', function (t) {
+  basicServer.close(function () {
+    t.end()
+  })
+})

package/tests/test-bearer-auth.js

@@ -0,0 +1,187 @@
+'use strict'
+
+var assert = require('assert')
+var http = require('http')
+var request = require('../index')
+var tape = require('tape')
+
+var numBearerRequests = 0
+var bearerServer
+
+tape('setup', function (t) {
+  bearerServer = http.createServer(function (req, res) {
+    numBearerRequests++
+
+    var ok
+
+    if (req.headers.authorization) {
+      if (req.headers.authorization === 'Bearer theToken') {
+        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', 'Bearer realm="Private"')
+    }
+
+    if (req.url === '/post/') {
+      var expectedContent = 'data_key=data_value'
+      req.on('data', function (data) {
+        assert.equal(data, expectedContent)
+      })
+      assert.equal(req.method, 'POST')
+      assert.equal(req.headers['content-length'], '' + expectedContent.length)
+      assert.equal(req.headers['content-type'], 'application/x-www-form-urlencoded')
+    }
+
+    if (ok) {
+      res.end('ok')
+    } else {
+      res.statusCode = 401
+      res.end('401')
+    }
+  }).listen(0, function () {
+    bearerServer.url = 'http://localhost:' + this.address().port
+    t.end()
+  })
+})
+
+tape('bearer auth', function (t) {
+  request({
+    'method': 'GET',
+    'uri': bearerServer.url + '/test/',
+    'auth': {
+      'bearer': 'theToken',
+      'sendImmediately': false
+    }
+  }, function (error, res, body) {
+    t.error(error)
+    t.equal(res.statusCode, 200)
+    t.equal(numBearerRequests, 2)
+    t.end()
+  })
+})
+
+tape('bearer auth with default sendImmediately', function (t) {
+  // If we don't set sendImmediately = false, request will send bearer auth
+  request({
+    'method': 'GET',
+    'uri': bearerServer.url + '/test2/',
+    'auth': {
+      'bearer': 'theToken'
+    }
+  }, function (error, res, body) {
+    t.error(error)
+    t.equal(res.statusCode, 200)
+    t.equal(numBearerRequests, 3)
+    t.end()
+  })
+})
+
+tape('', function (t) {
+  request({
+    'method': 'POST',
+    'form': { 'data_key': 'data_value' },
+    'uri': bearerServer.url + '/post/',
+    'auth': {
+      'bearer': 'theToken',
+      'sendImmediately': false
+    }
+  }, function (error, res, body) {
+    t.error(error)
+    t.equal(res.statusCode, 200)
+    t.equal(numBearerRequests, 5)
+    t.end()
+  })
+})
+
+tape('using .auth, sendImmediately = false', function (t) {
+  request
+    .get(bearerServer.url + '/test/')
+    .auth(null, null, false, 'theToken')
+    .on('response', function (res) {
+      t.equal(res.statusCode, 200)
+      t.equal(numBearerRequests, 7)
+      t.end()
+    })
+})
+
+tape('using .auth, sendImmediately = true', function (t) {
+  request
+    .get(bearerServer.url + '/test/')
+    .auth(null, null, true, 'theToken')
+    .on('response', function (res) {
+      t.equal(res.statusCode, 200)
+      t.equal(numBearerRequests, 8)
+      t.end()
+    })
+})
+
+tape('bearer is a function', function (t) {
+  request({
+    'method': 'GET',
+    'uri': bearerServer.url + '/test/',
+    'auth': {
+      'bearer': function () { return 'theToken' },
+      'sendImmediately': false
+    }
+  }, function (error, res, body) {
+    t.error(error)
+    t.equal(res.statusCode, 200)
+    t.equal(numBearerRequests, 10)
+    t.end()
+  })
+})
+
+tape('bearer is a function, path = test2', function (t) {
+  // If we don't set sendImmediately = false, request will send bearer auth
+  request({
+    'method': 'GET',
+    'uri': bearerServer.url + '/test2/',
+    'auth': {
+      'bearer': function () { return 'theToken' }
+    }
+  }, function (error, res, body) {
+    t.error(error)
+    t.equal(res.statusCode, 200)
+    t.equal(numBearerRequests, 11)
+    t.end()
+  })
+})
+
+tape('no auth method', function (t) {
+  request({
+    'method': 'GET',
+    'uri': bearerServer.url + '/test2/',
+    'auth': {
+      'bearer': undefined
+    }
+  }, function (error, res, body) {
+    t.equal(error.message, 'no auth mechanism defined')
+    t.end()
+  })
+})
+
+tape('null bearer', function (t) {
+  request({
+    'method': 'GET',
+    'uri': bearerServer.url + '/test2/',
+    'auth': {
+      'bearer': null
+    }
+  }, function (error, res, body) {
+    t.error(error)
+    t.equal(res.statusCode, 401)
+    t.equal(numBearerRequests, 13)
+    t.end()
+  })
+})
+
+tape('cleanup', function (t) {
+  bearerServer.close(function () {
+    t.end()
+  })
+})

package/tests/test-body.js

@@ -0,0 +1,154 @@
+'use strict'
+
+var server = require('./server')
+var request = require('../index')
+var tape = require('tape')
+var http = require('http')
+
+var s = server.createServer()
+
+tape('setup', function (t) {
+  s.listen(0, function () {
+    t.end()
+  })
+})
+
+function addTest (name, data) {
+  tape('test ' + name, function (t) {
+    s.on('/' + name, data.resp)
+    data.uri = s.url + '/' + name
+    request(data, function (err, resp, body) {
+      t.equal(err, null)
+      if (data.expectBody && Buffer.isBuffer(data.expectBody)) {
+        t.deepEqual(data.expectBody.toString(), body.toString())
+      } else if (data.expectBody) {
+        t.deepEqual(data.expectBody, body)
+      }
+      t.end()
+    })
+  })
+}
+
+addTest('testGet', {
+  resp: server.createGetResponse('TESTING!'), expectBody: 'TESTING!'
+})
+
+addTest('testGetChunkBreak', {
+  resp: server.createChunkResponse(
+    [ Buffer.from([239]),
+      Buffer.from([163]),
+      Buffer.from([191]),
+      Buffer.from([206]),
+      Buffer.from([169]),
+      Buffer.from([226]),
+      Buffer.from([152]),
+      Buffer.from([131])
+    ]),
+  expectBody: '\uF8FF\u03A9\u2603'
+})
+
+addTest('testGetBuffer', {
+  resp: server.createGetResponse(Buffer.from('TESTING!')), encoding: null, expectBody: Buffer.from('TESTING!')
+})
+
+addTest('testGetEncoding', {
+  resp: server.createGetResponse(Buffer.from('efa3bfcea9e29883', 'hex')), encoding: 'hex', expectBody: 'efa3bfcea9e29883'
+})
+
+addTest('testGetUTF', {
+  resp: server.createGetResponse(Buffer.from([0xEF, 0xBB, 0xBF, 226, 152, 131])), encoding: 'utf8', expectBody: '\u2603'
+})
+
+addTest('testGetJSON', {
+  resp: server.createGetResponse('{"test":true}', 'application/json'), json: true, expectBody: {'test': true}
+})
+
+addTest('testPutString', {
+  resp: server.createPostValidator('PUTTINGDATA'), method: 'PUT', body: 'PUTTINGDATA'
+})
+
+addTest('testPutBuffer', {
+  resp: server.createPostValidator('PUTTINGDATA'), method: 'PUT', body: Buffer.from('PUTTINGDATA')
+})
+
+addTest('testPutJSON', {
+  resp: server.createPostValidator(JSON.stringify({foo: 'bar'})), method: 'PUT', json: {foo: 'bar'}
+})
+
+addTest('testPutMultipart', {
+  resp: server.createPostValidator(
+    '--__BOUNDARY__\r\n' +
+    'content-type: text/html\r\n' +
+    '\r\n' +
+    '<html><body>Oh hi.</body></html>' +
+    '\r\n--__BOUNDARY__\r\n\r\n' +
+    'Oh hi.' +
+    '\r\n--__BOUNDARY__--'
+  ),
+  method: 'PUT',
+  multipart: [ {'content-type': 'text/html', 'body': '<html><body>Oh hi.</body></html>'},
+    {'body': 'Oh hi.'}
+  ]
+})
+
+addTest('testPutMultipartPreambleCRLF', {
+  resp: server.createPostValidator(
+    '\r\n--__BOUNDARY__\r\n' +
+    'content-type: text/html\r\n' +
+    '\r\n' +
+    '<html><body>Oh hi.</body></html>' +
+    '\r\n--__BOUNDARY__\r\n\r\n' +
+    'Oh hi.' +
+    '\r\n--__BOUNDARY__--'
+  ),
+  method: 'PUT',
+  preambleCRLF: true,
+  multipart: [ {'content-type': 'text/html', 'body': '<html><body>Oh hi.</body></html>'},
+    {'body': 'Oh hi.'}
+  ]
+})
+
+addTest('testPutMultipartPostambleCRLF', {
+  resp: server.createPostValidator(
+    '\r\n--__BOUNDARY__\r\n' +
+    'content-type: text/html\r\n' +
+    '\r\n' +
+    '<html><body>Oh hi.</body></html>' +
+    '\r\n--__BOUNDARY__\r\n\r\n' +
+    'Oh hi.' +
+    '\r\n--__BOUNDARY__--' +
+    '\r\n'
+  ),
+  method: 'PUT',
+  preambleCRLF: true,
+  postambleCRLF: true,
+  multipart: [ {'content-type': 'text/html', 'body': '<html><body>Oh hi.</body></html>'},
+    {'body': 'Oh hi.'}
+  ]
+})
+
+tape('typed array', function (t) {
+  var server = http.createServer()
+  server.on('request', function (req, res) {
+    req.pipe(res)
+  })
+  server.listen(0, function () {
+    var data = new Uint8Array([1, 2, 3])
+    request({
+      uri: 'http://localhost:' + this.address().port,
+      method: 'POST',
+      body: data,
+      encoding: null
+    }, function (err, res, body) {
+      t.error(err)
+      t.deepEqual(Buffer.from(data), body)
+      server.close(t.end)
+    })
+  })
+})
+
+tape('cleanup', function (t) {
+  s.close(function () {
+    t.end()
+  })
+})

package/tests/test-cookies.js

@@ -0,0 +1,130 @@
+'use strict'
+
+var http = require('http')
+var request = require('../index')
+var tape = require('tape')
+
+var validUrl
+var malformedUrl
+var invalidUrl
+
+var server = http.createServer(function (req, res) {
+  if (req.url === '/valid') {
+    res.setHeader('set-cookie', 'foo=bar')
+  } else if (req.url === '/malformed') {
+    res.setHeader('set-cookie', 'foo')
+  } else if (req.url === '/invalid') {
+    res.setHeader('set-cookie', 'foo=bar; Domain=foo.com')
+  }
+  res.end('okay')
+})
+
+tape('setup', function (t) {
+  server.listen(0, function () {
+    server.url = 'http://localhost:' + this.address().port
+    validUrl = server.url + '/valid'
+    malformedUrl = server.url + '/malformed'
+    invalidUrl = server.url + '/invalid'
+    t.end()
+  })
+})
+
+tape('simple cookie creation', function (t) {
+  var cookie = request.cookie('foo=bar')
+  t.equals(cookie.key, 'foo')
+  t.equals(cookie.value, 'bar')
+  t.end()
+})
+
+tape('simple malformed cookie creation', function (t) {
+  var cookie = request.cookie('foo')
+  t.equals(cookie.key, '')
+  t.equals(cookie.value, 'foo')
+  t.end()
+})
+
+tape('after server sends a cookie', function (t) {
+  var jar1 = request.jar()
+  request({
+    method: 'GET',
+    url: validUrl,
+    jar: jar1
+  },
+    function (error, response, body) {
+      t.equal(error, null)
+      t.equal(jar1.getCookieString(validUrl), 'foo=bar')
+      t.equal(body, 'okay')
+
+      var cookies = jar1.getCookies(validUrl)
+      t.equal(cookies.length, 1)
+      t.equal(cookies[0].key, 'foo')
+      t.equal(cookies[0].value, 'bar')
+      t.end()
+    })
+})
+
+tape('after server sends a malformed cookie', function (t) {
+  var jar = request.jar()
+  request({
+    method: 'GET',
+    url: malformedUrl,
+    jar: jar
+  },
+    function (error, response, body) {
+      t.equal(error, null)
+      t.equal(jar.getCookieString(malformedUrl), 'foo')
+      t.equal(body, 'okay')
+
+      var cookies = jar.getCookies(malformedUrl)
+      t.equal(cookies.length, 1)
+      t.equal(cookies[0].key, '')
+      t.equal(cookies[0].value, 'foo')
+      t.end()
+    })
+})
+
+tape('after server sends a cookie for a different domain', function (t) {
+  var jar2 = request.jar()
+  request({
+    method: 'GET',
+    url: invalidUrl,
+    jar: jar2
+  },
+    function (error, response, body) {
+      t.equal(error, null)
+      t.equal(jar2.getCookieString(validUrl), '')
+      t.deepEqual(jar2.getCookies(validUrl), [])
+      t.equal(body, 'okay')
+      t.end()
+    })
+})
+
+tape('make sure setCookie works', function (t) {
+  var jar3 = request.jar()
+  var err = null
+  try {
+    jar3.setCookie(request.cookie('foo=bar'), validUrl)
+  } catch (e) {
+    err = e
+  }
+  t.equal(err, null)
+  var cookies = jar3.getCookies(validUrl)
+  t.equal(cookies.length, 1)
+  t.equal(cookies[0].key, 'foo')
+  t.equal(cookies[0].value, 'bar')
+  t.end()
+})
+
+tape('custom store', function (t) {
+  var Store = function () {}
+  var store = new Store()
+  var jar = request.jar(store)
+  t.equals(store, jar._jar.store)
+  t.end()
+})
+
+tape('cleanup', function (t) {
+  server.close(function () {
+    t.end()
+  })
+})