@wiajs/request 3.0.0 → 3.0.1

package/tests/test-isUrl.js

@@ -0,0 +1,120 @@
+'use strict'
+
+var http = require('http')
+var request = require('../index')
+var tape = require('tape')
+
+var s = http.createServer(function (req, res) {
+  res.statusCode = 200
+  res.end('ok')
+})
+
+tape('setup', function (t) {
+  s.listen(0, function () {
+    s.port = this.address().port
+    s.url = 'http://localhost:' + s.port
+    t.end()
+  })
+})
+
+tape('lowercase', function (t) {
+  request(s.url, function (err, resp, body) {
+    t.equal(err, null)
+    t.equal(body, 'ok')
+    t.end()
+  })
+})
+
+tape('uppercase', function (t) {
+  request(s.url.replace('http', 'HTTP'), function (err, resp, body) {
+    t.equal(err, null)
+    t.equal(body, 'ok')
+    t.end()
+  })
+})
+
+tape('mixedcase', function (t) {
+  request(s.url.replace('http', 'HtTp'), function (err, resp, body) {
+    t.equal(err, null)
+    t.equal(body, 'ok')
+    t.end()
+  })
+})
+
+tape('hostname and port', function (t) {
+  request({
+    uri: {
+      protocol: 'http:',
+      hostname: 'localhost',
+      port: s.port
+    }
+  }, function (err, res, body) {
+    t.equal(err, null)
+    t.equal(body, 'ok')
+    t.end()
+  })
+})
+
+tape('hostname and port 1', function (t) {
+  request({
+    uri: {
+      protocol: 'http:',
+      hostname: 'localhost',
+      port: s.port
+    }
+  }, function (err, res, body) {
+    t.equal(err, null)
+    t.equal(body, 'ok')
+    t.end()
+  })
+})
+
+tape('hostname and port 2', function (t) {
+  request({
+    protocol: 'http:',
+    hostname: 'localhost',
+    port: s.port
+  }, {
+    // need this empty options object, otherwise request thinks no uri was set
+  }, function (err, res, body) {
+    t.equal(err, null)
+    t.equal(body, 'ok')
+    t.end()
+  })
+})
+
+tape('hostname and port 3', function (t) {
+  request({
+    protocol: 'http:',
+    hostname: 'localhost',
+    port: s.port
+  }, function (err, res, body) {
+    t.notEqual(err, null)
+    t.equal(err.message, 'options.uri is a required argument')
+    t.equal(body, undefined)
+    t.end()
+  })
+})
+
+tape('hostname and query string', function (t) {
+  request({
+    uri: {
+      protocol: 'http:',
+      hostname: 'localhost',
+      port: s.port
+    },
+    qs: {
+      test: 'test'
+    }
+  }, function (err, res, body) {
+    t.equal(err, null)
+    t.equal(body, 'ok')
+    t.end()
+  })
+})
+
+tape('cleanup', function (t) {
+  s.close(function () {
+    t.end()
+  })
+})

package/tests/test-json-request.js

