node_modules

2 files changed, 389 insertions, 0 deletions

diff --git a/node_modules/selenium-webdriver/test/http/http_test.js b/node_modules/selenium-webdriver/test/http/http_test.js
new file mode 100644
index 000000000..6056cda8e
--- /dev/null
+++ b/node_modules/selenium-webdriver/test/http/http_test.js
@@ -0,0 +1,205 @@
+// Licensed to the Software Freedom Conservancy (SFC) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The SFC licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+'use strict';
+
+var assert = require('assert'),
+    http = require('http'),
+    url = require('url');
+
+var HttpClient = require('../../http').HttpClient,
+    HttpRequest = require('../../lib/http').Request,
+    HttpResponse = require('../../lib/http').Response,
+    Server = require('../../lib/test/httpserver').Server;
+
+describe('HttpClient', function() {
+  this.timeout(4 * 1000);
+
+  var server = new Server(function(req, res) {
+    let parsedUrl = url.parse(req.url);
+
+    if (req.method == 'GET' && req.url == '/echo') {
+      res.writeHead(200, req.headers);
+      res.end();
+
+    } else if (req.method == 'GET' && req.url == '/redirect') {
+      res.writeHead(303, {'Location': server.url('/hello')});
+      res.end();
+
+    } else if (req.method == 'GET' && req.url == '/hello') {
+      res.writeHead(200, {'content-type': 'text/plain'});
+      res.end('hello, world!');
+
+    } else if (req.method == 'GET' && req.url == '/badredirect') {
+      res.writeHead(303, {});
+      res.end();
+
+    } else if (req.method == 'GET' && req.url == '/protected') {
+      var denyAccess = function() {
+        res.writeHead(401, {'WWW-Authenticate': 'Basic realm="test"'});
+        res.end('Access denied');
+      };
+
+      var basicAuthRegExp = /^\s*basic\s+([a-z0-9\-\._~\+\/]+)=*\s*$/i
+      var auth = req.headers.authorization;
+      var match = basicAuthRegExp.exec(auth || '');
+      if (!match) {
+        denyAccess();
+        return;
+      }
+
+      var userNameAndPass = new Buffer(match[1], 'base64').toString();
+      var parts = userNameAndPass.split(':', 2);
+      if (parts[0] !== 'genie' && parts[1] !== 'bottle') {
+        denyAccess();
+        return;
+      }
+
+      res.writeHead(200, {'content-type': 'text/plain'});
+      res.end('Access granted!');
+
+    } else if (req.method == 'GET'
+        && parsedUrl.pathname
+        && parsedUrl.pathname.endsWith('/proxy')) {
+      let headers = Object.assign({}, req.headers);
+      headers['x-proxy-request-uri'] = req.url;
+      res.writeHead(200, headers);
+      res.end();
+
+    } else if (req.method == 'GET'
+        && parsedUrl.pathname
+        && parsedUrl.pathname.endsWith('/proxy/redirect')) {
+      let path = `/proxy${parsedUrl.search || ''}${parsedUrl.hash || ''}`;
+      res.writeHead(303, {'Location': path});
+      res.end();
+
+    } else {
+      res.writeHead(404, {});
+      res.end();
+    }
+  });
+
+  before(function() {
+    return server.start();
+  });
+
+  after(function() {
+    return server.stop();
+  });
+
+  it('can send a basic HTTP request', function() {
+    var request = new HttpRequest('GET', '/echo');
+    request.headers.set('Foo', 'Bar');
+
+    var agent = new http.Agent();
+    agent.maxSockets = 1;  // Only making 1 request.
+
+    var client = new HttpClient(server.url(), agent);
+    return client.send(request).then(function(response) {
+      assert.equal(200, response.status);
+      assert.equal(response.headers.get('content-length'), '0');
+      assert.equal(response.headers.get('connection'), 'keep-alive');
+      assert.equal(response.headers.get('host'), server.host());
+
+      assert.equal(request.headers.get('Foo'), 'Bar');
+      assert.equal(
+          request.headers.get('Accept'), 'application/json; charset=utf-8');
+    });
+  });
+
+  it('can use basic auth', function() {
+    var parsed = url.parse(server.url());
+    parsed.auth = 'genie:bottle';
+
+    var client = new HttpClient(url.format(parsed));
+    var request = new HttpRequest('GET', '/protected');
+    return client.send(request).then(function(response) {
+      assert.equal(200, response.status);
+      assert.equal(response.headers.get('content-type'), 'text/plain');
+      assert.equal(response.body, 'Access granted!');
+    });
+  });
+
+  it('fails requests missing required basic auth', function() {
+    var client = new HttpClient(server.url());
+    var request = new HttpRequest('GET', '/protected');
+    return client.send(request).then(function(response) {
+      assert.equal(401, response.status);
+      assert.equal(response.body, 'Access denied');
+    });
+  });
+
+  it('automatically follows redirects', function() {
+    var request = new HttpRequest('GET', '/redirect');
+    var client = new HttpClient(server.url());
+    return client.send(request).then(function(response) {
+      assert.equal(200, response.status);
+      assert.equal(response.headers.get('content-type'), 'text/plain');
+      assert.equal(response.body, 'hello, world!');
+    });
+  });
+
+  it('handles malformed redirect responses', function() {
+    var request = new HttpRequest('GET', '/badredirect');
+    var client = new HttpClient(server.url());
+    return client.send(request).then(assert.fail, function(err) {
+      assert.ok(/Failed to parse "Location"/.test(err.message),
+          'Not the expected error: ' + err.message);
+    });
+  });
+
+  describe('with proxy', function() {
+    it('sends request to proxy with absolute URI', function() {
+      var request = new HttpRequest('GET', '/proxy');
+      var client = new HttpClient(
+          'http://another.server.com', undefined, server.url());
+      return client.send(request).then(function(response) {
+        assert.equal(200, response.status);
+        assert.equal(response.headers.get('host'), 'another.server.com');
+        assert.equal(
+            response.headers.get('x-proxy-request-uri'),
+            'http://another.server.com/proxy');
+      });
+    });
+
+    it('uses proxy when following redirects', function() {
+      var request = new HttpRequest('GET', '/proxy/redirect');
+      var client = new HttpClient(
+          'http://another.server.com', undefined, server.url());
+      return client.send(request).then(function(response) {
+        assert.equal(200, response.status);
+        assert.equal(response.headers.get('host'), 'another.server.com');
+        assert.equal(
+            response.headers.get('x-proxy-request-uri'),
+            'http://another.server.com/proxy');
+      });
+    });
+
+    it('includes search and hash in redirect URI', function() {
+      var request = new HttpRequest('GET', '/proxy/redirect?foo#bar');
+      var client = new HttpClient(
+          'http://another.server.com', undefined, server.url());
+      return client.send(request).then(function(response) {
+        assert.equal(200, response.status);
+        assert.equal(response.headers.get('host'), 'another.server.com');
+        assert.equal(
+            response.headers.get('x-proxy-request-uri'),
+            'http://another.server.com/proxy?foo#bar');
+      });
+    });
+  });
+});
diff --git a/node_modules/selenium-webdriver/test/http/util_test.js b/node_modules/selenium-webdriver/test/http/util_test.js
new file mode 100644
index 000000000..aa7a9158a
--- /dev/null
+++ b/node_modules/selenium-webdriver/test/http/util_test.js
@@ -0,0 +1,184 @@
+// Licensed to the Software Freedom Conservancy (SFC) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The SFC licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+'use strict';
+
+var assert = require('assert'),
+    http = require('http');
+
+var error = require('../../lib/error');
+var util = require('../../http/util');
+
+describe('selenium-webdriver/http/util', function() {
+
+  var server, baseUrl;
+
+  var status, value, responseCode;
+
+  function startServer(done) {
+    if (server) return done();
+
+    server = http.createServer(function(req, res) {
+      var data = JSON.stringify({status: status, value: value});
+      res.writeHead(responseCode, {
+        'Content-Type': 'application/json; charset=utf-8',
+        'Content-Length': Buffer.byteLength(data, 'utf8')
+      });
+      res.end(data);
+    });
+
+    server.listen(0, '127.0.0.1', function(e) {
+      if (e) return done(e);
+
+      var addr = server.address();
+      baseUrl = 'http://' + addr.address + ':' + addr.port;
+      done();
+    });
+  }
+
+  function killServer(done) {
+    if (!server) return done();
+    server.close(done);
+    server = null;
+  }
+
+  after(killServer);
+
+  beforeEach(function(done) {
+    status = 0;
+    value = 'abc123';
+    responseCode = 200;
+    startServer(done);
+  });
+
+  describe('#getStatus', function() {
+    it('should return value field on success', function() {
+      return util.getStatus(baseUrl).then(function(response) {
+        assert.equal('abc123', response);
+      });
+    });
+
+    it('should fail if response object is not success', function() {
+      status = 1;
+      return util.getStatus(baseUrl).then(function() {
+        throw Error('expected a failure');
+      }, function(err) {
+        assert.ok(err instanceof error.WebDriverError);
+        assert.equal(err.code, error.WebDriverError.code);
+        assert.equal(err.message, value);
+      });
+    });
+
+    it('should fail if the server is not listening', function(done) {
+      killServer(function(e) {
+        if(e) return done(e);
+
+        util.getStatus(baseUrl).then(function() {
+          done(Error('expected a failure'));
+        }, function() {
+          // Expected.
+          done();
+        });
+      });
+    });
+
+    it('should fail if HTTP status is not 200', function() {
+      status = 1;
+      responseCode = 404;
+      return util.getStatus(baseUrl).then(function() {
+        throw Error('expected a failure');
+      }, function(err) {
+        assert.ok(err instanceof error.WebDriverError);
+        assert.equal(err.code, error.WebDriverError.code);
+        assert.equal(err.message, value);
+      });
+    });
+  });
+
+  describe('#waitForServer', function() {
+    it('resolves when server is ready', function() {
+      status = 1;
+      setTimeout(function() { status = 0; }, 50);
+      return util.waitForServer(baseUrl, 100);
+    });
+
+    it('should fail if server does not become ready', function() {
+      status = 1;
+      return util.waitForServer(baseUrl, 50).
+          then(function() {throw Error('Expected to time out')},
+               function() {});
+    });
+
+    it('can cancel wait', function(done) {
+      status = 1;
+      var err = Error('cancelled!');
+      var isReady =  util.waitForServer(baseUrl, 200).
+          then(function() { done('Did not expect to succeed'); }).
+          then(null, function(e) {
+            assert.equal('cancelled!', e.message);
+          }).
+          then(function() { done(); }, done);
+
+      setTimeout(function() {
+        isReady.cancel('cancelled!');
+      }, 50);
+    });
+  });
+
+  describe('#waitForUrl', function() {
+    it('succeeds when URL returns 2xx', function() {
+      responseCode = 404;
+      setTimeout(function() { responseCode = 200; }, 50);
+
+      return util.waitForUrl(baseUrl, 200);
+    });
+
+    it('fails if URL always returns 4xx', function() {
+      responseCode = 404;
+
+      return util.waitForUrl(baseUrl, 50)
+          .then(() => assert.fail('Expected to time out'),
+                () => true);
+    });
+
+    it('fails if cannot connect to server', function() {
+      return new Promise((resolve, reject) => {
+        killServer(function(e) {
+          if (e) return reject(e);
+
+          util.waitForUrl(baseUrl, 50).
+              then(function() { reject(Error('Expected to time out')); },
+                   function() { resolve(); });
+        });
+      });
+    });
+
+    it('can cancel wait', function(done) {
+      responseCode = 404;
+      var isReady =  util.waitForUrl(baseUrl, 200).
+          then(function() { done('Did not expect to succeed'); }).
+          then(null, function(e) {
+            assert.equal('cancelled!', e.message);
+          }).
+          then(function() { done(); }, done);
+
+      setTimeout(function() {
+        isReady.cancel('cancelled!');
+      }, 50);
+    });
+  });
+});