@wiajs/request 3.0.0 → 3.0.1

package/tests/test-gzip.js

@@ -0,0 +1,296 @@
+'use strict'
+
+var request = require('../index')
+var http = require('http')
+var zlib = require('zlib')
+var assert = require('assert')
+var bufferEqual = require('buffer-equal')
+var tape = require('tape')
+
+var testContent = 'Compressible response content.\n'
+var testContentBig
+var testContentBigGzip
+var testContentGzip
+
+var server = http.createServer(function (req, res) {
+  res.statusCode = 200
+  res.setHeader('Content-Type', 'text/plain')
+
+  if (req.method === 'HEAD') {
+    res.setHeader('Content-Encoding', 'gzip')
+    res.end()
+    return
+  }
+  if (req.headers.code) {
+    res.writeHead(req.headers.code, {
+      'Content-Encoding': 'gzip',
+      code: req.headers.code
+    })
+    res.end()
+    return
+  }
+
+  if (/\bgzip\b/i.test(req.headers['accept-encoding'])) {
+    res.setHeader('Content-Encoding', 'gzip')
+    if (req.url === '/error') {
+      // send plaintext instead of gzip (should cause an error for the client)
+      res.end(testContent)
+    } else if (req.url === '/chunks') {
+      res.writeHead(200)
+      res.write(testContentBigGzip.slice(0, 4096))
+      setTimeout(function () { res.end(testContentBigGzip.slice(4096)) }, 10)
+    } else if (req.url === '/just-slightly-truncated') {
+      zlib.gzip(testContent, function (err, data) {
+        assert.equal(err, null)
+        // truncate the CRC checksum and size check at the end of the stream
+        res.end(data.slice(0, data.length - 8))
+      })
+    } else {
+      zlib.gzip(testContent, function (err, data) {
+        assert.equal(err, null)
+        res.end(data)
+      })
+    }
+  } else if (/\bdeflate\b/i.test(req.headers['accept-encoding'])) {
+    res.setHeader('Content-Encoding', 'deflate')
+    zlib.deflate(testContent, function (err, data) {
+      assert.equal(err, null)
+      res.end(data)
+    })
+  } else {
+    res.end(testContent)
+  }
+})
+
+tape('setup', function (t) {
+  // Need big compressed content to be large enough to chunk into gzip blocks.
+  // Want it to be deterministic to ensure test is reliable.
+  // Generate pseudo-random printable ASCII characters using MINSTD
+  var a = 48271
+  var m = 0x7FFFFFFF
+  var x = 1
+  testContentBig = Buffer.alloc(10240)
+  for (var i = 0; i < testContentBig.length; ++i) {
+    x = (a * x) & m
+    // Printable ASCII range from 32-126, inclusive
+    testContentBig[i] = (x % 95) + 32
+  }
+
+  zlib.gzip(testContent, function (err, data) {
+    t.equal(err, null)
+    testContentGzip = data
+
+    zlib.gzip(testContentBig, function (err, data2) {
+      t.equal(err, null)
+      testContentBigGzip = data2
+
+      server.listen(0, function () {
+        server.url = 'http://localhost:' + this.address().port
+        t.end()
+      })
+    })
+  })
+})
+
+tape('transparently supports gzip decoding to callbacks', function (t) {
+  var options = { url: server.url + '/foo', gzip: true }
+  request.get(options, function (err, res, body) {
+    t.equal(err, null)
+    t.equal(res.headers['content-encoding'], 'gzip')
+    t.equal(body, testContent)
+    t.end()
+  })
+})
+
+tape('supports slightly invalid gzip content', function (t) {
+  var options = { url: server.url + '/just-slightly-truncated', gzip: true }
+  request.get(options, function (err, res, body) {
+    t.equal(err, null)
+    t.equal(res.headers['content-encoding'], 'gzip')
+    t.equal(body, testContent)
+    t.end()
+  })
+})
+
+tape('transparently supports gzip decoding to pipes', function (t) {
+  var options = { url: server.url + '/foo', gzip: true }
+  var chunks = []
+  request.get(options)
+    .on('data', function (chunk) {
+      chunks.push(chunk)
+    })
+    .on('end', function () {
+      t.equal(Buffer.concat(chunks).toString(), testContent)
+      t.end()
+    })
+    .on('error', function (err) {
+      t.fail(err)
+    })
+})
+
+tape('does not request gzip if user specifies Accepted-Encodings', function (t) {
+  var headers = { 'Accept-Encoding': null }
+  var options = {
+    url: server.url + '/foo',
+    headers: headers,
+    gzip: true
+  }
+  request.get(options, function (err, res, body) {
+    t.equal(err, null)
+    t.equal(res.headers['content-encoding'], undefined)
+    t.equal(body, testContent)
+    t.end()
+  })
+})
+
+tape('does not decode user-requested encoding by default', function (t) {
+  var headers = { 'Accept-Encoding': 'gzip' }
+  var options = { url: server.url + '/foo', headers: headers }
+  request.get(options, function (err, res, body) {
+    t.equal(err, null)
+    t.equal(res.headers['content-encoding'], 'gzip')
+    t.equal(body, testContentGzip.toString())
+    t.end()
+  })
+})
+
+tape('supports character encoding with gzip encoding', function (t) {
+  var headers = { 'Accept-Encoding': 'gzip' }
+  var options = {
+    url: server.url + '/foo',
+    headers: headers,
+    gzip: true,
+    encoding: 'utf8'
+  }
+  var strings = []
+  request.get(options)
+    .on('data', function (string) {
+      t.equal(typeof string, 'string')
+      strings.push(string)
+    })
+    .on('end', function () {
+      t.equal(strings.join(''), testContent)
+      t.end()
+    })
+    .on('error', function (err) {
+      t.fail(err)
+    })
+})
+
+tape('transparently supports gzip error to callbacks', function (t) {
+  var options = { url: server.url + '/error', gzip: true }
+  request.get(options, function (err, res, body) {
+    t.equal(err.code, 'Z_DATA_ERROR')
+    t.equal(res, undefined)
+    t.equal(body, undefined)
+    t.end()
+  })
+})
+
+tape('transparently supports gzip error to pipes', function (t) {
+  var options = { url: server.url + '/error', gzip: true }
+  request.get(options)
+    .on('data', function (chunk) {
+      t.fail('Should not receive data event')
+    })
+    .on('end', function () {
+      t.fail('Should not receive end event')
+    })
+    .on('error', function (err) {
+      t.equal(err.code, 'Z_DATA_ERROR')
+      t.end()
+    })
+})
+
+tape('pause when streaming from a gzip request object', function (t) {
+  var chunks = []
+  var paused = false
+  var options = { url: server.url + '/chunks', gzip: true }
+  request.get(options)
+    .on('data', function (chunk) {
+      var self = this
+
+      t.notOk(paused, 'Only receive data when not paused')
+
+      chunks.push(chunk)
+      if (chunks.length === 1) {
+        self.pause()
+        paused = true
+        setTimeout(function () {
+          paused = false
+          self.resume()
+        }, 100)
+      }
+    })
+    .on('end', function () {
+      t.ok(chunks.length > 1, 'Received multiple chunks')
+      t.ok(bufferEqual(Buffer.concat(chunks), testContentBig), 'Expected content')
+      t.end()
+    })
+})
+
+tape('pause before streaming from a gzip request object', function (t) {
+  var paused = true
+  var options = { url: server.url + '/foo', gzip: true }
+  var r = request.get(options)
+  r.pause()
+  r.on('data', function (data) {
+    t.notOk(paused, 'Only receive data when not paused')
+    t.equal(data.toString(), testContent)
+  })
+  r.on('end', t.end.bind(t))
+
+  setTimeout(function () {
+    paused = false
+    r.resume()
+  }, 100)
+})
+
+tape('transparently supports deflate decoding to callbacks', function (t) {
+  var options = { url: server.url + '/foo', gzip: true, headers: { 'Accept-Encoding': 'deflate' } }
+
+  request.get(options, function (err, res, body) {
+    t.equal(err, null)
+    t.equal(res.headers['content-encoding'], 'deflate')
+    t.equal(body, testContent)
+    t.end()
+  })
+})
+
+tape('do not try to pipe HEAD request responses', function (t) {
+  var options = { method: 'HEAD', url: server.url + '/foo', gzip: true }
+
+  request(options, function (err, res, body) {
+    t.equal(err, null)
+    t.equal(body, '')
+    t.end()
+  })
+})
+
+tape('do not try to pipe responses with no body', function (t) {
+  var options = { url: server.url + '/foo', gzip: true }
+
+  // skip 105 on Node >= v10
+  var statusCodes = process.version.split('.')[0].slice(1) >= 10
+    ? [204, 304] : [105, 204, 304]
+
+  ;(function next (index) {
+    if (index === statusCodes.length) {
+      t.end()
+      return
+    }
+    options.headers = {code: statusCodes[index]}
+    request.post(options, function (err, res, body) {
+      t.equal(err, null)
+      t.equal(res.headers.code, statusCodes[index].toString())
+      t.equal(body, '')
+      next(++index)
+    })
+  })(0)
+})
+
+tape('cleanup', function (t) {
+  server.close(function () {
+    t.end()
+  })
+})