@@ -0,0 +1,117 @@
+'use strict'
+
+var server = require('./server')
+var request = require('../index')
+var tape = require('tape')
+
+var s = server.createServer()
+
+tape('setup', function (t) {
+  s.listen(0, function () {
+    t.end()
+  })
+})
+
+function testJSONValue (testId, value) {
+  tape('test ' + testId, function (t) {
+    var testUrl = '/' + testId
+    s.on(testUrl, server.createPostJSONValidator(value, 'application/json'))
+    var opts = {
+      method: 'PUT',
+      uri: s.url + testUrl,
+      json: true,
+      body: value
+    }
+    request(opts, function (err, resp, body) {
+      t.equal(err, null)
+      t.equal(resp.statusCode, 200)
+      t.deepEqual(body, value)
+      t.end()
+    })
+  })
+}
+
+function testJSONValueReviver (testId, value, reviver, revivedValue) {
+  tape('test ' + testId, function (t) {
+    var testUrl = '/' + testId
+    s.on(testUrl, server.createPostJSONValidator(value, 'application/json'))
+    var opts = {
+      method: 'PUT',
+      uri: s.url + testUrl,
+      json: true,
+      jsonReviver: reviver,
+      body: value
+    }
+    request(opts, function (err, resp, body) {
+      t.equal(err, null)
+      t.equal(resp.statusCode, 200)
+      t.deepEqual(body, revivedValue)
+      t.end()
+    })
+  })
+}
+
+function testJSONValueReplacer (testId, value, replacer, replacedValue) {
+  tape('test ' + testId, function (t) {
+    var testUrl = '/' + testId
+    s.on(testUrl, server.createPostJSONValidator(replacedValue, 'application/json'))
+    var opts = {
+      method: 'PUT',
+      uri: s.url + testUrl,
+      json: true,
+      jsonReplacer: replacer,
+      body: value
+    }
+    request(opts, function (err, resp, body) {
+      t.equal(err, null)
+      t.equal(resp.statusCode, 200)
+      t.deepEqual(body, replacedValue)
+      t.end()
+    })
+  })
+}
+
+testJSONValue('jsonNull', null)
+testJSONValue('jsonTrue', true)
+testJSONValue('jsonFalse', false)
+testJSONValue('jsonNumber', -289365.2938)
+testJSONValue('jsonString', 'some string')
+testJSONValue('jsonArray', ['value1', 2, null, 8925.53289, true, false, ['array'], { object: 'property' }])
+testJSONValue('jsonObject', {
+  trueProperty: true,
+  falseProperty: false,
+  numberProperty: -98346.34698,
+  stringProperty: 'string',
+  nullProperty: null,
+  arrayProperty: ['array'],
+  objectProperty: { object: 'property' }
+})
+
+testJSONValueReviver('jsonReviver', -48269.592, function (k, v) {
+  return v * -1
+}, 48269.592)
+testJSONValueReviver('jsonReviverInvalid', -48269.592, 'invalid reviver', -48269.592)
+
+testJSONValueReplacer('jsonReplacer', -48269.592, function (k, v) {
+  return v * -1
+}, 48269.592)
+testJSONValueReplacer('jsonReplacerInvalid', -48269.592, 'invalid replacer', -48269.592)
+testJSONValueReplacer('jsonReplacerObject', {foo: 'bar'}, function (k, v) {
+  return v.toUpperCase ? v.toUpperCase() : v
+}, {foo: 'BAR'})
+
+tape('missing body', function (t) {
+  s.on('/missing-body', function (req, res) {
+    t.equal(req.headers['content-type'], undefined)
+    res.end()
+  })
+  request({url: s.url + '/missing-body', json: true}, function () {
+    t.end()
+  })
+})
+
+tape('cleanup', function (t) {
+  s.close(function () {
+    t.end()
+  })
+})

package/tests/test-localAddress.js

@@ -0,0 +1,49 @@
+'use strict'
+var request = require('../index')
+var tape = require('tape')
+
+tape('bind to invalid address', function (t) {
+  request.get({
+    uri: 'http://www.google.com',
+    localAddress: '1.2.3.4'
+  }, function (err, res) {
+    t.notEqual(err, null)
+    t.equal(true, /bind EADDRNOTAVAIL/.test(err.message))
+    t.equal(res, undefined)
+    t.end()
+  })
+})
+
+tape('bind to local address', function (t) {
+  request.get({
+    uri: 'http://www.google.com',
+    localAddress: '127.0.0.1'
+  }, function (err, res) {
+    t.notEqual(err, null)
+    t.equal(res, undefined)
+    t.end()
+  })
+})
+
+tape('bind to local address on redirect', function (t) {
+  var os = require('os')
+  var localInterfaces = os.networkInterfaces()
+  var localIPS = []
+  Object.keys(localInterfaces).forEach(function (ifname) {
+    localInterfaces[ifname].forEach(function (iface) {
+      if (iface.family !== 'IPv4' || iface.internal !== false) {
+        // skip over internal (i.e. 127.0.0.1) and non-ipv4 addresses
+        return
+      }
+      localIPS.push(iface.address)
+    })
+  })
+  request.get({
+    uri: 'http://google.com', // redirects to 'http://google.com'
+    localAddress: localIPS[0]
+  }, function (err, res) {
+    t.equal(err, null)
+    t.equal(res.request.localAddress, localIPS[0])
+    t.end()
+  })
+})

