appium-mac2-driver 4.5.1 → 4.6.1

package/node_modules/spdy/test/server-test.js

@@ -0,0 +1,487 @@
+/* eslint-env mocha */
+
+var assert = require('assert')
+var tls = require('tls')
+var net = require('net')
+var https = require('https')
+var transport = require('spdy-transport')
+var util = require('util')
+
+var fixtures = require('./fixtures')
+var spdy = require('../')
+
+describe('SPDY Server', function () {
+  fixtures.everyConfig(function (protocol, alpn, version, plain) {
+    var server
+    var client
+
+    beforeEach(function (done) {
+      server = spdy.createServer(Object.assign({
+        spdy: {
+          'x-forwarded-for': true,
+          plain: plain
+        }
+      }, fixtures.keys))
+
+      server.listen(fixtures.port, function () {
+        var socket = (plain ? net : tls).connect({
+          rejectUnauthorized: false,
+          port: fixtures.port,
+          ALPNProtocols: [alpn]
+        }, function () {
+          client = transport.connection.create(socket, {
+            protocol: protocol,
+            isServer: false
+          })
+          client.start(version)
+          done()
+        })
+      })
+    })
+
+    afterEach(function (done) {
+      client.socket.destroy()
+      server.close(done)
+    })
+
+    it('should process GET request', function (done) {
+      var stream = client.request({
+        method: 'GET',
+        path: '/get',
+        headers: {
+          a: 'b'
+        }
+      }, function (err) {
+        assert(!err)
+
+        stream.on('error', (err) => {
+          done(err)
+        })
+
+        stream.on('response', function (status, headers) {
+          assert.strictEqual(status, 200)
+          assert.strictEqual(headers.ok, 'yes')
+
+          fixtures.expectData(stream, 'response', done)
+        })
+
+        stream.end()
+      })
+
+      server.on('request', function (req, res) {
+        assert.strictEqual(req.isSpdy, res.isSpdy)
+        assert.strictEqual(req.spdyVersion, res.spdyVersion)
+        assert(req.isSpdy)
+        if (!plain) {
+          assert(req.socket.encrypted)
+          assert(req.socket.getPeerCertificate())
+        }
+
+        // Auto-detection
+        if (version === 3.1) {
+          assert(req.spdyVersion >= 3 && req.spdyVersion <= 3.1)
+        } else {
+          assert.strictEqual(req.spdyVersion, version)
+        }
+        assert(req.spdyStream)
+        assert(res.spdyStream)
+
+        assert.strictEqual(req.method, 'GET')
+        assert.strictEqual(req.url, '/get')
+        assert.deepStrictEqual(req.headers, { a: 'b', host: 'localhost' })
+
+        req.on('end', function () {
+          res.writeHead(200, {
+            ok: 'yes'
+          })
+          res.end('response')
+          assert(res.finished, 'res.finished should be set')
+        })
+        req.resume()
+      })
+    })
+
+    it('should process POST request', function (done) {
+      var stream = client.request({
+        method: 'POST',
+        path: '/post'
+      }, function (err) {
+        assert(!err)
+
+        stream.on('response', function (status, headers) {
+          assert.strictEqual(status, 200)
+          assert.strictEqual(headers.ok, 'yes')
+
+          fixtures.expectData(stream, 'response', next)
+        })
+
+        stream.end('request')
+      })
+
+      server.on('request', function (req, res) {
+        assert.strictEqual(req.method, 'POST')
+        assert.strictEqual(req.url, '/post')
+
+        res.writeHead(200, {
+          ok: 'yes'
+        })
+        res.end('response')
+
+        fixtures.expectData(req, 'request', next)
+      })
+
+      var waiting = 2
+      function next () {
+        if (--waiting === 0) {
+          return done()
+        }
+      }
+    })
+
+    it('should process expect-continue request', function (done) {
+      var stream = client.request({
+        method: 'GET',
+        path: '/get',
+        headers: {
+          Expect: '100-continue'
+        }
+      }, function (err) {
+        assert(!err)
+
+        stream.on('response', function (status, headers) {
+          assert.strictEqual(status, 100)
+
+          fixtures.expectData(stream, 'response', done)
+        })
+
+        stream.end()
+      })
+
+      server.on('request', function (req, res) {
+        req.on('end', function () {
+          res.end('response')
+        })
+        req.resume()
+      })
+    })
+
+    it('should emit `checkContinue` request', function (done) {
+      var stream = client.request({
+        method: 'GET',
+        path: '/get',
+        headers: {
+          Expect: '100-continue'
+        }
+      }, function (err) {
+        assert(!err)
+
+        stream.on('response', function (status, headers) {
+          assert.strictEqual(status, 100)
+
+          fixtures.expectData(stream, 'response', done)
+        })
+
+        stream.end()
+      })
+
+      server.on('checkContinue', function (req, res) {
+        req.on('end', function () {
+          res.writeContinue()
+          res.end('response')
+        })
+        req.resume()
+      })
+    })
+
+    it('should send PUSH_PROMISE', function (done) {
+      var stream = client.request({
+        method: 'POST',
+        path: '/page'
+      }, function (err) {
+        assert(!err)
+
+        stream.on('pushPromise', function (push) {
+          assert.strictEqual(push.path, '/push')
+          assert.strictEqual(push.headers.yes, 'push')
+
+          fixtures.expectData(push, 'push', next)
+          fixtures.expectData(stream, 'response', next)
+        })
+
+        stream.end('request')
+      })
+
+      server.on('request', function (req, res) {
+        assert.strictEqual(req.method, 'POST')
+        assert.strictEqual(req.url, '/page')
+
+        res.writeHead(200, {
+          ok: 'yes'
+        })
+
+        var push = res.push('/push', {
+          request: {
+            yes: 'push'
+          }
+        })
+        push.end('push')
+
+        res.end('response')
+
+        fixtures.expectData(req, 'request', next)
+      })
+
+      var waiting = 3
+      function next () {
+        if (--waiting === 0) {
+          return done()
+        }
+      }
+    })
+
+    it('should receive trailing headers', function (done) {
+      var stream = client.request({
+        method: 'POST',
+        path: '/post'
+      }, function (err) {
+        assert(!err)
+
+        stream.sendHeaders({ trai: 'ler' })
+        stream.end()
+
+        stream.on('response', function (status, headers) {
+          assert.strictEqual(status, 200)
+          assert.strictEqual(headers.ok, 'yes')
+
+          fixtures.expectData(stream, 'response', done)
+        })
+      })
+
+      server.on('request', function (req, res) {
+        var gotHeaders = false
+        req.on('trailers', function (headers) {
+          gotHeaders = true
+          assert.strictEqual(headers.trai, 'ler')
+        })
+
+        req.on('end', function () {
+          assert(gotHeaders)
+
+          res.writeHead(200, {
+            ok: 'yes'
+          })
+          res.end('response')
+        })
+        req.resume()
+      })
+    })
+
+    it('should call .writeHead() automatically', function (done) {
+      var stream = client.request({
+        method: 'POST',
+        path: '/post'
+      }, function (err) {
+        assert(!err)
+
+        stream.on('response', function (status, headers) {
+          assert.strictEqual(status, 300)
+
+          fixtures.expectData(stream, 'response', done)
+        })
+        stream.end()
+      })
+
+      server.on('request', function (req, res) {
+        req.on('end', function () {
+          res.statusCode = 300
+          res.end('response')
+        })
+        req.resume()
+      })
+    })
+
+    it('should not crash on .writeHead() after socket close', function (done) {
+      var stream = client.request({
+        method: 'POST',
+        path: '/post'
+      }, function (err) {
+        assert(!err)
+
+        setTimeout(function () {
+          client.socket.destroy()
+        }, 50)
+        stream.on('error', function () {})
+        stream.end()
+      })
+
+      server.on('request', function (req, res) {
+        req.connection.on('close', function () {
+          assert.doesNotThrow(function () {
+            res.writeHead(200)
+            res.end('response')
+          })
+          done()
+        })
+      })
+    })
+
+    it('should not crash on .push() after socket close', function (done) {
+      var stream = client.request({
+        method: 'POST',
+        path: '/post'
+      }, function (err) {
+        assert(!err)
+
+        setTimeout(function () {
+          client.socket.destroy()
+        }, 50)
+        stream.on('error', function () {})
+        stream.end()
+      })
+
+      server.on('request', function (req, res) {
+        req.connection.on('close', function () {
+          assert.doesNotThrow(function () {
+            assert.strictEqual(res.push('/push', {}), undefined)
+            res.end('response')
+          })
+          done()
+        })
+      })
+    })
+
+    it('should end response after writing everything down', function (done) {
+      var stream = client.request({
+        method: 'GET',
+        path: '/post'
+      }, function (err) {
+        assert(!err)
+
+        stream.on('response', function (status, headers) {
+          assert.strictEqual(status, 200)
+
+          fixtures.expectData(stream, 'hello world, what\'s up?', done)
+        })
+
+        stream.end()
+      })
+
+      server.on('request', function (req, res) {
+        req.resume()
+        res.writeHead(200)
+        res.write('hello ')
+        res.write('world')
+        res.write(', what\'s')
+        res.write(' up?')
+        res.end()
+      })
+    })
+
+    it('should handle x-forwarded-for', function (done) {
+      client.sendXForwardedFor('1.2.3.4')
+
+      var stream = client.request({
+        method: 'GET',
+        path: '/post'
+      }, function (err) {
+        assert(!err)
+
+        stream.resume()
+        stream.on('end', done)
+        stream.end()
+      })
+
+      server.on('request', function (req, res) {
+        assert.strictEqual(req.headers['x-forwarded-for'], '1.2.3.4')
+        req.resume()
+        res.end()
+      })
+    })
+
+    it('should destroy request after end', function (done) {
+      var stream = client.request({
+        method: 'POST',
+        path: '/post'
+      }, function (err) {
+        assert(!err)
+      })
+      stream.end()
+      stream.on('error', function () {})
+
+      server.on('request', function (req, res) {
+        res.end()
+        res.destroy()
+        res.socket.on('close', function () {
+          done()
+        })
+      })
+    })
+  })
+
+  it('should respond to http/1.1', function (done) {
+    var server = spdy.createServer(fixtures.keys, function (req, res) {
+      assert.strictEqual(req.isSpdy, res.isSpdy)
+      assert.strictEqual(req.spdyVersion, res.spdyVersion)
+      assert(!req.isSpdy)
+      assert.strictEqual(req.spdyVersion, 1)
+
+      res.writeHead(200)
+      res.end()
+    })
+
+    server.listen(fixtures.port, function () {
+      var req = https.request({
+        agent: false,
+        rejectUnauthorized: false,
+        NPNProtocols: ['http/1.1'],
+        port: fixtures.port,
+        method: 'GET',
+        path: '/'
+      }, function (res) {
+        assert.strictEqual(res.statusCode, 200)
+        res.resume()
+        res.on('end', function () {
+          server.close(done)
+        })
+      })
+
+      req.end()
+    })
+  })
+
+  it('should support custom base', function (done) {
+    function Pseuver (options, listener) {
+      https.Server.call(this, options, listener)
+    }
+    util.inherits(Pseuver, https.Server)
+
+    var server = spdy.createServer(Pseuver, fixtures.keys, function (req, res) {
+      assert.strictEqual(req.isSpdy, res.isSpdy)
+      assert.strictEqual(req.spdyVersion, res.spdyVersion)
+      assert(!req.isSpdy)
+      assert.strictEqual(req.spdyVersion, 1)
+
+      res.writeHead(200)
+      res.end()
+    })
+
+    server.listen(fixtures.port, function () {
+      var req = https.request({
+        agent: false,
+        rejectUnauthorized: false,
+        NPNProtocols: ['http/1.1'],
+        port: fixtures.port,
+        method: 'GET',
+        path: '/'
+      }, function (res) {
+        assert.strictEqual(res.statusCode, 200)
+        res.resume()
+        res.on('end', function () {
+          server.close(done)
+        })
+      })
+
+      req.end()
+    })
+  })
+})

