selenium-webdriver 2.47.0 → 2.52.0

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);
+    });
+  });
+});

package/test/lib/capabilities_test.js

@@ -0,0 +1,84 @@
+// 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';
+
+const Capabilities = require('../../lib/capabilities').Capabilities;
+const Symbols = require('../../lib/symbols');
+
+const assert = require('assert');
+
+describe('Capabilities', function() {
+  it('can set and unset a capability', function() {
+    let caps = new Capabilities();
+    assert.equal(undefined, caps.get('foo'));
+    assert.ok(!caps.has('foo'));
+
+    caps.set('foo', 'bar');
+    assert.equal('bar', caps.get('foo'));
+    assert.ok(caps.has('foo'));
+
+    caps.set('foo', null);
+    assert.equal(null, caps.get('foo'));
+    assert.ok(caps.has('foo'));
+  });
+
+  it('requires string capability keys', function() {
+    let caps = new Capabilities();
+    assert.throws(() => caps.set({}, 'hi'));
+  });
+
+  it('can merge capabilities', function() {
+    let caps1 = new Capabilities()
+        .set('foo', 'bar')
+        .set('color', 'red');
+
+    let caps2 = new Capabilities()
+        .set('color', 'green');
+
+    assert.equal('bar', caps1.get('foo'));
+    assert.equal('red', caps1.get('color'));
+    assert.equal('green', caps2.get('color'));
+    assert.equal(undefined, caps2.get('foo'));
+
+    caps2.merge(caps1);
+    assert.equal('bar', caps1.get('foo'));
+    assert.equal('red', caps1.get('color'));
+    assert.equal('red', caps2.get('color'));
+    assert.equal('bar', caps2.get('foo'));
+  });
+
+  it('can be initialized from a hash object', function() {
+    let caps = new Capabilities({'one': 123, 'abc': 'def'});
+    assert.equal(123, caps.get('one'));
+    assert.equal('def', caps.get('abc'));
+  });
+
+  it('can be initialized from a map', function() {
+    let m = new Map([['one', 123], ['abc', 'def']]);
+
+    let caps = new Capabilities(m);
+    assert.equal(123, caps.get('one'));
+    assert.equal('def', caps.get('abc'));
+  });
+
+  it('can be serialized', function() {
+    let m = new Map([['one', 123], ['abc', 'def']]);
+    let caps = new Capabilities(m);
+    assert.deepEqual({one: 123, abc: 'def'}, caps[Symbols.serialize]());
+  });
+});

package/test/lib/events_test.js

