selenium-webdriver 3.3.0 → 4.0.0-alpha.1

package/test/testing/assert_test.js

@@ -1,373 +0,0 @@
-// 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('../../testing/assert');
-
-const AssertionError = require('assert').AssertionError;
-const assertTrue = require('assert').ok;
-const assertEqual = require('assert').equal;
-const assertThrows = require('assert').throws;
-const fail = require('assert').fail;
-
-
-describe('assert', function() {
-  describe('atLeast', function() {
-    it('compares subject >= value', function() {
-      assert(1).atLeast(0);
-      assert(1).atLeast(1);
-      assertThrows(() => assert(1).atLeast(2));
-    });
-
-    it('accepts failure message', function() {
-      assertThrows(
-          () => assert(1).atLeast(2, 'hi there!'),
-          (error) => error.message.indexOf('hi there') != -1);
-    });
-
-    it('fails if given a non-numeric subject', function() {
-      assertThrows(() => assert('a').atLeast(1));
-    });
-
-    it('fails if given a non-numeric bound', function() {
-      assertThrows(() => assert(1).atLeast('a'));
-    });
-
-    it('waits for promised subject', function() {
-      return assert(Promise.resolve(123)).atLeast(100);
-    });
-
-    it('waits for promised subject (with failure)', function() {
-      return assert(Promise.resolve(100))
-          .atLeast(123)
-          .then(() => fail('should have failed'), function(e) {
-            assertInstanceOf(AssertionError, e);
-            assertEqual('100 >= 123', e.message);
-          });
-    });
-  });
-
-  describe('atMost', function() {
-    it('compares subject <= value', function() {
-      assertThrows(() => assert(1).atMost(0));
-      assert(1).atMost(1);
-      assert(1).atMost(2);
-    });
-
-    it('accepts failure message', function() {
-      assertThrows(
-          () => assert(1).atMost(0, 'hi there!'),
-          (error) => error.message.indexOf('hi there!') != -1);
-    });
-
-    it('fails if given a non-numeric subject', function() {
-      assertThrows(() => assert(1).atMost('a'));
-    });
-
-    it('fails if given a non-numeric bound', function() {
-      assertThrows(() => assert('a').atMost(1));
-    });
-
-    it('waits for promised subject', function() {
-      return assert(Promise.resolve(100)).atMost(123);
-    });
-
-    it('waits for promised subject (with failure)', function() {
-      return assert(Promise.resolve(123))
-          .atMost(100)
-          .then(() => fail('should have failed'), function(e) {
-            assertInstanceOf(AssertionError, e);
-            assertEqual('123 <= 100', e.message);
-          });
-    });
-  });
-
-  describe('greaterThan', function() {
-    it('compares subject > value', function() {
-      assertThrows(() => assert(1).greaterThan(1));
-      assertThrows(() => assert(1).greaterThan(2));
-      assert(2).greaterThan(1);
-    });
-
-    it('accepts failure message', function() {
-      assertThrows(
-          () => assert(0).greaterThan(1, 'hi there!'),
-          (error) => error.message.indexOf('hi there!') != -1);
-    });
-
-    it('fails if given a non-numeric subject', function() {
-      assertThrows(() => assert('a').atMost(1));
-    });
-
-    it('fails if given a non-numeric bound', function() {
-      assertThrows(() => assert(1).atMost('a'));
-    });
-
-    it('waits for promised subject', function() {
-      return assert(Promise.resolve(123)).greaterThan(100);
-    });
-
-    it('waits for promised subject (with failure)', function() {
-      return assert(Promise.resolve(100))
-          .greaterThan(123)
-          .then(() => fail('should have failed'), function(e) {
-            assertInstanceOf(AssertionError, e);
-            assertEqual('100 > 123', e.message);
-          });
-    });
-  });
-
-  describe('lessThan', function() {
-    it('compares subject < value', function() {
-      assertThrows(() => assert(1).lessThan(0));
-      assertThrows(() => assert(1).lessThan(1));
-      assert(1).lessThan(2);
-    });
-
-    it('accepts failure message', function() {
-      assertThrows(
-          () => assert(1).lessThan(0, 'hi there!'),
-          (error) => error.message.indexOf('hi there!') != -1);
-    });
-
-    it('fails if given a non-numeric subject', function() {
-      assertThrows(() => assert('a').lessThan(1));
-    });
-
-    it('fails if given a non-numeric bound', function() {
-      assertThrows(() => assert(1).lessThan('a'));
-    });
-
-    it('waits for promised subject', function() {
-      return assert(Promise.resolve(100)).lessThan(123);
-    });
-
-    it('waits for promised subject (with failure)', function() {
-      return assert(Promise.resolve(123))
-          .lessThan(100)
-          .then(() => fail('should have failed'), function(e) {
-            assertInstanceOf(AssertionError, e);
-            assertEqual('123 < 100', e.message);
-          });
-    });
-  });
-
-  describe('closeTo', function() {
-    it('accepts values within epislon of target', function() {
-      assert(123).closeTo(123, 0);
-      assert(123).closeTo(124, 1);
-      assert(125).closeTo(124, 1);
-
-      assertThrows(() => assert(123).closeTo(125, .1));
-      assertThrows(() => assert(1./3).closeTo(.8, .01));
-    });
-
-    it('waits for promised values', function() {
-      let p = new Promise(resolve => setTimeout(() => resolve(123), 10));
-      return assert(p).closeTo(124, 1);
-    });
-  });
-
-  describe('instanceOf', function() {
-    it('works with direct instances', function() {
-      assert(Error('foo')).instanceOf(Error);
-    });
-
-    it('works with sub-types', function() {
-      assert(TypeError('foo')).instanceOf(Error);
-    });
-
-    it('parent types are not instances of sub-types', function() {
-      assertThrows(() => assert(Error('foo')).instanceOf(TypeError));
-    });
-  });
-
-  describe('isNull', function() {
-    it('normal case', function() {
-      assert(null).isNull();
-      assertThrows(() => assert(1).isNull());
-    });
-
-    it('handles promised values', function() {
-      let p = new Promise(function(f) {
-        setTimeout(() => f(null), 10);
-      });
-      return assert(p).isNull();
-    });
-
-    it('does not match on undefined', function() {
-      assertThrows(() => assert(void(0)).isNull());
-    })
-  });
-
-  describe('isUndefined', function() {
-    it('normal case', function() {
-      assert(void(0)).isUndefined();
-      assertThrows(() => assert(1).isUndefined());
-    });
-
-    it('handles promised values', function() {
-      let p = new Promise(function(f) {
-        setTimeout(() => f(void(0)), 10);
-      });
-      return assert(p).isUndefined();
-    });
-
-    it('does not match on null', function() {
-      assertThrows(() => assert(null).isUndefined());
-    })
-  });
-
-  describe('contains', function() {
-    it('works with strings', function() {
-      assert('abc').contains('a');
-      assert('abc').contains('ab');
-      assert('abc').contains('abc');
-      assert('abc').contains('bc');
-      assert('abc').contains('c');
-      assertThrows(() => assert('abc').contains('d'));
-    });
-
-    it('works with arrays', function() {
-      assert([1, 2, 3]).contains(1);
-      assert([1, 2, 3]).contains(2);
-      assert([1, 2, 3]).contains(3);
-      assertThrows(() => assert([1, 2]).contains(3));
-    });
-
-    it('works with maps', function() {
-      let m = new Map;
-      m.set(1, 2);
-      assert(m).contains(1);
-      assertThrows(() => assert(m).contains(2));
-    });
-
-    it('works with sets', function() {
-      let s = new Set;
-      s.add(1);
-      assert(s).contains(1);
-      assertThrows(() => assert(s).contains(2));
-    });
-
-    it('requires an array, string, map, or set subject', function() {
-      assertThrows(() => assert(123).contains('a'));
-    });
-  });
-
-  describe('endsWith', function() {
-    it('works', function() {
-      assert('abc').endsWith('abc');
-      assert('abc').endsWith('bc');
-      assert('abc').endsWith('c');
-      assertThrows(() => assert('abc').endsWith('d'));
-    })
-  });
-
-  describe('startsWith', function() {
-    it('works', function() {
-      assert('abc').startsWith('abc');
-      assert('abc').startsWith('ab');
-      assert('abc').startsWith('a');
-      assertThrows(() => assert('abc').startsWith('d'));
-    })
-  });
-
-  describe('matches', function() {
-    it('requires a regex value', function() {
-      assertThrows(() => assert('abc').matches(1234));
-    });
-
-    it('requires a string value', function() {
-      assertThrows(() => assert(1234).matches(/abc/));
-    });
-
-    it('requires a string value (promise case)', function() {
-      return assert(Promise.resolve(1234))
-          .matches(/abc/)
-          .then(fail, function(error) {
-            assertEqual(
-                'Expected a string matching /abc/, got <1234> (number)',
-                error.message);
-          });
-    });
-
-    it('applies regex', function() {
-      assert('abc').matches(/abc/);
-      assertThrows(() => assert('def').matches(/abc/));
-    });
-  });
-
-  describe('isTrue', function() {
-    it('only accepts booleans', function() {
-      assertThrows(() => assert(123).isTrue());
-    });
-
-    it('accepts true values', function() {
-      assert(true).isTrue();
-      assert(Boolean('abc')).isTrue();
-      return assert(Promise.resolve(true)).isTrue();
-    });
-
-    it('rejects false values', function() {
-      assertThrows(() => assert(false).isTrue());
-      assertThrows(() => assert(Boolean(0)).isTrue());
-      return assert(Promise.resolve(false)).isTrue()
-          .then(fail, function() {/*no-op, ok*/});
-    });
-  });
-
-  describe('isFalse', function() {
-    it('only accepts booleans', function() {
-      assertThrows(() => assert(123).isFalse());
-    })
-
-    it('accepts false values', function() {
-      assert(false).isFalse();
-      assert(Boolean('')).isFalse();
-      return assert(Promise.resolve(false)).isFalse();
-    });
-
-    it('rejects true values', function() {
-      assertThrows(() => assert(true).isFalse());
-      assertThrows(() => assert(Boolean(1)).isFalse());
-      return assert(Promise.resolve(true)).isFalse()
-          .then(fail, function() {/*no-op, ok*/});
-    });
-  });
-
-  describe('isEqualTo', function() {
-    it('is strict equality', function() {
-      assert('abc').isEqualTo('abc');
-      assert('abc').equals('abc');
-      assert('abc').equalTo('abc');
-      assertThrows(() => assert('1').isEqualTo(1));
-    });
-  });
-
-  describe('notEqualTo', function() {
-    it('tests strict equality', function() {
-      assert('1').notEqualTo(1);
-      assert(1).notEqualTo('1');
-      assertThrows(() => assert('abc').notEqualTo('abc'));
-    });
-  });
-
-  function assertInstanceOf(ctor, value) {
-    assertTrue(value instanceof ctor);
-  }
-});