package/tests/test-multipart-encoding.js

@@ -0,0 +1,147 @@
+'use strict'
+
+var http = require('http')
+var path = require('path')
+var request = require('../index')
+var fs = require('fs')
+var tape = require('tape')
+
+var localFile = path.join(__dirname, 'unicycle.jpg')
+var cases = {
+  // based on body type
+  '+array -stream': {
+    options: {
+      multipart: [{name: 'field', body: 'value'}]
+    },
+    expected: {chunked: false}
+  },
+  '+array +stream': {
+    options: {
+      multipart: [{name: 'file', body: null}]
+    },
+    expected: {chunked: true}
+  },
+  // encoding overrides body value
+  '+array +encoding': {
+    options: {
+      headers: {'transfer-encoding': 'chunked'},
+      multipart: [{name: 'field', body: 'value'}]
+    },
+    expected: {chunked: true}
+  },
+
+  // based on body type
+  '+object -stream': {
+    options: {
+      multipart: {data: [{name: 'field', body: 'value'}]}
+    },
+    expected: {chunked: false}
+  },
+  '+object +stream': {
+    options: {
+      multipart: {data: [{name: 'file', body: null}]}
+    },
+    expected: {chunked: true}
+  },
+  // encoding overrides body value
+  '+object +encoding': {
+    options: {
+      headers: {'transfer-encoding': 'chunked'},
+      multipart: {data: [{name: 'field', body: 'value'}]}
+    },
+    expected: {chunked: true}
+  },
+
+  // based on body type
+  '+object -chunked -stream': {
+    options: {
+      multipart: {chunked: false, data: [{name: 'field', body: 'value'}]}
+    },
+    expected: {chunked: false}
+  },
+  '+object -chunked +stream': {
+    options: {
+      multipart: {chunked: false, data: [{name: 'file', body: null}]}
+    },
+    expected: {chunked: true}
+  },
+  // chunked overrides body value
+  '+object +chunked -stream': {
+    options: {
+      multipart: {chunked: true, data: [{name: 'field', body: 'value'}]}
+    },
+    expected: {chunked: true}
+  },
+  // encoding overrides chunked
+  '+object +encoding -chunked': {
+    options: {
+      headers: {'transfer-encoding': 'chunked'},
+      multipart: {chunked: false, data: [{name: 'field', body: 'value'}]}
+    },
+    expected: {chunked: true}
+  }
+}
+
+function runTest (t, test) {
+  var server = http.createServer(function (req, res) {
+    t.ok(req.headers['content-type'].match(/^multipart\/related; boundary=[^\s;]+$/))
+
+    if (test.expected.chunked) {
+      t.ok(req.headers['transfer-encoding'] === 'chunked')
+      t.notOk(req.headers['content-length'])
+    } else {
+      t.ok(req.headers['content-length'])
+      t.notOk(req.headers['transfer-encoding'])
+    }
+
+    // temp workaround
+    var data = ''
+    req.setEncoding('utf8')
+
+    req.on('data', function (d) {
+      data += d
+    })
+
+    req.on('end', function () {
+      // check for the fields traces
+      if (test.expected.chunked && data.indexOf('name: file') !== -1) {
+        // file
+        t.ok(data.indexOf('name: file') !== -1)
+        // check for unicycle.jpg traces
+        t.ok(data.indexOf('2005:06:21 01:44:12') !== -1)
+      } else {
+        // field
+        t.ok(data.indexOf('name: field') !== -1)
+        var parts = test.options.multipart.data || test.options.multipart
+        t.ok(data.indexOf(parts[0].body) !== -1)
+      }
+
+      res.writeHead(200)
+      res.end()
+    })
+  })
+
+  server.listen(0, function () {
+    var url = 'http://localhost:' + this.address().port
+    // @NOTE: multipartData properties must be set here
+    // so that file read stream does not leak in node v0.8
+    var parts = test.options.multipart.data || test.options.multipart
+    if (parts[0].name === 'file') {
+      parts[0].body = fs.createReadStream(localFile)
+    }
+
+    request.post(url, test.options, function (err, res, body) {
+      t.equal(err, null)
+      t.equal(res.statusCode, 200)
+      server.close(function () {
+        t.end()
+      })
+    })
+  })
+}
+
+Object.keys(cases).forEach(function (name) {
+  tape('multipart-encoding ' + name, function (t) {
+    runTest(t, cases[name])
+  })
+})