package/tests/test-har.js

@@ -0,0 +1,175 @@
+'use strict'
+
+var path = require('path')
+var request = require('..')
+var tape = require('tape')
+var fixture = require('./fixtures/har.json')
+var server = require('./server')
+
+var s = server.createEchoServer()
+
+tape('setup', function (t) {
+  s.listen(0, function () {
+    t.end()
+  })
+})
+
+tape('application-form-encoded', function (t) {
+  var options = {
+    url: s.url,
+    har: fixture['application-form-encoded']
+  }
+
+  request(options, function (err, res, body) {
+    var json = JSON.parse(body)
+
+    t.equal(err, null)
+    t.equal(json.body, 'foo=bar&hello=world')
+    t.end()
+  })
+})
+
+tape('application-json', function (t) {
+  var options = {
+    url: s.url,
+    har: fixture['application-json']
+  }
+
+  request(options, function (err, res, body) {
+    t.equal(err, null)
+    t.equal(body.body, fixture['application-json'].postData.text)
+    t.end()
+  })
+})
+
+tape('cookies', function (t) {
+  var options = {
+    url: s.url,
+    har: fixture.cookies
+  }
+
+  request(options, function (err, res, body) {
+    var json = JSON.parse(body)
+
+    t.equal(err, null)
+    t.equal(json.headers.cookie, 'foo=bar; bar=baz')
+    t.end()
+  })
+})
+
+tape('custom-method', function (t) {
+  var options = {
+    url: s.url,
+    har: fixture['custom-method']
+  }
+
+  request(options, function (err, res, body) {
+    var json = JSON.parse(body)
+
+    t.equal(err, null)
+    t.equal(json.method, fixture['custom-method'].method)
+    t.end()
+  })
+})
+
+tape('headers', function (t) {
+  var options = {
+    url: s.url,
+    har: fixture.headers
+  }
+
+  request(options, function (err, res, body) {
+    var json = JSON.parse(body)
+
+    t.equal(err, null)
+    t.equal(json.headers['x-foo'], 'Bar')
+    t.end()
+  })
+})
+
+tape('multipart-data', function (t) {
+  var options = {
+    url: s.url,
+    har: fixture['multipart-data']
+  }
+
+  request(options, function (err, res, body) {
+    var json = JSON.parse(body)
+
+    t.equal(err, null)
+    t.ok(~json.headers['content-type'].indexOf('multipart/form-data'))
+    t.ok(~json.body.indexOf('Content-Disposition: form-data; name="foo"; filename="hello.txt"\r\nContent-Type: text/plain\r\n\r\nHello World'))
+    t.end()
+  })
+})
+
+tape('multipart-file', function (t) {
+  var options = {
+    url: s.url,
+    har: fixture['multipart-file']
+  }
+  var absolutePath = path.resolve(__dirname, options.har.postData.params[0].fileName)
+  options.har.postData.params[0].fileName = absolutePath
+
+  request(options, function (err, res, body) {
+    var json = JSON.parse(body)
+
+    t.equal(err, null)
+    t.ok(~json.headers['content-type'].indexOf('multipart/form-data'))
+    t.ok(~json.body.indexOf('Content-Disposition: form-data; name="foo"; filename="unicycle.jpg"\r\nContent-Type: image/jpeg'))
+    t.end()
+  })
+})
+
+tape('multipart-form-data', function (t) {
+  var options = {
+    url: s.url,
+    har: fixture['multipart-form-data']
+  }
+
+  request(options, function (err, res, body) {
+    var json = JSON.parse(body)
+
+    t.equal(err, null)
+    t.ok(~json.headers['content-type'].indexOf('multipart/form-data'))
+    t.ok(~json.body.indexOf('Content-Disposition: form-data; name="foo"'))
+    t.end()
+  })
+})
+
+tape('query', function (t) {
+  var options = {
+    url: s.url + '/?fff=sss',
+    har: fixture.query
+  }
+
+  request(options, function (err, res, body) {
+    var json = JSON.parse(body)
+
+    t.equal(err, null)
+    t.equal(json.url, '/?fff=sss&foo%5B0%5D=bar&foo%5B1%5D=baz&baz=abc')
+    t.end()
+  })
+})
+
+tape('text/plain', function (t) {
+  var options = {
+    url: s.url,
+    har: fixture['text-plain']
+  }
+
+  request(options, function (err, res, body) {
+    var json = JSON.parse(body)
+
+    t.equal(err, null)
+    t.equal(json.headers['content-type'], 'text/plain')
+    t.equal(json.body, 'Hello World')
+    t.end()
+  })
+})
+
+tape('cleanup', function (t) {
+  s.close(function () {
+    t.end()
+  })
+})

