appium-mac2-driver 4.5.1 → 4.6.1

package/node_modules/http-deceiver/lib/deceiver.js

@@ -0,0 +1,250 @@
+var assert = require('assert');
+var util = require('util');
+
+var Buffer = require('buffer').Buffer;
+
+// Node.js version
+var mode = /^v0\.8\./.test(process.version) ? 'rusty' :
+           /^v0\.(9|10)\./.test(process.version) ? 'old' :
+           /^v0\.12\./.test(process.version) ? 'normal' :
+           'modern';
+
+var HTTPParser;
+
+var methods;
+var reverseMethods;
+
+var kOnHeaders;
+var kOnHeadersComplete;
+var kOnMessageComplete;
+var kOnBody;
+if (mode === 'normal' || mode === 'modern') {
+  HTTPParser = process.binding('http_parser').HTTPParser;
+  methods = HTTPParser.methods;
+
+  // v6
+  if (!methods)
+    methods = process.binding('http_parser').methods;
+
+  reverseMethods = {};
+
+  methods.forEach(function(method, index) {
+    reverseMethods[method] = index;
+  });
+
+  kOnHeaders = HTTPParser.kOnHeaders | 0;
+  kOnHeadersComplete = HTTPParser.kOnHeadersComplete | 0;
+  kOnMessageComplete = HTTPParser.kOnMessageComplete | 0;
+  kOnBody = HTTPParser.kOnBody | 0;
+} else {
+  kOnHeaders = 'onHeaders';
+  kOnHeadersComplete = 'onHeadersComplete';
+  kOnMessageComplete = 'onMessageComplete';
+  kOnBody = 'onBody';
+}
+
+function Deceiver(socket, options) {
+  this.socket = socket;
+  this.options = options || {};
+  this.isClient = this.options.isClient;
+}
+module.exports = Deceiver;
+
+Deceiver.create = function create(stream, options) {
+  return new Deceiver(stream, options);
+};
+
+Deceiver.prototype._toHeaderList = function _toHeaderList(object) {
+  var out = [];
+  var keys = Object.keys(object);
+
+  for (var i = 0; i < keys.length; i++)
+    out.push(keys[i], object[keys[i]]);
+
+  return out;
+};
+
+Deceiver.prototype._isUpgrade = function _isUpgrade(request) {
+  return request.method === 'CONNECT' ||
+         request.headers.upgrade ||
+         request.headers.connection &&
+            /(^|\W)upgrade(\W|$)/i.test(request.headers.connection);
+};
+
+// TODO(indutny): support CONNECT
+if (mode === 'modern') {
+  /*
+  function parserOnHeadersComplete(versionMajor, versionMinor, headers, method,
+                                   url, statusCode, statusMessage, upgrade,
+                                   shouldKeepAlive) {
+   */
+  Deceiver.prototype.emitRequest = function emitRequest(request) {
+    var parser = this.socket.parser;
+    assert(parser, 'No parser present');
+
+    parser.execute = null;
+
+    var self = this;
+    var method = reverseMethods[request.method];
+    parser.execute = function execute() {
+      self._skipExecute(this);
+      this[kOnHeadersComplete](1,
+                               1,
+                               self._toHeaderList(request.headers),
+                               method,
+                               request.path,
+                               0,
+                               '',
+                               self._isUpgrade(request),
+                               true);
+      return 0;
+    };
+
+    this._emitEmpty();
+  };
+
+  Deceiver.prototype.emitResponse = function emitResponse(response) {
+    var parser = this.socket.parser;
+    assert(parser, 'No parser present');
+
+    parser.execute = null;
+
+    var self = this;
+    parser.execute = function execute() {
+      self._skipExecute(this);
+      this[kOnHeadersComplete](1,
+                               1,
+                               self._toHeaderList(response.headers),
+                               response.path,
+                               response.code,
+                               response.status,
+                               response.reason || '',
+                               self._isUpgrade(response),
+                               true);
+      return 0;
+    };
+
+    this._emitEmpty();
+  };
+} else {
+  /*
+    `function parserOnHeadersComplete(info) {`
+
+    info = { .versionMajor, .versionMinor, .url, .headers, .method,
+             .statusCode, .statusMessage, .upgrade, .shouldKeepAlive }
+   */
+  Deceiver.prototype.emitRequest = function emitRequest(request) {
+    var parser = this.socket.parser;
+    assert(parser, 'No parser present');
+
+    var method = request.method;
+    if (reverseMethods)
+      method = reverseMethods[method];
+
+    var info = {
+      versionMajor: 1,
+      versionMinor: 1,
+      url: request.path,
+      headers: this._toHeaderList(request.headers),
+      method: method,
+      statusCode: 0,
+      statusMessage: '',
+      upgrade: this._isUpgrade(request),
+      shouldKeepAlive: true
+    };
+
+    var self = this;
+    parser.execute = function execute() {
+      self._skipExecute(this);
+      this[kOnHeadersComplete](info);
+      return 0;
+    };
+
+    this._emitEmpty();
+  };
+
+  Deceiver.prototype.emitResponse = function emitResponse(response) {
+    var parser = this.socket.parser;
+    assert(parser, 'No parser present');
+
+    var info = {
+      versionMajor: 1,
+      versionMinor: 1,
+      url: response.path,
+      headers: this._toHeaderList(response.headers),
+      method: false,
+      statusCode: response.status,
+      statusMessage: response.reason || '',
+      upgrade: this._isUpgrade(response),
+      shouldKeepAlive: true
+    };
+
+    var self = this;
+    parser.execute = function execute() {
+      self._skipExecute(this);
+      this[kOnHeadersComplete](info);
+      return 0;
+    };
+
+    this._emitEmpty();
+  };
+}
+
+Deceiver.prototype._skipExecute = function _skipExecute(parser) {
+  var self = this;
+  var oldExecute = parser.constructor.prototype.execute;
+  var oldFinish = parser.constructor.prototype.finish;
+
+  parser.execute = null;
+  parser.finish = null;
+
+  parser.execute = function execute(buffer, start, len) {
+    // Parser reuse
+    if (this.socket !== self.socket) {
+      this.execute = oldExecute;
+      this.finish = oldFinish;
+      return this.execute(buffer, start, len);
+    }
+
+    if (start !== undefined)
+      buffer = buffer.slice(start, start + len);
+    self.emitBody(buffer);
+    return len;
+  };
+
+  parser.finish = function finish() {
+    // Parser reuse
+    if (this.socket !== self.socket) {
+      this.execute = oldExecute;
+      this.finish = oldFinish;
+      return this.finish();
+    }
+
+    this.execute = oldExecute;
+    this.finish = oldFinish;
+    self.emitMessageComplete();
+  };
+};
+
+Deceiver.prototype.emitBody = function emitBody(buffer) {
+  var parser = this.socket.parser;
+  assert(parser, 'No parser present');
+
+  parser[kOnBody](buffer, 0, buffer.length);
+};
+
+Deceiver.prototype._emitEmpty = function _emitEmpty() {
+  // Emit data to force out handling of UPGRADE
+  var empty = new Buffer(0);
+  if (this.socket.ondata)
+    this.socket.ondata(empty, 0, 0);
+  else
+    this.socket.emit('data', empty);
+};
+
+Deceiver.prototype.emitMessageComplete = function emitMessageComplete() {
+  var parser = this.socket.parser;
+  assert(parser, 'No parser present');
+
+  parser[kOnMessageComplete]();
+};