package/tests/test-multipart.js

@@ -0,0 +1,129 @@
+'use strict'
+
+var http = require('http')
+var path = require('path')
+var request = require('../index')
+var fs = require('fs')
+var tape = require('tape')
+
+function runTest (t, a) {
+  var remoteFile = path.join(__dirname, 'googledoodle.jpg')
+  var localFile = path.join(__dirname, 'unicycle.jpg')
+  var multipartData = []
+
+  var server = http.createServer(function (req, res) {
+    if (req.url === '/file') {
+      res.writeHead(200, {'content-type': 'image/jpg'})
+      res.end(fs.readFileSync(remoteFile), 'binary')
+      return
+    }
+
+    if (a.header) {
+      if (a.header.indexOf('mixed') !== -1) {
+        t.ok(req.headers['content-type'].match(/^multipart\/mixed; boundary=[^\s;]+$/))
+      } else {
+        t.ok(req.headers['content-type']
+          .match(/^multipart\/related; boundary=XXX; type=text\/xml; start="<root>"$/))
+      }
+    } else {
+      t.ok(req.headers['content-type'].match(/^multipart\/related; boundary=[^\s;]+$/))
+    }
+
+    // temp workaround
+    var data = ''
+    req.setEncoding('utf8')
+
+    req.on('data', function (d) {
+      data += d
+    })
+
+    req.on('end', function () {
+      // check for the fields traces
+
+      // my_field
+      t.ok(data.indexOf('name: my_field') !== -1)
+      t.ok(data.indexOf(multipartData[0].body) !== -1)
+
+      // my_number
+      t.ok(data.indexOf('name: my_number') !== -1)
+      t.ok(data.indexOf(multipartData[1].body) !== -1)
+
+      // my_buffer
+      t.ok(data.indexOf('name: my_buffer') !== -1)
+      t.ok(data.indexOf(multipartData[2].body) !== -1)
+
+      // my_file
+      t.ok(data.indexOf('name: my_file') !== -1)
+      // check for unicycle.jpg traces
+      t.ok(data.indexOf('2005:06:21 01:44:12') !== -1)
+
+      // remote_file
+      t.ok(data.indexOf('name: remote_file') !== -1)
+      // check for http://localhost:nnnn/file traces
+      t.ok(data.indexOf('Photoshop ICC') !== -1)
+
+      if (a.header && a.header.indexOf('boundary=XXX') !== -1) {
+        t.ok(data.indexOf('--XXX') !== -1)
+      }
+
+      res.writeHead(200)
+      res.end(a.json ? JSON.stringify({status: 'done'}) : 'done')
+    })
+  })
+
+  server.listen(0, function () {
+    var url = 'http://localhost:' + this.address().port
+    // @NOTE: multipartData properties must be set here so that my_file read stream does not leak in node v0.8
+    multipartData = [
+      {name: 'my_field', body: 'my_value'},
+      {name: 'my_number', body: 1000},
+      {name: 'my_buffer', body: Buffer.from([1, 2, 3])},
+      {name: 'my_file', body: fs.createReadStream(localFile)},
+      {name: 'remote_file', body: request(url + '/file')}
+    ]
+
+    var reqOptions = {
+      url: url + '/upload',
+      multipart: multipartData
+    }
+    if (a.header) {
+      reqOptions.headers = {
+        'content-type': a.header
+      }
+    }
+    if (a.json) {
+      reqOptions.json = true
+    }
+    request[a.method](reqOptions, function (err, res, body) {
+      t.equal(err, null)
+      t.equal(res.statusCode, 200)
+      t.deepEqual(body, a.json ? {status: 'done'} : 'done')
+      server.close(function () {
+        t.end()
+      })
+    })
+  })
+}
+
+var testHeaders = [
+  null,
+  'multipart/mixed',
+  'multipart/related; boundary=XXX; type=text/xml; start="<root>"'
+]
+
+var methods = ['post', 'get']
+methods.forEach(function (method) {
+  testHeaders.forEach(function (header) {
+    [true, false].forEach(function (json) {
+      var name = [
+        'multipart-related', method.toUpperCase(),
+        (header || 'default'),
+        (json ? '+' : '-') + 'json'
+      ].join(' ')
+
+      tape(name, function (t) {
+        runTest(t, {method: method, header: header, json: json})
+      })
+    })
+  })
+})