@@ -0,0 +1,177 @@
+// 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';
+
+const EventEmitter = require('../../lib/events').EventEmitter;
+
+const assert = require('assert');
+const sinon = require('sinon');
+
+describe('EventEmitter', function() {
+  describe('#emit()', function() {
+    it('can emit events when nothing is registered', function() {
+      let emitter = new EventEmitter;
+      emitter.emit('foo');
+      // Ok if no errors are thrown.
+    });
+
+    it('can pass args to listeners on emit', function() {
+      let emitter = new EventEmitter;
+      let now = Date.now();
+
+      let messages = [];
+      emitter.on('foo', (arg) => messages.push(arg));
+
+      emitter.emit('foo', now);
+      assert.deepEqual([now], messages);
+
+      emitter.emit('foo', now + 15);
+      assert.deepEqual([now, now + 15], messages);
+    });
+  });
+
+  describe('#addListener()', function() {
+    it('can add multiple listeners for one event', function() {
+      let emitter = new EventEmitter;
+      let count = 0;
+      emitter.addListener('foo', () => count++);
+      emitter.addListener('foo', () => count++);
+      emitter.addListener('foo', () => count++);
+      emitter.emit('foo');
+      assert.equal(3, count);
+    });
+
+    it('only registers each listener function once', function() {
+      let emitter = new EventEmitter;
+      let count = 0;
+      let onFoo = () => count++;
+      emitter.addListener('foo', onFoo);
+      emitter.addListener('foo', onFoo);
+      emitter.addListener('foo', onFoo);
+
+      emitter.emit('foo');
+      assert.equal(1, count);
+
+      emitter.emit('foo');
+      assert.equal(2, count);
+    });
+
+    it('allows users to specify a custom scope', function() {
+      let obj = {
+        count: 0,
+        inc: function() {
+          this.count++;
+        }
+      };
+      let emitter = new EventEmitter;
+      emitter.addListener('foo', obj.inc, obj);
+
+      emitter.emit('foo');
+      assert.equal(1, obj.count);
+
+      emitter.emit('foo');
+      assert.equal(2, obj.count);
+    });
+  });
+
+  describe('#once()', function() {
+    it('only calls registered callback once', function() {
+      let emitter = new EventEmitter;
+      let count = 0;
+      emitter.once('foo', () => count++);
+      emitter.once('foo', () => count++);
+      emitter.once('foo', () => count++);
+
+      emitter.emit('foo');
+      assert.equal(3, count);
+
+      emitter.emit('foo');
+      assert.equal(3, count);
+
+      emitter.emit('foo');
+      assert.equal(3, count);
+    });
+  });
+
+  describe('#removeListeners()', function() {
+    it('only removes the given listener function', function() {
+      let emitter = new EventEmitter;
+      let count = 0;
+      emitter.addListener('foo', () => count++);
+      emitter.addListener('foo', () => count++);
+
+      let toRemove = () => count++;
+      emitter.addListener('foo', toRemove);
+
+      emitter.emit('foo');
+      assert.equal(3, count);
+
+      emitter.removeListener('foo', toRemove);
+      emitter.emit('foo');
+      assert.equal(5, count);
+    });
+  });
+
+  describe('#removeAllListeners()', function() {
+    it('only removes listeners for type if specified', function() {
+      let emitter = new EventEmitter;
+      let count = 0;
+      emitter.addListener('foo', () => count++);
+      emitter.addListener('foo', () => count++);
+      emitter.addListener('foo', () => count++);
+      emitter.addListener('bar', () => count++);
+
+      emitter.emit('foo');
+      assert.equal(3, count);
+
+      emitter.removeAllListeners('foo');
+
+      emitter.emit('foo');
+      assert.equal(3, count);
+
+      emitter.emit('bar');
+      assert.equal(4, count);
+    });
+
+    it('removes absolutely all listeners if no type specified', function() {
+      let emitter = new EventEmitter;
+      let count = 0;
+      emitter.addListener('foo', () => count++);
+      emitter.addListener('bar', () => count++);
+      emitter.addListener('baz', () => count++);
+      emitter.addListener('baz', () => count++);
+
+      emitter.emit('foo');
+      assert.equal(1, count);
+
+      emitter.emit('baz');
+      assert.equal(3, count);
+
+      emitter.removeAllListeners();
+
+      emitter.emit('foo');
+      assert.equal(3, count);
+
+      emitter.emit('bar');
+      assert.equal(3, count);
+
+      emitter.emit('baz');
+      assert.equal(3, count);
+    });
+  });
+});

package/test/lib/logging_test.js