package/node_modules/http-deceiver/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "http-deceiver",
+  "version": "1.2.7",
+  "description": "Deceive HTTP parser",
+  "main": "lib/deceiver.js",
+  "scripts": {
+    "test": "mocha --reporter=spec test/*-test.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/indutny/http-deceiver.git"
+  },
+  "keywords": [
+    "http",
+    "net",
+    "deceive"
+  ],
+  "author": "Fedor Indutny <fedor@indutny.com>",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/indutny/http-deceiver/issues"
+  },
+  "homepage": "https://github.com/indutny/http-deceiver#readme",
+  "devDependencies": {
+    "handle-thing": "^1.0.1",
+    "mocha": "^2.2.5",
+    "readable-stream": "^2.0.1",
+    "stream-pair": "^1.0.0"
+  }
+}

package/node_modules/http-deceiver/test/api-test.js

@@ -0,0 +1,226 @@
+var assert = require('assert');
+var net = require('net');
+var http = require('http');
+var streamPair = require('stream-pair');
+var thing = require('handle-thing');
+
+var httpDeceiver = require('../');
+
+describe('HTTP Deceiver', function() {
+  var handle;
+  var pair;
+  var socket;
+  var deceiver;
+
+  beforeEach(function() {
+    pair = streamPair.create();
+    handle = thing.create(pair.other);
+    socket = new net.Socket({ handle: handle });
+
+    // For v0.8
+    socket.readable = true;
+    socket.writable = true;
+
+    deceiver = httpDeceiver.create(socket);
+  });
+
+  it('should emit request', function(done) {
+    var server = http.createServer();
+    server.emit('connection', socket);
+
+    server.on('request', function(req, res) {
+      assert.equal(req.method, 'PUT');
+      assert.equal(req.url, '/hello');
+      assert.deepEqual(req.headers, { a: 'b' });
+
+      done();
+    });
+
+    deceiver.emitRequest({
+      method: 'PUT',
+      path: '/hello',
+      headers: {
+        a: 'b'
+      }
+    });
+  });
+
+  it('should emit response', function(done) {
+    var agent = new http.Agent();
+    agent.createConnection = function createConnection() {
+      return socket;
+    };
+    var client = http.request({
+      method: 'POST',
+      path: '/ok',
+      agent: agent
+    }, function(res) {
+      assert.equal(res.statusCode, 421);
+      assert.deepEqual(res.headers, { a: 'b' });
+
+      done();
+    });
+
+    process.nextTick(function() {
+      deceiver.emitResponse({
+        status: 421,
+        reason: 'F',
+        headers: {
+          a: 'b'
+        }
+      });
+    });
+  });
+
+  it('should override .execute and .finish', function(done) {
+    var server = http.createServer();
+    server.emit('connection', socket);
+
+    server.on('request', function(req, res) {
+      assert.equal(req.method, 'PUT');
+      assert.equal(req.url, '/hello');
+      assert.deepEqual(req.headers, { a: 'b' });
+
+      var actual = '';
+      req.on('data', function(chunk) {
+        actual += chunk;
+      });
+      req.once('end', function() {
+        assert.equal(actual, 'hello world');
+        done();
+      });
+    });
+
+    deceiver.emitRequest({
+      method: 'PUT',
+      path: '/hello',
+      headers: {
+        a: 'b'
+      }
+    });
+
+    pair.write('hello');
+    pair.end(' world');
+  });
+
+  it('should work with reusing parser', function(done) {
+    var server = http.createServer();
+    server.emit('connection', socket);
+
+    function secondRequest() {
+      pair = streamPair.create();
+      handle = thing.create(pair.other);
+      socket = new net.Socket({ handle: handle });
+
+      // For v0.8
+      socket.readable = true;
+      socket.writable = true;
+
+      server.emit('connection', socket);
+
+      pair.end('PUT /second HTTP/1.1\r\nContent-Length:11\r\n\r\nhello world');
+    }
+
+    server.on('request', function(req, res) {
+      var actual = '';
+      req.on('data', function(chunk) {
+        actual += chunk;
+      });
+      req.once('end', function() {
+        assert.equal(actual, 'hello world');
+
+        if (req.url === '/first')
+          secondRequest();
+        else
+          done();
+      });
+    });
+
+    deceiver.emitRequest({
+      method: 'PUT',
+      path: '/first',
+      headers: {
+        a: 'b'
+      }
+    });
+
+    pair.write('hello');
+    pair.end(' world');
+  });
+
+  it('should emit CONNECT request', function(done) {
+    var server = http.createServer();
+    server.emit('connection', socket);
+
+    server.on('connect', function(req, socket, bodyHead) {
+      assert.equal(req.method, 'CONNECT');
+      assert.equal(req.url, '/hello');
+
+      done();
+    });
+
+    deceiver.emitRequest({
+      method: 'CONNECT',
+      path: '/hello',
+      headers: {
+      }
+    });
+  });
+
+  it('should emit Upgrade request', function(done) {
+    var server = http.createServer();
+    server.emit('connection', socket);
+
+    server.on('upgrade', function(req, socket, bodyHead) {
+      assert.equal(req.method, 'POST');
+      assert.equal(req.url, '/hello');
+
+      socket.on('data', function(chunk) {
+        assert.equal(chunk + '', 'hm');
+        done();
+      });
+    });
+
+    deceiver.emitRequest({
+      method: 'POST',
+      path: '/hello',
+      headers: {
+        'upgrade': 'websocket'
+      }
+    });
+
+    pair.write('hm');
+  });
+
+  it('should emit Upgrade response', function(done) {
+    var agent = new http.Agent();
+    agent.createConnection = function createConnection() {
+      return socket;
+    };
+    var client = http.request({
+      method: 'POST',
+      path: '/ok',
+      headers: {
+        connection: 'upgrade',
+        upgrade: 'websocket'
+      },
+      agent: agent
+    }, function(res) {
+      assert(false);
+    });
+    client.on('upgrade', function(res, socket) {
+      assert.equal(res.statusCode, 421);
+      done();
+    });
+
+    process.nextTick(function() {
+      deceiver.emitResponse({
+        status: 421,
+        reason: 'F',
+        headers: {
+          upgrade: 'websocket'
+        }
+      });
+    });
+  });
+});