package/tests/test-hawk.js

@@ -0,0 +1,187 @@
+'use strict'
+
+var http = require('http')
+var request = require('../index')
+var hawk = require('../lib/hawk')
+var tape = require('tape')
+var assert = require('assert')
+
+var server = http.createServer(function (req, res) {
+  res.writeHead(200, {
+    'Content-Type': 'text/plain'
+  })
+  res.end(authenticate(req))
+})
+
+tape('setup', function (t) {
+  server.listen(0, function () {
+    server.url = 'http://localhost:' + this.address().port
+    t.end()
+  })
+})
+
+var creds = {
+  key: 'werxhqb98rpaxn39848xrunpaw3489ruxnpa98w4rxn',
+  algorithm: 'sha256',
+  id: 'dh37fgj492je'
+}
+
+tape('hawk-get', function (t) {
+  request(server.url, {
+    hawk: { credentials: creds }
+  }, function (err, res, body) {
+    t.equal(err, null)
+    t.equal(res.statusCode, 200)
+    t.equal(body, 'OK')
+    t.end()
+  })
+})
+
+tape('hawk-post', function (t) {
+  request.post({ url: server.url, body: 'hello', hawk: { credentials: creds, payload: 'hello' } }, function (err, res, body) {
+    t.equal(err, null)
+    t.equal(res.statusCode, 200)
+    t.equal(body, 'OK')
+    t.end()
+  })
+})
+
+tape('hawk-ext', function (t) {
+  request(server.url, {
+    hawk: { credentials: creds, ext: 'test' }
+  }, function (err, res, body) {
+    t.equal(err, null)
+    t.equal(res.statusCode, 200)
+    t.equal(body, 'OK')
+    t.end()
+  })
+})
+
+tape('hawk-app', function (t) {
+  request(server.url, {
+    hawk: { credentials: creds, app: 'test' }
+  }, function (err, res, body) {
+    t.equal(err, null)
+    t.equal(res.statusCode, 200)
+    t.equal(body, 'OK')
+    t.end()
+  })
+})
+
+tape('hawk-app+dlg', function (t) {
+  request(server.url, {
+    hawk: { credentials: creds, app: 'test', dlg: 'asd' }
+  }, function (err, res, body) {
+    t.equal(err, null)
+    t.equal(res.statusCode, 200)
+    t.equal(body, 'OK')
+    t.end()
+  })
+})
+
+tape('hawk-missing-creds', function (t) {
+  request(server.url, {
+    hawk: {}
+  }, function (err, res, body) {
+    t.equal(err, null)
+    t.equal(res.statusCode, 200)
+    t.equal(body, 'FAIL')
+    t.end()
+  })
+})
+
+tape('hawk-missing-creds-id', function (t) {
+  request(server.url, {
+    hawk: {
+      credentials: {}
+    }
+  }, function (err, res, body) {
+    t.equal(err, null)
+    t.equal(res.statusCode, 200)
+    t.equal(body, 'FAIL')
+    t.end()
+  })
+})
+
+tape('hawk-missing-creds-key', function (t) {
+  request(server.url, {
+    hawk: {
+      credentials: { id: 'asd' }
+    }
+  }, function (err, res, body) {
+    t.equal(err, null)
+    t.equal(res.statusCode, 200)
+    t.equal(body, 'FAIL')
+    t.end()
+  })
+})
+
+tape('hawk-missing-creds-algo', function (t) {
+  request(server.url, {
+    hawk: {
+      credentials: { key: '123', id: '123' }
+    }
+  }, function (err, res, body) {
+    t.equal(err, null)
+    t.equal(res.statusCode, 200)
+    t.equal(body, 'FAIL')
+    t.end()
+  })
+})
+
+tape('hawk-invalid-creds-algo', function (t) {
+  request(server.url, {
+    hawk: {
+      credentials: { key: '123', id: '123', algorithm: 'xx' }
+    }
+  }, function (err, res, body) {
+    t.equal(err, null)
+    t.equal(res.statusCode, 200)
+    t.equal(body, 'FAIL')
+    t.end()
+  })
+})
+
+tape('cleanup', function (t) {
+  server.close(function () {
+    t.end()
+  })
+})
+
+function authenticate (req) {
+  if (!req.headers.authorization) {
+    return 'FAIL'
+  }
+
+  var headerParts = req.headers.authorization.match(/^(\w+)(?:\s+(.*))?$/)
+  assert.equal(headerParts[1], 'Hawk')
+  var attributes = {}
+  headerParts[2].replace(/(\w+)="([^"\\]*)"\s*(?:,\s*|$)/g, function ($0, $1, $2) { attributes[$1] = $2 })
+  var hostParts = req.headers.host.split(':')
+
+  const artifacts = {
+    method: req.method,
+    host: hostParts[0],
+    port: (hostParts[1] ? hostParts[1] : (req.connection && req.connection.encrypted ? 443 : 80)),
+    resource: req.url,
+    ts: attributes.ts,
+    nonce: attributes.nonce,
+    hash: attributes.hash,
+    ext: attributes.ext,
+    app: attributes.app,
+    dlg: attributes.dlg,
+    mac: attributes.mac,
+    id: attributes.id
+  }
+
+  assert.equal(attributes.id, 'dh37fgj492je')
+  var credentials = {
+    key: 'werxhqb98rpaxn39848xrunpaw3489ruxnpa98w4rxn',
+    algorithm: 'sha256',
+    user: 'Steve'
+  }
+
+  const mac = hawk.calculateMac(credentials, artifacts)
+  assert.equal(mac, attributes.mac)
+  return 'OK'
+}