package/node_modules/spdy-transport/.travis.yml

@@ -0,0 +1,14 @@
+sudo: false
+
+language: node_js
+
+node_js:
+  - "6"
+  - "8"
+  - "10"
+  - "stable"
+
+script:
+  - npm run lint
+  - npm test
+  - npm run coverage

package/node_modules/spdy-transport/README.md

@@ -0,0 +1,76 @@
+# spdy-transport
+
+[![Build Status](https://travis-ci.org/spdy-http2/spdy-transport.svg?branch=master)](http://travis-ci.org/spdy-http2/spdy-transport)
+[![NPM version](https://badge.fury.io/js/spdy-transport.svg)](http://badge.fury.io/js/spdy-transport)
+[![dependencies Status](https://david-dm.org/spdy-http2/spdy-transport/status.svg?style=flat-square)](https://david-dm.org/spdy-http2/spdy-transport)
+[![Standard - JavaScript Style Guide](https://img.shields.io/badge/code_style-standard-brightgreen.svg?style=flat-square)](http://standardjs.com/)
+[![Waffle](https://img.shields.io/badge/track-waffle-blue.svg?style=flat-square)](https://waffle.io/spdy-http2/node-spdy)
+
+> SPDY/HTTP2 generic transport implementation.
+
+## Usage
+
+```javascript
+var transport = require('spdy-transport');
+
+// NOTE: socket is some stream or net.Socket instance, may be an argument
+// of `net.createServer`'s connection handler.
+
+var server = transport.connection.create(socket, {
+  protocol: 'http2',
+  isServer: true
+});
+
+server.on('stream', function(stream) {
+  console.log(stream.method, stream.path, stream.headers);
+  stream.respond(200, {
+    header: 'value'
+  });
+
+  stream.on('readable', function() {
+    var chunk = stream.read();
+    if (!chunk)
+      return;
+
+    console.log(chunk);
+  });
+
+  stream.on('end', function() {
+    console.log('end');
+  });
+
+  // And other node.js Stream APIs
+  // ...
+});
+```
+
+## LICENSE
+
+This software is licensed under the MIT License.
+
+Copyright Fedor Indutny, 2015.
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to permit
+persons to whom the Software is furnished to do so, subject to the
+following conditions:
+
+The above copyright notice and this permission notice shall be included
+in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+[0]: http://json.org/
+[1]: http://github.com/indutny/bud-backend
+[2]: https://github.com/nodejs/io.js
+[3]: https://github.com/libuv/libuv
+[4]: http://openssl.org/