selenium-webdriver 2.48.2 → 2.52.0

package/test/http/http_test.js

@@ -15,15 +15,284 @@
 // specific language governing permissions and limitations
 // under the License.
 
+'use strict';
+
 var assert = require('assert');
 var http = require('http');
+var sinon = require('sinon');
 var url = require('url');
 
+var error = require('../../error');
+var Executor = require('../../http').Executor;
 var HttpClient = require('../../http').HttpClient;
-var HttpRequest = require('../../_base').require('webdriver.http.Request');
+var HttpRequest = require('../../http').Request;
+var HttpResponse = require('../../http').Response;
+var buildPath = require('../../http').buildPath;
+var Command = require('../../lib/command').Command;
+var CommandName = require('../../lib/command').Name;
 var Server = require('../../lib/test/httpserver').Server;
 var promise = require('../..').promise;
-var test = require('../../lib/test');
+
+describe('buildPath', function() {
+  it('properly replaces path segments with command parameters', function() {
+    var parameters = {'sessionId':'foo', 'url':'http://www.google.com'};
+    var finalPath = buildPath('/session/:sessionId/url', parameters);
+    assert.equal(finalPath, '/session/foo/url');
+    assert.deepEqual(parameters,  {'url':'http://www.google.com'});
+  });
+
+  it('handles web element references', function() {
+    var parameters = {'sessionId':'foo', 'id': {}};
+    parameters['id']['ELEMENT'] = 'bar';
+
+    var finalPath = buildPath(
+        '/session/:sessionId/element/:id/click', parameters);
+    assert.equal(finalPath, '/session/foo/element/bar/click');
+    assert.deepEqual(parameters, {});
+  });
+
+  it('throws if missing a parameter', function() {
+    assert.throws(
+      () => buildPath('/session/:sessionId', {}),
+      function(err) {
+        return err instanceof error.InvalidArgumentError
+            && 'Missing required parameter: sessionId' === err.message;
+      });
+
+    assert.throws(
+      () => buildPath('/session/:sessionId/element/:id', {'sessionId': 'foo'}),
+      function(err) {
+        return err instanceof error.InvalidArgumentError
+            && 'Missing required parameter: id' === err.message;
+      });
+  });
+
+  it('does not match on segments that do not start with a colon', function() {
+    assert.equal(buildPath('/session/foo:bar/baz', {}), '/session/foo:bar/baz');
+  });
+});
+
+describe('Executor', function() {
+  let executor;
+  let send;
+
+  beforeEach(function setUp() {
+    let client = new HttpClient('http://www.example.com');
+    send = sinon.stub(client, 'send');
+    executor = new Executor(client);
+  });
+
+  it('rejects unrecognized commands', function() {
+    assert.throws(
+        () => executor.execute(new Command('fake-name')),
+        function (err) {
+          return err instanceof error.UnknownCommandError
+              && 'Unrecognized command: fake-name' === err.message;
+        });
+  });
+
+  it('rejects promise if client fails to send request', function() {
+    let error = new Error('boom');
+    send.returns(Promise.reject(error));
+    return assertFailsToSend(new Command(CommandName.NEW_SESSION))
+        .then(function(e) {
+           assert.strictEqual(error, e);
+           assertSent(
+               'POST', '/session', {},
+               [['Accept', 'application/json; charset=utf-8']]);
+        });
+  });
+
+  it('can execute commands with no URL parameters', function() {
+    send.returns(Promise.resolve(new HttpResponse(200, {}, '')));
+
+    let command = new Command(CommandName.NEW_SESSION);
+    return assertSendsSuccessfully(command).then(function(response) {
+       assertSent(
+           'POST', '/session', {},
+           [['Accept', 'application/json; charset=utf-8']]);
+    });
+  });
+
+  it('rejects commands missing URL parameters', function() {
+    let command =
+        new Command(CommandName.FIND_CHILD_ELEMENT).
+            setParameter('sessionId', 's123').
+            // Let this be missing: setParameter('id', {'ELEMENT': 'e456'}).
+            setParameter('using', 'id').
+            setParameter('value', 'foo');
+
+    assert.throws(
+        () => executor.execute(command),
+        function(err) {
+          return err instanceof error.InvalidArgumentError
+              && 'Missing required parameter: id' === err.message;
+        });
+    assert.ok(!send.called);
+  });
+
+  it('replaces URL parameters with command parameters', function() {
+    var command = new Command(CommandName.GET).
+        setParameter('sessionId', 's123').
+        setParameter('url', 'http://www.google.com');
+
+    send.returns(Promise.resolve(new HttpResponse(200, {}, '')));
+
+    return assertSendsSuccessfully(command).then(function(response) {
+       assertSent(
+           'POST', '/session/s123/url', {'url': 'http://www.google.com'},
+           [['Accept', 'application/json; charset=utf-8']]);
+    });
+  });
+
+  it('returns parsed JSON response', function() {
+    var responseObj = {
+      'status': error.ErrorCode.SUCCESS,
+      'value': 'http://www.google.com'
+    };
+
+    var command = new Command(CommandName.GET_CURRENT_URL).
+        setParameter('sessionId', 's123');
+
+
+    send.returns(Promise.resolve(
+        new HttpResponse(200, {}, JSON.stringify(responseObj))));
+
+    return assertSendsSuccessfully(command).then(function(response) {
+       assertSent('GET', '/session/s123/url', {},
+           [['Accept', 'application/json; charset=utf-8']]);
+       assert.deepEqual(response, responseObj);
+    });
+  });
+
+  it('returns success for 2xx with body as value when not json', function() {
+    var command = new Command(CommandName.GET_CURRENT_URL).
+        setParameter('sessionId', 's123');
+
+    send.returns(Promise.resolve(
+        new HttpResponse(200, {}, 'hello, world\r\ngoodbye, world!')));
+
+    return assertSendsSuccessfully(command).then(function(response) {
+       assertSent('GET', '/session/s123/url', {},
+           [['Accept', 'application/json; charset=utf-8']]);
+       assert.deepEqual(response, {
+         'status': error.ErrorCode.SUCCESS,
+         'value': 'hello, world\ngoodbye, world!'
+       });
+    });
+  });
+
+  it('returns success for 2xx with invalid JSON body', function() {
+    var command = new Command(CommandName.GET_CURRENT_URL).
+        setParameter('sessionId', 's123');
+
+    send.returns(Promise.resolve(
+        new HttpResponse(200, {}, '[')));
+
+    return assertSendsSuccessfully(command).then(function(response) {
+       assertSent('GET', '/session/s123/url', {},
+           [['Accept', 'application/json; charset=utf-8']]);
+       assert.deepEqual(response, {
+         'status': error.ErrorCode.SUCCESS,
+         'value': '['
+       });
+    });
+  });
+
+  it('returns unknown command for 404 with body as value when not json',
+      function() {
+        var command = new Command(CommandName.GET_CURRENT_URL).
+            setParameter('sessionId', 's123');
+
+        send.returns(Promise.resolve(
+            new HttpResponse(404, {}, 'hello, world\r\ngoodbye, world!')));
+
+        return assertSendsSuccessfully(command, function(response) {
+           assertSent('GET', '/session/s123/url', {},
+               [['Accept', 'application/json; charset=utf-8']]);
+           assert.deepEqual(response, {
+             'status': error.ErrorCode.UNKNOWN_COMMAND,
+             'value': 'hello, world\ngoodbye, world!'
+           });
+      });
+     });
+
+  it('returnsUnknownErrorForGenericErrorCodeWithBodyAsValueWhenNotJSON',
+      function() {
+        var command = new Command(CommandName.GET_CURRENT_URL).
+            setParameter('sessionId', 's123');
+
+        send.returns(Promise.resolve(
+            new HttpResponse(500, {}, 'hello, world\r\ngoodbye, world!')));
+
+        return assertSendsSuccessfully(command).then(function(response) {
+           assertSent('GET', '/session/s123/url', {},
+               [['Accept', 'application/json; charset=utf-8']]);
+           assert.deepEqual(response, {
+             'status': error.ErrorCode.UNKNOWN_ERROR,
+             'value': 'hello, world\ngoodbye, world!'
+           });
+        });
+      });
+
+  it('canDefineNewCommands', function() {
+    executor.defineCommand('greet', 'GET', '/person/:name');
+
+    var command = new Command('greet').
+        setParameter('name', 'Bob');
+
+    send.returns(Promise.resolve(new HttpResponse(200, {}, '')));
+
+    return assertSendsSuccessfully(command).then(function(response) {
+       assertSent('GET', '/person/Bob', {},
+           [['Accept', 'application/json; charset=utf-8']]);
+    });
+  });
+
+  it('canRedefineStandardCommands', function() {
+    executor.defineCommand(CommandName.GO_BACK, 'POST', '/custom/back');
+
+    var command = new Command(CommandName.GO_BACK).
+        setParameter('times', 3);
+
+    send.returns(Promise.resolve(new HttpResponse(200, {}, '')));
+
+    return assertSendsSuccessfully(command).then(function(response) {
+       assertSent('POST', '/custom/back', {'times': 3},
+           [['Accept', 'application/json; charset=utf-8']]);
+    });
+  });
+
+  function entries(map) {
+    let entries = [];
+    for (let e of map.entries()) {
+      entries.push(e);
+    }
+    return entries;
+  }
+
+  function assertSent(method, path, data, headers) {
+    assert.ok(send.calledWith(sinon.match(function(value) {
+      assert.equal(value.method, method);
+      assert.equal(value.path, path);
+      assert.deepEqual(value.data, data);
+      assert.deepEqual(entries(value.headers), headers);
+      return true;
+    })));
+  }
+
+  function assertSendsSuccessfully(command) {
+    return executor.execute(command).then(function(response) {
+      return response;
+    });
+  }
+
+  function assertFailsToSend(command, opt_onError) {
+    return executor.execute(command).then(
+        () => {throw Error('should have failed')},
+        (e) => {return e});
+  }
+});
 
 describe('HttpClient', function() {
   this.timeout(4 * 1000);
@@ -83,99 +352,92 @@ describe('HttpClient', function() {
     }
   });
 
-  test.before(function() {
+  before(function() {
     return server.start();
   });
 
-  test.after(function() {
+  after(function() {
     return server.stop();
   });
 
-  test.it('can send a basic HTTP request', function() {
+  it('can send a basic HTTP request', function() {
     var request = new HttpRequest('GET', '/echo');
-    request.headers['Foo'] = 'Bar';
+    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 promise.checkedNodeCall(client.send.bind(client, request))
-        .then(function(response) {
-          assert.equal(200, response.status);
-          assert.equal(
-            'application/json; charset=utf-8', response.headers['accept']);
-          assert.equal('Bar', response.headers['foo']);
-          assert.equal('0', response.headers['content-length']);
-          assert.equal('keep-alive', response.headers['connection']);
-          assert.equal(server.host(), response.headers['host']);
-        });
+    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');
+    });
   });
 
-  test.it('can use basic auth', function() {
+  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 promise.checkedNodeCall(client.send.bind(client, request))
-      .then(function(response) {
-        assert.equal(200, response.status);
-        assert.equal('text/plain', response.headers['content-type']);
-        assert.equal('Access granted!', response.body);
-      });
+    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!');
+    });
   });
 
-  test.it('fails requests missing required basic auth', function() {
+  it('fails requests missing required basic auth', function() {
     var client = new HttpClient(server.url());
     var request = new HttpRequest('GET', '/protected');
-    return promise.checkedNodeCall(client.send.bind(client, request))
-      .then(function(response) {
-              assert.equal(401, response.status);
-              assert.equal('Access denied', response.body);
-            });
+    return client.send(request).then(function(response) {
+      assert.equal(401, response.status);
+      assert.equal(response.body, 'Access denied');
+    });
   });
 
-  test.it('automatically follows redirects', function() {
+  it('automatically follows redirects', function() {
     var request = new HttpRequest('GET', '/redirect');
     var client = new HttpClient(server.url());
-    return promise.checkedNodeCall(client.send.bind(client, request))
-        .then(function(response) {
-          assert.equal(200, response.status);
-          assert.equal('text/plain', response.headers['content-type']);
-          assert.equal('hello, world!', response.body);
-        });
+    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!');
+    });
   });
 
-  test.it('handles malformed redirect responses', function() {
+  it('handles malformed redirect responses', function() {
     var request = new HttpRequest('GET', '/badredirect');
     var client = new HttpClient(server.url());
-    return promise.checkedNodeCall(client.send.bind(client, request))
-        .thenCatch(function(err) {
-          assert.ok(/Failed to parse "Location"/.test(err.message),
-              'Not the expected error: ' + err.message);
-        });
+    return client.send(request).then(assert.fail, function(err) {
+      assert.ok(/Failed to parse "Location"/.test(err.message),
+          'Not the expected error: ' + err.message);
+    });
   });
 
-  test.it('proxies requests through the webdriver proxy', function() {
+  it('proxies requests through the webdriver proxy', function() {
     var request = new HttpRequest('GET', '/proxy');
     var client = new HttpClient(
         'http://another.server.com', undefined, server.url());
-    return promise.checkedNodeCall(client.send.bind(client, request))
-        .then(function(response) {
-           assert.equal(200, response.status);
-           assert.equal('another.server.com', response.headers['host']);
-        });
+    return client.send(request).then(function(response) {
+       assert.equal(200, response.status);
+       assert.equal(response.headers.get('host'), 'another.server.com');
+    });
   });
 
-  test.it(
-      'proxies requests through the webdriver proxy on redirect', function() {
+  it('proxies requests through the webdriver proxy on redirect', function() {
     var request = new HttpRequest('GET', '/proxy/redirect');
     var client = new HttpClient(
         'http://another.server.com', undefined, server.url());
-    return promise.checkedNodeCall(client.send.bind(client, request))
-        .then(function(response) {
-          assert.equal(200, response.status);
-          assert.equal('another.server.com', response.headers['host']);
-        });
+    return client.send(request).then(function(response) {
+      assert.equal(200, response.status);
+      assert.equal(response.headers.get('host'), 'another.server.com');
+    });
   });
 });

package/test/http/util_test.js

@@ -20,6 +20,7 @@
 var assert = require('assert'),
     http = require('http');
 
+var error = require('../../error');
 var util = require('../../http/util');
 
 describe('selenium-webdriver/http/util', function() {
@@ -65,20 +66,21 @@ describe('selenium-webdriver/http/util', function() {
   });
 
   describe('#getStatus', function() {
-    it('should return value field on success', function(done) {
-      util.getStatus(baseUrl).then(function(response) {
+    it('should return value field on success', function() {
+      return util.getStatus(baseUrl).then(function(response) {
         assert.equal('abc123', response);
-      }).thenFinally(done);
+      });
     });
 
-    it('should fail if response object is not success', function(done) {
+    it('should fail if response object is not success', function() {
       status = 1;
-      util.getStatus(baseUrl).then(function() {
+      return util.getStatus(baseUrl).then(function() {
         throw Error('expected a failure');
       }, function(err) {
-        assert.equal(status, err.code);
-        assert.equal(value, err.message);
-      }).thenFinally(done);
+        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) {
@@ -86,39 +88,39 @@ describe('selenium-webdriver/http/util', function() {
         if(e) return done(e);
 
         util.getStatus(baseUrl).then(function() {
-          throw Error('expected a failure');
+          done(Error('expected a failure'));
         }, function() {
           // Expected.
-        }).thenFinally(done);
+          done();
+        });
       });
     });
 
-    it('should fail if HTTP status is not 200', function(done) {
+    it('should fail if HTTP status is not 200', function() {
       status = 1;
       responseCode = 404;
-      util.getStatus(baseUrl).then(function() {
+      return util.getStatus(baseUrl).then(function() {
         throw Error('expected a failure');
       }, function(err) {
-        assert.equal(status, err.code);
-        assert.equal(value, err.message);
-      }).thenFinally(done);
+        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(done) {
+    it('resolves when server is ready', function() {
       status = 1;
       setTimeout(function() { status = 0; }, 50);
-      util.waitForServer(baseUrl, 100).
-          then(function() {}).  // done needs no argument to pass.
-          thenFinally(done);
+      return util.waitForServer(baseUrl, 100);
     });
 
-    it('should fail if server does not become ready', function(done) {
+    it('should fail if server does not become ready', function() {
       status = 1;
-      util.waitForServer(baseUrl, 50).
-          then(function() { done('Expected to time out'); },
-               function() { done(); });
+      return util.waitForServer(baseUrl, 50).
+          then(function() {throw Error('Expected to time out')},
+               function() {});
     });
 
     it('can cancel wait', function(done) {

package/test/io_test.js

@@ -37,7 +37,6 @@ describe('io', function() {
         tmpDir = d;
 
         fs.writeFileSync(path.join(d, 'foo'), 'Hello, world');
-        fs.symlinkSync(path.join(d, 'foo'), path.join(d, 'symlinked-foo'));
       });
     });
 
@@ -51,6 +50,12 @@ describe('io', function() {
     });
 
     it('can copy symlink to destination', function() {
+      if (process.platform === 'win32') {
+        return;  // No symlinks on windows.
+      }
+      fs.symlinkSync(
+          path.join(tmpDir, 'foo'),
+          path.join(tmpDir, 'symlinked-foo'));
       return io.tmpFile().then(function(f) {
         return io.copy(path.join(tmpDir, 'symlinked-foo'), f).then(function(p) {
           assert.equal(p, f);

package/test/lib/by_test.js

@@ -0,0 +1,127 @@
+// 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');
+var by = require('../../lib/by');
+
+describe('by', function() {
+  describe('By', function() {
+    describe('className', function() {
+      it('delegates to By.css', function() {
+        let locator = by.By.className('foo');
+        assert.equal('css selector', locator.using);
+        assert.equal('.foo', locator.value);
+      });
+
+      it('escapes class name', function() {
+        let locator = by.By.className('foo#bar');
+        assert.equal('css selector', locator.using);
+        assert.equal('.foo\\#bar', locator.value);
+      });
+
+      it('translates compound class names', function() {
+        let locator = by.By.className('a b');
+        assert.equal('css selector', locator.using);
+        assert.equal('.a.b', locator.value);
+
+        locator = by.By.className('  x   y   z-1  "g" ');
+        assert.equal('css selector', locator.using);
+        assert.equal('.x.y.z-1.\\"g\\"', locator.value);
+      });
+    });
+
+    describe('id', function() {
+      it('delegates to By.css', function() {
+        let locator = by.By.id('foo');
+        assert.equal('css selector', locator.using);
+        assert.equal('*[id="foo"]', locator.value);
+      });
+
+      it('escapes the ID', function() {
+        let locator = by.By.id('foo#bar');
+        assert.equal('css selector', locator.using);
+        assert.equal('*[id="foo\\#bar"]', locator.value);
+      });
+    });
+
+    describe('name', function() {
+      it('delegates to By.css', function() {
+        let locator = by.By.name('foo')
+        assert.equal('css selector', locator.using);
+        assert.equal('*[name="foo"]', locator.value);
+      });
+
+      it('escapes the name', function() {
+        let locator = by.By.name('foo"bar"')
+        assert.equal('css selector', locator.using);
+        assert.equal('*[name="foo\\"bar\\""]', locator.value);
+      });
+    });
+  });
+
+  describe('checkedLocator', function() {
+    it('accepts class name', function() {
+      let locator = by.checkedLocator({className: 'foo'});
+      assert.equal('css selector', locator.using);
+      assert.equal('.foo', locator.value);
+    });
+
+    it('accepts css', function() {
+      let locator = by.checkedLocator({css: 'a > b'});
+      assert.equal('css selector', locator.using);
+      assert.equal('a > b', locator.value);
+    });
+
+    it('accepts id', function() {
+      let locator = by.checkedLocator({id: 'foobar'});
+      assert.equal('css selector', locator.using);
+      assert.equal('*[id="foobar"]', locator.value);
+    });
+
+    it('accepts linkText', function() {
+      let locator = by.checkedLocator({linkText: 'hello'});
+      assert.equal('link text', locator.using);
+      assert.equal('hello', locator.value);
+    });
+
+    it('accepts name', function() {
+      let locator = by.checkedLocator({name: 'foobar'});
+      assert.equal('css selector', locator.using);
+      assert.equal('*[name="foobar"]', locator.value);
+    });
+
+    it('accepts partialLinkText', function() {
+      let locator = by.checkedLocator({partialLinkText: 'hello'});
+      assert.equal('partial link text', locator.using);
+      assert.equal('hello', locator.value);
+    });
+
+    it('accepts tagName', function() {
+      let locator = by.checkedLocator({tagName: 'div'});
+      assert.equal('css selector', locator.using);
+      assert.equal('div', locator.value);
+    });
+
+    it('accepts xpath', function() {
+      let locator = by.checkedLocator({xpath: '//div[1]'});
+      assert.equal('xpath', locator.using);
+      assert.equal('//div[1]', locator.value);
+    });
+  });
+});