package/test/testing/index_test.js

@@ -1,224 +0,0 @@
-// 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 promise = require('../..').promise;
-const {enablePromiseManager} = require('../../lib/test/promise');
-
-
-var test = require('../../testing');
-
-describe('Mocha Integration', function() {
-
-  describe('beforeEach properly binds "this"', function() {
-    beforeEach(function() { this.x = 1; });
-    test.beforeEach(function() { this.x = 2; });
-    it('', function() { assert.equal(this.x, 2); });
-  });
-
-  describe('afterEach properly binds "this"', function() {
-    it('', function() { this.x = 1; });
-    test.afterEach(function() { this.x = 2; });
-    afterEach(function() { assert.equal(this.x, 2); });
-  });
-
-  describe('it properly binds "this"', function() {
-    beforeEach(function() { this.x = 1; });
-    test.it('', function() { this.x = 2; });
-    afterEach(function() { assert.equal(this.x, 2); });
-  });
-
-  enablePromiseManager(function() {
-    describe('timeout handling', function() {
-      describe('it does not reset the control flow on a non-timeout', function() {
-        var flowReset = false;
-
-        beforeEach(function() {
-          flowReset = false;
-          test.controlFlow().once(promise.ControlFlow.EventType.RESET, onreset);
-        });
-
-        test.it('', function() {
-          this.timeout(100);
-          return promise.delayed(50);
-        });
-
-        afterEach(function() {
-          assert.ok(!flowReset);
-          test.controlFlow().removeListener(
-              promise.ControlFlow.EventType.RESET, onreset);
-        });
-
-        function onreset() {
-          flowReset = true;
-        }
-      });
-
-      describe('it resets the control flow after a timeout' ,function() {
-        var timeoutErr, flowReset;
-
-        beforeEach(function() {
-          flowReset = false;
-          test.controlFlow().once(promise.ControlFlow.EventType.RESET, onreset);
-        });
-
-        test.it('', function() {
-          var callback = this.runnable().callback;
-          var test = this;
-          this.runnable().callback = function(err) {
-            timeoutErr = err;
-            // Reset our timeout to 0 so Mocha does not fail the test.
-            test.timeout(0);
-            // When we invoke the real callback, do not pass along the error so
-            // Mocha does not fail the test.
-            return callback.call(this);
-          };
-
-          test.timeout(50);
-          return promise.defer().promise;
-        });
-
-        afterEach(function() {
-          return Promise.resolve().then(function() {
-            test.controlFlow().removeListener(
-                promise.ControlFlow.EventType.RESET, onreset);
-            assert.ok(flowReset, 'control flow was not reset after a timeout');
-          });
-        });
-
-        function onreset() {
-          flowReset = true;
-        }
-      });
-    });
-
-    describe('async "done" support', function() {
-       this.timeout(2*1000);
-
-       var waited = false;
-       var DELAY = 100; // ms enough to notice
-
-       // Each test asynchronously sets waited to true, so clear/check waited
-       // before/after:
-       beforeEach(function() {
-          waited = false;
-       });
-
-       afterEach(function() {
-          assert.strictEqual(waited, true);
-       });
-
-       // --- First, vanilla mocha "it" should support the "done" callback correctly.
-
-       // This 'it' should block until 'done' is invoked
-       it('vanilla delayed', function(done) {
-          setTimeout(function delayedVanillaTimeout() {
-             waited = true;
-             done();
-          }, DELAY);
-       });
-
-       // --- Now with the webdriver wrappers for 'it' should support the "done" callback:
-
-       test.it('delayed', function(done) {
-          assert(done);
-          assert.strictEqual(typeof done, 'function');
-          setTimeout(function delayedTimeoutCallback() {
-             waited = true;
-             done();
-          }, DELAY);
-       });
-
-       // --- And test that the webdriver wrapper for 'it' works with a returned promise, too:
-
-       test.it('delayed by promise', function() {
-          var defer = promise.defer();
-          setTimeout(function delayedPromiseCallback() {
-             waited = true;
-             defer.fulfill('ignored');
-          });
-          return defer.promise;
-       });
-    });
-
-    describe('ControlFlow and "done" work together', function() {
-       var flow, order;
-       before(function() {
-          order = [];
-          flow = test.controlFlow();
-          flow.execute(function() { order.push(1); });
-       });
-
-       test.it('control flow updates and async done', function(done) {
-          flow.execute(function() { order.push(2); });
-          flow.execute(function() { order.push(3); }).then(function() {
-             order.push(4);
-          });
-          done();
-       });
-
-       after(function() {
-          assert.deepEqual([1, 2, 3, 4], order);
-       });
-    });
-  });
-
-  describe('generator support', function() {
-    let arr;
-
-    beforeEach(() => arr = []);
-    afterEach(() => assert.deepEqual(arr, [0, 1, 2, 3]));
-
-    test.it('sync generator', function* () {
-      arr.push(yield arr.length);
-      arr.push(yield arr.length);
-      arr.push(yield arr.length);
-      arr.push(yield arr.length);
-    });
-
-    test.it('async generator', function* () {
-      arr.push(yield Promise.resolve(arr.length));
-      arr.push(yield Promise.resolve(arr.length));
-      arr.push(yield Promise.resolve(arr.length));
-      arr.push(yield Promise.resolve(arr.length));
-    });
-
-    test.it('generator returns promise', function*() {
-      arr.push(yield Promise.resolve(arr.length));
-      arr.push(yield Promise.resolve(arr.length));
-      arr.push(yield Promise.resolve(arr.length));
-      setTimeout(_ => arr.push(arr.length), 10);
-      return new Promise((resolve) => setTimeout(_ => resolve(), 25));
-    });
-
-    describe('generator runs with proper "this" context', () => {
-      before(function() { this.values = [0, 1, 2, 3]; });
-      test.it('', function*() {
-        arr = this.values;
-      });
-    });
-
-    it('generator function must not take a callback', function() {
-      arr = [0, 1, 2, 3];  // For teardown hook.
-      assert.throws(_ => {
-        test.it('', function*(done){});
-      }, TypeError);
-    });
-  });
-});