package/node_modules/http-errors/HISTORY.md

@@ -0,0 +1,186 @@
+2.0.1 / 2025-11-20
+==================
+
+  * deps: use tilde notation for dependencies
+  * deps: update statuses to 2.0.2
+
+2.0.0 / 2021-12-17
+==================
+
+  * Drop support for Node.js 0.6
+  * Remove `I'mateapot` export; use `ImATeapot` instead
+  * Remove support for status being non-first argument
+  * Rename `UnorderedCollection` constructor to `TooEarly`
+  * deps: depd@2.0.0
+    - Replace internal `eval` usage with `Function` constructor
+    - Use instance methods on `process` to check for listeners
+  * deps: statuses@2.0.1
+    - Fix messaging casing of `418 I'm a Teapot`
+    - Remove code 306
+    - Rename `425 Unordered Collection` to standard `425 Too Early`
+
+2021-11-14 / 1.8.1
+==================
+
+  * deps: toidentifier@1.0.1
+
+2020-06-29 / 1.8.0
+==================
+
+  * Add `isHttpError` export to determine if value is an HTTP error
+  * deps: setprototypeof@1.2.0
+
+2019-06-24 / 1.7.3
+==================
+
+  * deps: inherits@2.0.4
+
+2019-02-18 / 1.7.2
+==================
+
+  * deps: setprototypeof@1.1.1
+
+2018-09-08 / 1.7.1
+==================
+
+  * Fix error creating objects in some environments
+
+2018-07-30 / 1.7.0
+==================
+
+  * Set constructor name when possible
+  * Use `toidentifier` module to make class names
+  * deps: statuses@'>= 1.5.0 < 2'
+
+2018-03-29 / 1.6.3
+==================
+
+  * deps: depd@~1.1.2
+    - perf: remove argument reassignment
+  * deps: setprototypeof@1.1.0
+  * deps: statuses@'>= 1.4.0 < 2'
+
+2017-08-04 / 1.6.2
+==================
+
+  * deps: depd@1.1.1
+    - Remove unnecessary `Buffer` loading
+
+2017-02-20 / 1.6.1
+==================
+
+  * deps: setprototypeof@1.0.3
+    - Fix shim for old browsers
+
+2017-02-14 / 1.6.0
+==================
+
+  * Accept custom 4xx and 5xx status codes in factory
+  * Add deprecation message to `"I'mateapot"` export
+  * Deprecate passing status code as anything except first argument in factory
+  * Deprecate using non-error status codes
+  * Make `message` property enumerable for `HttpError`s
+
+2016-11-16 / 1.5.1
+==================
+
+  * deps: inherits@2.0.3
+    - Fix issue loading in browser
+  * deps: setprototypeof@1.0.2
+  * deps: statuses@'>= 1.3.1 < 2'
+
+2016-05-18 / 1.5.0
+==================
+
+  * Support new code `421 Misdirected Request`
+  * Use `setprototypeof` module to replace `__proto__` setting
+  * deps: statuses@'>= 1.3.0 < 2'
+    - Add `421 Misdirected Request`
+    - perf: enable strict mode
+  * perf: enable strict mode
+
+2016-01-28 / 1.4.0
+==================
+
+  * Add `HttpError` export, for `err instanceof createError.HttpError`
+  * deps: inherits@2.0.1
+  * deps: statuses@'>= 1.2.1 < 2'
+    - Fix message for status 451
+    - Remove incorrect nginx status code
+
+2015-02-02 / 1.3.1
+==================
+
+  * Fix regression where status can be overwritten in `createError` `props`
+
+2015-02-01 / 1.3.0
+==================
+
+  * Construct errors using defined constructors from `createError`
+  * Fix error names that are not identifiers
+    - `createError["I'mateapot"]` is now `createError.ImATeapot`
+  * Set a meaningful `name` property on constructed errors
+
+2014-12-09 / 1.2.8
+==================
+
+  * Fix stack trace from exported function
+  * Remove `arguments.callee` usage
+
+2014-10-14 / 1.2.7
+==================
+
+  * Remove duplicate line
+
+2014-10-02 / 1.2.6
+==================
+
+  * Fix `expose` to be `true` for `ClientError` constructor
+
+2014-09-28 / 1.2.5
+==================
+
+  * deps: statuses@1
+
+2014-09-21 / 1.2.4
+==================
+
+  * Fix dependency version to work with old `npm`s
+
+2014-09-21 / 1.2.3
+==================
+
+  * deps: statuses@~1.1.0
+
+2014-09-21 / 1.2.2
+==================
+
+  * Fix publish error
+
+2014-09-21 / 1.2.1
+==================
+
+  * Support Node.js 0.6
+  * Use `inherits` instead of `util`
+
+2014-09-09 / 1.2.0
+==================
+
+  * Fix the way inheriting functions
+  * Support `expose` being provided in properties argument
+
+2014-09-08 / 1.1.0
+==================
+
+  * Default status to 500
+  * Support provided `error` to extend
+
+2014-09-08 / 1.0.1
+==================
+
+  * Fix accepting string message
+
+2014-09-08 / 1.0.0
+==================
+
+  * Initial release

package/node_modules/http-errors/LICENSE

@@ -0,0 +1,23 @@
+
+The MIT License (MIT)
+
+Copyright (c) 2014 Jonathan Ong me@jongleberry.com
+Copyright (c) 2016 Douglas Christopher Wilson doug@somethingdoug.com
+
+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.