@@ -0,0 +1,272 @@
+// 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';
+
+const assert = require('assert');
+const sinon = require('sinon');
+const logging = require('../../lib/logging');
+
+describe('logging', function() {
+  let mgr, root, clock;
+
+  beforeEach(function setUp() {
+    mgr = new logging.LogManager;
+    root = mgr.getLogger('');
+
+    clock = sinon.useFakeTimers();
+  });
+
+  afterEach(function tearDown() {
+    clock.restore();
+  });
+
+  describe('LogManager', function() {
+    describe('getLogger()', function() {
+      it('handles falsey input', function() {
+        assert.strictEqual(root, mgr.getLogger());
+        assert.strictEqual(root, mgr.getLogger(''));
+        assert.strictEqual(root, mgr.getLogger(null));
+        assert.strictEqual(root, mgr.getLogger(0));
+      });
+
+      it('creates parent loggers', function() {
+        let logger = mgr.getLogger('foo.bar.baz');
+        assert.strictEqual(logger.parent_, mgr.getLogger('foo.bar'));
+
+        logger = logger.parent_;
+        assert.strictEqual(logger.parent_, mgr.getLogger('foo'));
+
+        logger = logger.parent_;
+        assert.strictEqual(logger.parent_, mgr.getLogger(''));
+
+        assert.strictEqual(logger.parent_.parent_, null);
+      });
+    });
+  });
+
+  describe('Logger', function() {
+    describe('getEffectiveLevel()', function() {
+      it('defaults to OFF', function() {
+        assert.strictEqual(root.getLevel(), logging.Level.OFF);
+        assert.strictEqual(root.getEffectiveLevel(), logging.Level.OFF);
+
+        root.setLevel(null);
+        assert.strictEqual(root.getLevel(), null);
+        assert.strictEqual(root.getEffectiveLevel(), logging.Level.OFF);
+      });
+
+      it('uses own level if set', function() {
+        let logger = mgr.getLogger('foo.bar.baz');
+        assert.strictEqual(logger.getLevel(), null);
+        assert.strictEqual(logger.getEffectiveLevel(), logging.Level.OFF);
+
+        logger.setLevel(logging.Level.INFO);
+        assert.strictEqual(logger.getLevel(), logging.Level.INFO);
+        assert.strictEqual(logger.getEffectiveLevel(), logging.Level.INFO);
+      });
+
+      it('uses level from set on nearest parent', function() {
+        let ancestor = mgr.getLogger('foo');
+        ancestor.setLevel(logging.Level.SEVERE);
+
+        let logger = mgr.getLogger('foo.bar.baz');
+        assert.strictEqual(logger.getLevel(), null);
+        assert.strictEqual(logger.getEffectiveLevel(), logging.Level.SEVERE);
+      });
+    });
+
+    describe('isLoggable()', function() {
+      it('compares level against logger\'s effective level', function() {
+        const log1 = mgr.getLogger('foo');
+        log1.setLevel(logging.Level.WARNING);
+
+        const log2 = mgr.getLogger('foo.bar.baz');
+
+        assert(!log2.isLoggable(logging.Level.FINEST));
+        assert(!log2.isLoggable(logging.Level.INFO));
+        assert(log2.isLoggable(logging.Level.WARNING));
+        assert(log2.isLoggable(logging.Level.SEVERE));
+
+        log2.setLevel(logging.Level.INFO);
+
+        assert(!log2.isLoggable(logging.Level.FINEST));
+        assert(log2.isLoggable(logging.Level.INFO));
+        assert(log2.isLoggable(logging.Level.WARNING));
+        assert(log2.isLoggable(logging.Level.SEVERE));
+
+        log2.setLevel(logging.Level.ALL);
+
+        assert(log2.isLoggable(logging.Level.FINEST));
+        assert(log2.isLoggable(logging.Level.INFO));
+        assert(log2.isLoggable(logging.Level.WARNING));
+        assert(log2.isLoggable(logging.Level.SEVERE));
+      });
+
+      it('Level.OFF is never loggable', function() {
+        function test(level) {
+          root.setLevel(level);
+          assert(!root.isLoggable(logging.Level.OFF),
+              'OFF should not be loggable at ' + level);
+        }
+
+        test(logging.Level.ALL);
+        test(logging.Level.INFO);
+        test(logging.Level.OFF);
+      });
+    });
+
+    describe('log()', function() {
+      it('does not invoke loggable if message is not loggable', function() {
+        const log = mgr.getLogger('foo');
+        log.setLevel(logging.Level.OFF);
+
+        let callback = sinon.spy();
+        log.addHandler(callback);
+        root.addHandler(callback);
+
+        assert(!callback.called);
+      });
+
+      it('invokes handlers for each parent logger', function() {
+        const cb1 = sinon.spy();
+        const cb2 = sinon.spy();
+        const cb3 = sinon.spy();
+        const cb4 = sinon.spy();
+
+        const log1 = mgr.getLogger('foo');
+        const log2 = mgr.getLogger('foo.bar');
+        const log3 = mgr.getLogger('foo.bar.baz');
+        const log4 = mgr.getLogger('foo.bar.baz.quot');
+
+        log1.addHandler(cb1);
+        log1.setLevel(logging.Level.INFO);
+
+        log2.addHandler(cb2);
+        log2.setLevel(logging.Level.WARNING);
+
+        log3.addHandler(cb3);
+        log3.setLevel(logging.Level.FINER);
+
+        clock.tick(123456);
+
+        log4.finest('this is the finest message');
+        log4.finer('this is a finer message');
+        log4.info('this is an info message');
+        log4.warning('this is a warning message');
+        log4.severe('this is a severe message');
+
+        assert.equal(4, cb1.callCount);
+        assert.equal(4, cb2.callCount);
+        assert.equal(4, cb3.callCount);
+
+        const entry1 = new logging.Entry(
+            logging.Level.FINER,
+            '[foo.bar.baz.quot] this is a finer message',
+            123456);
+        const entry2 = new logging.Entry(
+            logging.Level.INFO,
+            '[foo.bar.baz.quot] this is an info message',
+            123456);
+        const entry3 = new logging.Entry(
+            logging.Level.WARNING,
+            '[foo.bar.baz.quot] this is a warning message',
+            123456);
+        const entry4 = new logging.Entry(
+            logging.Level.SEVERE,
+            '[foo.bar.baz.quot] this is a severe message',
+            123456);
+
+        check(cb1.getCall(0).args[0], entry1);
+        check(cb1.getCall(1).args[0], entry2);
+        check(cb1.getCall(2).args[0], entry3);
+        check(cb1.getCall(3).args[0], entry4);
+
+        check(cb2.getCall(0).args[0], entry1);
+        check(cb2.getCall(1).args[0], entry2);
+        check(cb2.getCall(2).args[0], entry3);
+        check(cb2.getCall(3).args[0], entry4);
+
+        check(cb3.getCall(0).args[0], entry1);
+        check(cb3.getCall(1).args[0], entry2);
+        check(cb3.getCall(2).args[0], entry3);
+        check(cb3.getCall(3).args[0], entry4);
+
+        function check(entry, expected) {
+          assert.equal(entry.level, expected.level, 'wrong level');
+          assert.equal(entry.message, expected.message, 'wrong message');
+          assert.equal(entry.timestamp, expected.timestamp, 'wrong time');
+        }
+      });
+
+      it('does not invoke removed handler', function() {
+        root.setLevel(logging.Level.INFO);
+        const cb = sinon.spy();
+
+        root.addHandler(cb);
+        root.info('hi');
+        assert.equal(1, cb.callCount);
+
+        assert(root.removeHandler(cb));
+        root.info('bye');
+        assert.equal(1, cb.callCount);
+
+        assert(!root.removeHandler(cb));
+      });
+    });
+  });
+
+  describe('getLevel()', function() {
+    it('converts named levels', function() {
+      assert.strictEqual(logging.Level.DEBUG, logging.getLevel('DEBUG'));
+      assert.strictEqual(logging.Level.ALL, logging.getLevel('FAKE'));
+    });
+
+    it('converts numeric levels', function() {
+      assert.strictEqual(
+          logging.Level.DEBUG,
+          logging.getLevel(logging.Level.DEBUG.value));
+    });
+
+    it('normalizes numeric levels', function() {
+      assert.strictEqual(
+          logging.Level.OFF,
+          logging.getLevel(logging.Level.OFF.value * 2));
+
+      let diff = logging.Level.SEVERE.value - logging.Level.WARNING.value;
+      assert.strictEqual(
+          logging.Level.WARNING,
+          logging.getLevel(logging.Level.WARNING.value + (diff * .5)));
+
+      assert.strictEqual(logging.Level.ALL, logging.getLevel(0));
+      assert.strictEqual(logging.Level.ALL, logging.getLevel(-1));
+    });
+  });
+
+  describe('Preferences', function() {
+    it('can be converted to JSON', function() {
+      let prefs = new logging.Preferences;
+      assert.equal('{}', JSON.stringify(prefs));
+
+      prefs.setLevel('foo', logging.Level.DEBUG);
+      assert.equal('{"foo":"DEBUG"}', JSON.stringify(prefs));
+
+      prefs.setLevel(logging.Type.BROWSER, logging.Level.FINE);
+      assert.equal('{"foo":"DEBUG","browser":"FINE"}', JSON.stringify(prefs));
+    });
+  });
+});