package/tests/test-node-debug.js

@@ -0,0 +1,95 @@
+'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('')
+})
+
+var stderr = []
+var prevStderrLen = 0
+
+tape('setup', function (t) {
+  process.stderr._oldWrite = process.stderr.write
+  process.stderr.write = function (string, encoding, fd) {
+    stderr.push(string)
+  }
+
+  s.listen(0, function () {
+    s.url = 'http://localhost:' + this.address().port
+    t.end()
+  })
+})
+
+tape('a simple request should not fail with debugging enabled', function (t) {
+  request.debug = true
+  t.equal(request.Request.debug, true, 'request.debug sets request.Request.debug')
+  t.equal(request.debug, true, 'request.debug gets request.Request.debug')
+  stderr = []
+
+  request(s.url, function (err, res, body) {
+    t.ifError(err, 'the request did not fail')
+    t.ok(res, 'the request did not fail')
+
+    t.ok(stderr.length, 'stderr has some messages')
+    var url = s.url.replace(/\//g, '\\/')
+    var patterns = [
+      /^REQUEST { uri: /,
+      new RegExp('^REQUEST make request ' + url + '/\n$'),
+      /^REQUEST onRequestResponse /,
+      /^REQUEST finish init /,
+      /^REQUEST response end /,
+      /^REQUEST end event /,
+      /^REQUEST emitting complete /
+    ]
+    patterns.forEach(function (pattern) {
+      var found = false
+      stderr.forEach(function (msg) {
+        if (pattern.test(msg)) {
+          found = true
+        }
+      })
+      t.ok(found, 'a log message matches ' + pattern)
+    })
+    prevStderrLen = stderr.length
+    t.end()
+  })
+})
+
+tape('there should be no further lookups on process.env', function (t) {
+  process.env.NODE_DEBUG = ''
+  stderr = []
+
+  request(s.url, function (err, res, body) {
+    t.ifError(err, 'the request did not fail')
+    t.ok(res, 'the request did not fail')
+    t.equal(stderr.length, prevStderrLen, 'env.NODE_DEBUG is not retested')
+    t.end()
+  })
+})
+
+tape('it should be possible to disable debugging at runtime', function (t) {
+  request.debug = false
+  t.equal(request.Request.debug, false, 'request.debug sets request.Request.debug')
+  t.equal(request.debug, false, 'request.debug gets request.Request.debug')
+  stderr = []
+
+  request(s.url, function (err, res, body) {
+    t.ifError(err, 'the request did not fail')
+    t.ok(res, 'the request did not fail')
+    t.equal(stderr.length, 0, 'debugging can be disabled')
+    t.end()
+  })
+})
+
+tape('cleanup', function (t) {
+  process.stderr.write = process.stderr._oldWrite
+  delete process.stderr._oldWrite
+
+  s.close(function () {
+    t.end()
+  })
+})