// 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 { StubError, assertIsInstance, assertIsStubError, throwStubError } = require('./testutil')

const error = require('selenium-webdriver/lib/error')
const logging = require('selenium-webdriver/lib/logging')
const promise = require('selenium-webdriver/lib/promise')
const until = require('selenium-webdriver/lib/until')
const { Alert, AlertPromise, WebDriver, WebElement, WebElementPromise } = require('selenium-webdriver/lib/webdriver')
const { By } = require('selenium-webdriver/lib/by')
const { Capabilities } = require('selenium-webdriver/lib/capabilities')
const { Name } = require('selenium-webdriver/lib/command')
const { Session } = require('selenium-webdriver/lib/session')
const assert = require('node:assert')

const CName = Name
const SESSION_ID = 'test_session_id'
const fail = (msg) => assert.fail(msg)

describe('WebDriver', function () {
  const LOG = logging.getLogger('webdriver.test')

  function defer() {
    let d = {}
    let promise = new Promise((resolve, reject) => {
      Object.assign(d, { resolve, reject })
    })
    d.promise = promise
    return d
  }

  function expectedError(ctor, message) {
    return function (e) {
      assertIsInstance(ctor, e)
      assert.strictEqual(message, e.message)
    }
  }

  class Expectation {
    constructor(executor, name, opt_parameters) {
      this.executor_ = executor
      this.name_ = name
      this.times_ = 1
      this.sessionId_ = SESSION_ID
      this.check_ = null
      this.toDo_ = null
      this.withParameters(opt_parameters || {})
    }

    anyTimes() {
      this.times_ = Infinity
      return this
    }

    times(n) {
      this.times_ = n
      return this
    }

    withParameters(parameters) {
      this.parameters_ = parameters
      if (this.name_ !== CName.NEW_SESSION) {
        this.parameters_['sessionId'] = this.sessionId_
      }
      return this
    }

    andReturn(code, opt_value) {
      this.toDo_ = function (command) {
        LOG.info('executing ' + command.getName() + '; returning ' + code)
        return Promise.resolve(opt_value !== void 0 ? opt_value : null)
      }
      return this
    }

    andReturnSuccess(opt_value) {
      this.toDo_ = function (command) {
        LOG.info('executing ' + command.getName() + '; returning success')
        return Promise.resolve(opt_value !== void 0 ? opt_value : null)
      }
      return this
    }

    andReturnError(error) {
      if (typeof error === 'number') {
        throw Error('need error type')
      }
      this.toDo_ = function (command) {
        LOG.info('executing ' + command.getName() + '; returning failure')
        return Promise.reject(error)
      }
      return this
    }

    expect(name, opt_parameters) {
      this.end()
      return this.executor_.expect(name, opt_parameters)
    }

    end() {
      if (!this.toDo_) {
        this.andReturnSuccess(null)
      }
      return this.executor_
    }

    execute(command) {
      assert.deepStrictEqual(command.getParameters(), this.parameters_)
      return this.toDo_(command)
    }
  }

  class FakeExecutor {
    constructor() {
      this.commands_ = new Map()
    }

    execute(command) {
      let expectations = this.commands_.get(command.getName())
      if (!expectations || !expectations.length) {
        assert.fail('unexpected command: ' + command.getName())
        return
      }

      let next = expectations[0]
      let result = next.execute(command)
      if (next.times_ !== Infinity) {
        next.times_ -= 1
        if (!next.times_) {
          expectations.shift()
        }
      }
      return result
    }

    expect(commandName, opt_parameters) {
      if (!this.commands_.has(commandName)) {
        this.commands_.set(commandName, [])
      }
      let e = new Expectation(this, commandName, opt_parameters)
      this.commands_.get(commandName).push(e)
      return e
    }

    createDriver(opt_session) {
      let session = opt_session || new Session(SESSION_ID, {})
      return new WebDriver(session, this)
    }
  }

  /////////////////////////////////////////////////////////////////////////////
  //
  //    Tests
  //
  /////////////////////////////////////////////////////////////////////////////

  describe('testCreateSession', function () {
    it('happyPathWithCapabilitiesHashObject', function () {
      let aSession = new Session(SESSION_ID, { browserName: 'firefox' })
      let executor = new FakeExecutor()
        .expect(CName.NEW_SESSION)
        .withParameters({
          capabilities: {
            alwaysMatch: { browserName: 'firefox' },
            firstMatch: [{}],
          },
        })
        .andReturnSuccess(aSession)
        .end()

      const driver = WebDriver.createSession(executor, {
        browserName: 'firefox',
      })
      return driver.getSession().then((v) => assert.strictEqual(v, aSession))
    })

    it('happy Path With Capabilities Instance', function () {
      let aSession = new Session(SESSION_ID, { browserName: 'firefox' })
      let executor = new FakeExecutor()
        .expect(CName.NEW_SESSION)
        .withParameters({
          capabilities: {
            alwaysMatch: {
              'moz:debuggerAddress': true,
              browserName: 'firefox',
            },
            firstMatch: [{}],
          },
        })
        .andReturnSuccess(aSession)
        .end()

      const driver = WebDriver.createSession(executor, Capabilities.firefox())
      return driver.getSession().then((v) => assert.strictEqual(v, aSession))
    })

    it('drops non-W3C capability names from W3C capabilities', function () {
      let aSession = new Session(SESSION_ID, { browserName: 'firefox' })
      let executor = new FakeExecutor()
        .expect(CName.NEW_SESSION)
        .withParameters({
          capabilities: {
            alwaysMatch: { browserName: 'firefox' },
            firstMatch: [{}],
          },
        })
        .andReturnSuccess(aSession)
        .end()

      const driver = WebDriver.createSession(executor, {
        browserName: 'firefox',
        foo: 'bar',
      })
      return driver.getSession().then((v) => assert.strictEqual(v, aSession))
    })

    it('failsToCreateSession', function () {
      let executor = new FakeExecutor()
        .expect(CName.NEW_SESSION)
        .withParameters({
          capabilities: {
            alwaysMatch: { browserName: 'firefox' },
            firstMatch: [{}],
          },
        })
        .andReturnError(new StubError())
        .end()

      const driver = WebDriver.createSession(executor, {
        browserName: 'firefox',
      })
      return driver.getSession().then(fail, assertIsStubError)
    })

    it('invokes quit callback if it fails to create a session', function () {
      let called = false
      let executor = new FakeExecutor()
        .expect(CName.NEW_SESSION)
        .withParameters({
          capabilities: {
            alwaysMatch: { browserName: 'firefox' },
            firstMatch: [{}],
          },
        })
        .andReturnError(new StubError())
        .end()

      let driver = WebDriver.createSession(executor, { browserName: 'firefox' }, () => (called = true))
      return driver.getSession().then(fail, (err) => {
        assert.ok(called)
        assertIsStubError(err)
      })
    })
  })

  it('testDoesNotExecuteCommandIfSessionDoesNotResolve', function () {
    const session = Promise.reject(new StubError())
    return new FakeExecutor()
      .createDriver(session)
      .getTitle()
      .then((_) => assert.fail('should have failed'), assertIsStubError)
  })

  it('testCommandReturnValuesArePassedToFirstCallback', function () {
    let executor = new FakeExecutor().expect(CName.GET_TITLE).andReturnSuccess('Google Search').end()

    const driver = executor.createDriver()
    return driver.getTitle().then((title) => assert.strictEqual('Google Search', title))
  })

  it('testStopsCommandExecutionWhenAnErrorOccurs', function () {
    let e = new error.NoSuchWindowError('window not found')
    let executor = new FakeExecutor()
      .expect(CName.SWITCH_TO_WINDOW)
      .withParameters({
        name: 'foo',
        handle: 'foo',
      })
      .andReturnError(e)
      .end()

    let driver = executor.createDriver()
    return driver
      .switchTo()
      .window('foo')
      .then(
        (_) => driver.getTitle(), // mock should blow if this gets executed
        (v) => assert.strictEqual(v, e),
      )
  })

  it('testReportsErrorWhenExecutingCommandsAfterExecutingAQuit', function () {
    let executor = new FakeExecutor().expect(CName.QUIT).end()

    let verifyError = expectedError(
      error.NoSuchSessionError,
      'This driver instance does not have a valid session ID ' +
        '(did you call WebDriver.quit()?) and may no longer be used.',
    )

    let driver = executor.createDriver()
    return driver
      .quit()
      .then((_) => driver.get('http://www.google.com'))
      .then(assert.fail, verifyError)
  })

  describe('returningAPromise', function () {
    it('fromACallback', function () {
      let executor = new FakeExecutor()
        .expect(CName.GET_TITLE)
        .expect(CName.GET_CURRENT_URL)
        .andReturnSuccess('http://www.google.com')
        .end()

      const driver = executor.createDriver()
      return driver
        .getTitle()
        .then(function () {
          return driver.getCurrentUrl()
        })
        .then(function (value) {
          assert.strictEqual('http://www.google.com', value)
        })
    })

    it('fromAnErrbackSuppressesTheError', function () {
      let executor = new FakeExecutor()
        .expect(CName.SWITCH_TO_WINDOW, {
          name: 'foo',
          handle: 'foo',
        })
        .andReturnError(new StubError())
        .expect(CName.GET_CURRENT_URL)
        .andReturnSuccess('http://www.google.com')
        .end()

      const driver = executor.createDriver()
      return driver
        .switchTo()
        .window('foo')
        .catch(function (e) {
          assertIsStubError(e)
          return driver.getCurrentUrl()
        })
        .then((url) => assert.strictEqual('http://www.google.com', url))
    })
  })

  describe('WebElementPromise', function () {
    let driver = new FakeExecutor().createDriver()

    it('resolvesWhenUnderlyingElementDoes', function () {
      let el = new WebElement(driver, { ELEMENT: 'foo' })
      return new WebElementPromise(driver, Promise.resolve(el)).then((e) => assert.strictEqual(e, el))
    })

    it('resolvesBeforeCallbacksOnWireValueTrigger', function () {
      const el = defer()

      const element = new WebElementPromise(driver, el.promise)
      const messages = []

      let steps = [
        element.then((_) => messages.push('element resolved')),
        element.getId().then((_) => messages.push('wire value resolved')),
      ]

      el.resolve(new WebElement(driver, { ELEMENT: 'foo' }))
      return Promise.all(steps).then(function () {
        assert.deepStrictEqual(['element resolved', 'wire value resolved'], messages)
      })
    })

    it('isRejectedIfUnderlyingIdIsRejected', function () {
      let element = new WebElementPromise(driver, Promise.reject(new StubError()))
      return element.then(fail, assertIsStubError)
    })
  })

  describe('executeScript', function () {
    it('nullReturnValue', function () {
      let executor = new FakeExecutor()
        .expect(CName.EXECUTE_SCRIPT)
        .withParameters({
          script: 'return document.body;',
          args: [],
        })
        .andReturnSuccess(null)
        .end()

      const driver = executor.createDriver()
      return driver.executeScript('return document.body;').then((result) => assert.strictEqual(null, result))
    })

    it('primitiveReturnValue', function () {
      let executor = new FakeExecutor()
        .expect(CName.EXECUTE_SCRIPT)
        .withParameters({
          script: 'return document.body;',
          args: [],
        })
        .andReturnSuccess(123)
        .end()

      const driver = executor.createDriver()
      return driver.executeScript('return document.body;').then((result) => assert.strictEqual(123, result))
    })

    it('webElementReturnValue', function () {
      const json = WebElement.buildId('foo')

      let executor = new FakeExecutor()
        .expect(CName.EXECUTE_SCRIPT)
        .withParameters({
          script: 'return document.body;',
          args: [],
        })
        .andReturnSuccess(json)
        .end()

      const driver = executor.createDriver()
      return driver
        .executeScript('return document.body;')
        .then((element) => element.getId())
        .then((id) => assert.strictEqual(id, 'foo'))
    })

    it('arrayReturnValue', function () {
      const json = [WebElement.buildId('foo')]

      let executor = new FakeExecutor()
        .expect(CName.EXECUTE_SCRIPT)
        .withParameters({
          script: 'return document.body;',
          args: [],
        })
        .andReturnSuccess(json)
        .end()

      const driver = executor.createDriver()
      return driver
        .executeScript('return document.body;')
        .then(function (array) {
          assert.strictEqual(1, array.length)
          return array[0].getId()
        })
        .then((id) => assert.strictEqual('foo', id))
    })

    it('objectReturnValue', function () {
      const json = { foo: WebElement.buildId('foo') }

      let executor = new FakeExecutor()
        .expect(CName.EXECUTE_SCRIPT)
        .withParameters({
          script: 'return document.body;',
          args: [],
        })
        .andReturnSuccess(json)
        .end()

      const driver = executor.createDriver()
      return driver
        .executeScript('return document.body;')
        .then((obj) => obj['foo'].getId())
        .then((id) => assert.strictEqual(id, 'foo'))
    })

    it('scriptAsFunction', function () {
      let executor = new FakeExecutor()
        .expect(CName.EXECUTE_SCRIPT)
        .withParameters({
          script: 'return (' + function () {} + ').apply(null, arguments);',
          args: [],
        })
        .andReturnSuccess(null)
        .end()

      const driver = executor.createDriver()
      return driver.executeScript(function () {})
    })

    it('simpleArgumentConversion', function () {
      let executor = new FakeExecutor()
        .expect(CName.EXECUTE_SCRIPT)
        .withParameters({
          script: 'return 1;',
          args: ['abc', 123, true, [123, { foo: 'bar' }]],
        })
        .andReturnSuccess(null)
        .end()

      const driver = executor.createDriver()
      return driver.executeScript('return 1;', 'abc', 123, true, [123, { foo: 'bar' }])
    })

    it('webElementArgumentConversion', function () {
      const elementJson = WebElement.buildId('fefifofum')

      let executor = new FakeExecutor()
        .expect(CName.EXECUTE_SCRIPT)
        .withParameters({
          script: 'return 1;',
          args: [elementJson],
        })
        .andReturnSuccess(null)
        .end()

      const driver = executor.createDriver()
      return driver.executeScript('return 1;', new WebElement(driver, 'fefifofum'))
    })

    it('webElementPromiseArgumentConversion', function () {
      const elementJson = WebElement.buildId('bar')

      let executor = new FakeExecutor()
        .expect(CName.FIND_ELEMENT, {
          using: 'css selector',
          value: '*[id="foo"]',
        })
        .andReturnSuccess(elementJson)
        .expect(CName.EXECUTE_SCRIPT)
        .withParameters({
          script: 'return 1;',
          args: [elementJson],
        })
        .andReturnSuccess(null)
        .end()

      const driver = executor.createDriver()
      const element = driver.findElement(By.id('foo'))
      return driver.executeScript('return 1;', element)
    })

    it('argumentConversion', function () {
      const elementJson = WebElement.buildId('fefifofum')

      let executor = new FakeExecutor()
        .expect(CName.EXECUTE_SCRIPT)
        .withParameters({
          script: 'return 1;',
          args: ['abc', 123, true, elementJson, [123, { foo: 'bar' }]],
        })
        .andReturnSuccess(null)
        .end()

      const driver = executor.createDriver()
      const element = new WebElement(driver, 'fefifofum')
      return driver.executeScript('return 1;', 'abc', 123, true, element, [123, { foo: 'bar' }])
    })

    it('scriptReturnsAnError', function () {
      let executor = new FakeExecutor()
        .expect(CName.EXECUTE_SCRIPT)
        .withParameters({
          script: 'throw Error(arguments[0]);',
          args: ['bam'],
        })
        .andReturnError(new StubError())
        .end()
      const driver = executor.createDriver()
      return driver.executeScript('throw Error(arguments[0]);', 'bam').then(fail, assertIsStubError)
    })

    it('failsIfArgumentIsARejectedPromise', function () {
      let executor = new FakeExecutor()

      const arg = Promise.reject(new StubError())
      arg.catch(function () {}) // Suppress default handler.

      const driver = executor.createDriver()
      return driver.executeScript(function () {}, arg).then(fail, assertIsStubError)
    })
  })

  describe('executeAsyncScript', function () {
    it('failsIfArgumentIsARejectedPromise', function () {
      const arg = Promise.reject(new StubError())
      arg.catch(function () {}) // Suppress default handler.

      const driver = new FakeExecutor().createDriver()
      return driver.executeAsyncScript(function () {}, arg).then(fail, assertIsStubError)
    })
  })

  describe('findElement', function () {
    it('elementNotFound', function () {
      let executor = new FakeExecutor()
        .expect(CName.FIND_ELEMENT, {
          using: 'css selector',
          value: '*[id="foo"]',
        })
        .andReturnError(new StubError())
        .end()

      const driver = executor.createDriver()
      return driver.findElement(By.id('foo')).then(assert.fail, assertIsStubError)
    })

    it('elementNotFoundInACallback', function () {
      let executor = new FakeExecutor()
        .expect(CName.FIND_ELEMENT, {
          using: 'css selector',
          value: '*[id="foo"]',
        })
        .andReturnError(new StubError())
        .end()

      const driver = executor.createDriver()
      return Promise.resolve()
        .then((_) => driver.findElement(By.id('foo')))
        .then(assert.fail, assertIsStubError)
    })

    it('elementFound', function () {
      let executor = new FakeExecutor()
        .expect(CName.FIND_ELEMENT, {
          using: 'css selector',
          value: '*[id="foo"]',
        })
        .andReturnSuccess(WebElement.buildId('bar'))
        .expect(CName.CLICK_ELEMENT, { id: WebElement.buildId('bar') })
        .andReturnSuccess()
        .end()

      const driver = executor.createDriver()
      const element = driver.findElement(By.id('foo'))
      return element.click()
    })

    it('canUseElementInCallback', function () {
      let executor = new FakeExecutor()
        .expect(CName.FIND_ELEMENT, {
          using: 'css selector',
          value: '*[id="foo"]',
        })
        .andReturnSuccess(WebElement.buildId('bar'))
        .expect(CName.CLICK_ELEMENT, { id: WebElement.buildId('bar') })
        .andReturnSuccess()
        .end()

      const driver = executor.createDriver()
      return driver.findElement(By.id('foo')).then((e) => e.click())
    })

    it('byJs', function () {
      let executor = new FakeExecutor()
        .expect(CName.EXECUTE_SCRIPT, {
          script: 'return document.body',
          args: [],
        })
        .andReturnSuccess(WebElement.buildId('bar'))
        .expect(CName.CLICK_ELEMENT, { id: WebElement.buildId('bar') })
        .end()

      const driver = executor.createDriver()
      return driver.findElement(By.js('return document.body')).then((e) => e.click())
    })

    it('byJs_returnsNonWebElementValue', function () {
      let executor = new FakeExecutor()
        .expect(CName.EXECUTE_SCRIPT, { script: 'return 123', args: [] })
        .andReturnSuccess(123)
        .end()

      const driver = executor.createDriver()
      return driver.findElement(By.js('return 123')).then(assert.fail, function (e) {
        assertIsInstance(TypeError, e)
        assert.strictEqual('Custom locator did not return a WebElement', e.message)
      })
    })

    it('byJs_canPassArguments', function () {
      const script = 'return document.getElementsByTagName(arguments[0]);'
      let executor = new FakeExecutor()
        .expect(CName.EXECUTE_SCRIPT, {
          script: script,
          args: ['div'],
        })
        .andReturnSuccess(WebElement.buildId('one'))
        .end()
      const driver = executor.createDriver()
      return driver.findElement(By.js(script, 'div'))
    })

    it('customLocator', function () {
      let executor = new FakeExecutor()
        .expect(CName.FIND_ELEMENTS, { using: 'css selector', value: '.a' })
        .andReturnSuccess([WebElement.buildId('foo'), WebElement.buildId('bar')])
        .expect(CName.CLICK_ELEMENT, { id: WebElement.buildId('foo') })
        .andReturnSuccess()
        .end()

      const driver = executor.createDriver()
      const element = driver.findElement(function (d) {
        assert.strictEqual(driver, d)
        return d.findElements(By.className('a'))
      })
      return element.click()
    })

    it('customLocatorThrowsIfresultIsNotAWebElement', function () {
      const driver = new FakeExecutor().createDriver()
      return driver
        .findElement((_) => 1)
        .then(assert.fail, function (e) {
          assertIsInstance(TypeError, e)
          assert.strictEqual('Custom locator did not return a WebElement', e.message)
        })
    })
  })

  describe('findElements', function () {
    it('returnsMultipleElements', function () {
      const ids = ['foo', 'bar', 'baz']
      let executor = new FakeExecutor()
        .expect(CName.FIND_ELEMENTS, { using: 'css selector', value: '.a' })
        .andReturnSuccess(ids.map(WebElement.buildId))
        .end()

      const driver = executor.createDriver()
      return driver
        .findElements(By.className('a'))
        .then(function (elements) {
          return Promise.all(
            elements.map(function (e) {
              assert.ok(e instanceof WebElement)
              return e.getId()
            }),
          )
        })
        .then((actual) => assert.deepStrictEqual(ids, actual))
    })

    it('byJs', function () {
      const ids = ['foo', 'bar', 'baz']
      let executor = new FakeExecutor()
        .expect(CName.EXECUTE_SCRIPT, {
          script: 'return document.getElementsByTagName("div");',
          args: [],
        })
        .andReturnSuccess(ids.map(WebElement.buildId))
        .end()

      const driver = executor.createDriver()

      return driver
        .findElements(By.js('return document.getElementsByTagName("div");'))
        .then(function (elements) {
          return Promise.all(
            elements.map(function (e) {
              assert.ok(e instanceof WebElement)
              return e.getId()
            }),
          )
        })
        .then((actual) => assert.deepStrictEqual(ids, actual))
    })

    it('byJs_filtersOutNonWebElementResponses', function () {
      const ids = ['foo', 'bar', 'baz']
      const json = [
        WebElement.buildId(ids[0]),
        123,
        'a',
        false,
        WebElement.buildId(ids[1]),
        { 'not a web element': 1 },
        WebElement.buildId(ids[2]),
      ]
      let executor = new FakeExecutor()
        .expect(CName.EXECUTE_SCRIPT, {
          script: 'return document.getElementsByTagName("div");',
          args: [],
        })
        .andReturnSuccess(json)
        .end()

      const driver = executor.createDriver()
      return driver
        .findElements(By.js('return document.getElementsByTagName("div");'))
        .then(function (elements) {
          return Promise.all(
            elements.map(function (e) {
              assert.ok(e instanceof WebElement)
              return e.getId()
            }),
          )
        })
        .then((actual) => assert.deepStrictEqual(ids, actual))
    })

    it('byJs_convertsSingleWebElementResponseToArray', function () {
      let executor = new FakeExecutor()
        .expect(CName.EXECUTE_SCRIPT, {
          script: 'return document.getElementsByTagName("div");',
          args: [],
        })
        .andReturnSuccess(WebElement.buildId('foo'))
        .end()

      const driver = executor.createDriver()
      return driver
        .findElements(By.js('return document.getElementsByTagName("div");'))
        .then(function (elements) {
          return Promise.all(
            elements.map(function (e) {
              assert.ok(e instanceof WebElement)
              return e.getId()
            }),
          )
        })
        .then((actual) => assert.deepStrictEqual(['foo'], actual))
    })

    it('byJs_canPassScriptArguments', function () {
      const script = 'return document.getElementsByTagName(arguments[0]);'
      let executor = new FakeExecutor()
        .expect(CName.EXECUTE_SCRIPT, {
          script: script,
          args: ['div'],
        })
        .andReturnSuccess([WebElement.buildId('one'), WebElement.buildId('two')])
        .end()

      const driver = executor.createDriver()
      return driver
        .findElements(By.js(script, 'div'))
        .then(function (elements) {
          return Promise.all(
            elements.map(function (e) {
              assert.ok(e instanceof WebElement)
              return e.getId()
            }),
          )
        })
        .then((actual) => assert.deepStrictEqual(['one', 'two'], actual))
    })
  })

  describe('sendKeys', function () {
    it('convertsVarArgsIntoStrings_simpleArgs', function () {
      let executor = new FakeExecutor()
        .expect(CName.SEND_KEYS_TO_ELEMENT, {
          id: WebElement.buildId('one'),
          text: '12abc3',
          value: '12abc3'.split(''),
        })
        .andReturnSuccess()
        .end()

      const driver = executor.createDriver()
      const element = new WebElement(driver, 'one')
      return element.sendKeys(1, 2, 'abc', 3)
    })

    it('sendKeysWithEmojiRepresentedByPairOfCodePoints', function () {
      let executor = new FakeExecutor()
        .expect(CName.SEND_KEYS_TO_ELEMENT, {
          id: WebElement.buildId('one'),
          text: '\uD83D\uDE00',
          value: ['\uD83D\uDE00'],
        })
        .andReturnSuccess()
        .end()

      const driver = executor.createDriver()
      const element = new WebElement(driver, 'one')
      return element.sendKeys('\uD83D\uDE00')
    })

    it('convertsVarArgsIntoStrings_promisedArgs', function () {
      let executor = new FakeExecutor()
        .expect(CName.FIND_ELEMENT, {
          using: 'css selector',
          value: '*[id="foo"]',
        })
        .andReturnSuccess(WebElement.buildId('one'))
        .expect(CName.SEND_KEYS_TO_ELEMENT, {
          id: WebElement.buildId('one'),
          text: 'abc123def',
          value: 'abc123def'.split(''),
        })
        .andReturnSuccess()
        .end()

      const driver = executor.createDriver()
      const element = driver.findElement(By.id('foo'))
      return element.sendKeys(Promise.resolve('abc'), 123, Promise.resolve('def'))
    })

    it('sendKeysWithAFileDetector', function () {
      let executor = new FakeExecutor()
        .expect(CName.FIND_ELEMENT, {
          using: 'css selector',
          value: '*[id="foo"]',
        })
        .andReturnSuccess(WebElement.buildId('one'))
        .expect(CName.SEND_KEYS_TO_ELEMENT, {
          id: WebElement.buildId('one'),
          text: 'modified/path',
          value: 'modified/path'.split(''),
        })
        .andReturnSuccess()
        .end()

      let driver = executor.createDriver()
      let handleFile = function (d, path) {
        assert.strictEqual(driver, d)
        assert.strictEqual(path, 'original/path')
        return Promise.resolve('modified/path')
      }
      driver.setFileDetector({ handleFile })

      return driver.findElement(By.id('foo')).sendKeys('original/', 'path')
    })

    it('sendKeysWithAFileDetector_handlerError', function () {
      let executor = new FakeExecutor()
        .expect(CName.FIND_ELEMENT, {
          using: 'css selector',
          value: '*[id="foo"]',
        })
        .andReturnSuccess(WebElement.buildId('one'))
        .expect(CName.SEND_KEYS_TO_ELEMENT, {
          id: WebElement.buildId('one'),
          text: 'original/path',
          value: 'original/path'.split(''),
        })
        .andReturnSuccess()
        .end()

      let driver = executor.createDriver()
      let handleFile = function (d, path) {
        assert.strictEqual(driver, d)
        assert.strictEqual(path, 'original/path')
        return Promise.reject('unhandled file error')
      }
      driver.setFileDetector({ handleFile })

      return driver.findElement(By.id('foo')).sendKeys('original/', 'path')
    })
  })

  describe('switchTo()', function () {
    describe('window', function () {
      it('should return a resolved promise when the window is found', function () {
        let executor = new FakeExecutor()
          .expect(CName.SWITCH_TO_WINDOW)
          .withParameters({
            name: 'foo',
            handle: 'foo',
          })
          .andReturnSuccess()
          .end()

        return executor.createDriver().switchTo().window('foo')
      })

      it('should propagate exceptions', function () {
        let e = new error.NoSuchWindowError('window not found')
        let executor = new FakeExecutor()
          .expect(CName.SWITCH_TO_WINDOW)
          .withParameters({
            name: 'foo',
            handle: 'foo',
          })
          .andReturnError(e)
          .end()

        return executor
          .createDriver()
          .switchTo()
          .window('foo')
          .then(assert.fail, (v) => assert.strictEqual(v, e))
      })
    })
  })

  describe('elementEquality', function () {
    it('isReflexive', function () {
      const a = new WebElement(new FakeExecutor().createDriver(), 'foo')
      return WebElement.equals(a, a).then(assert.ok)
    })

    it('failsIfAnInputElementCouldNotBeFound', function () {
      let id = Promise.reject(new StubError())

      const driver = new FakeExecutor().createDriver()
      const a = new WebElement(driver, 'foo')
      const b = new WebElementPromise(driver, id)

      return WebElement.equals(a, b).then(fail, assertIsStubError)
    })
  })

  describe('waiting', function () {
    it('on a condition that always returns true', function () {
      let executor = new FakeExecutor()
      let driver = executor.createDriver()
      let count = 0

      function condition() {
        count++
        return true
      }

      return driver.wait(condition, 1).then(() => assert.strictEqual(1, count))
    })

    it('on a simple counting condition', function () {
      let executor = new FakeExecutor()
      let driver = executor.createDriver()
      let count = 0

      function condition() {
        return ++count === 3
      }

      return driver.wait(condition, 250).then(() => assert.strictEqual(3, count))
    })

    it('on a condition that returns a promise that resolves to true after a short timeout', function () {
      let executor = new FakeExecutor()
      let driver = executor.createDriver()

      let count = 0

      function condition() {
        count += 1
        return new Promise((resolve) => {
          setTimeout(() => resolve(true), 50)
        })
      }

      return driver.wait(condition, 75).then(() => assert.strictEqual(1, count))
    })

    it('on a condition that returns a promise', function () {
      let executor = new FakeExecutor()
      let driver = executor.createDriver()

      let count = 0

      function condition() {
        count += 1
        return new Promise((resolve) => {
          setTimeout(() => resolve(count === 3), 25)
        })
      }

      return driver.wait(condition, 100, null, 25).then(() => assert.strictEqual(3, count))
    })

    it('fails if condition throws', function () {
      let executor = new FakeExecutor()
      let driver = executor.createDriver()
      return driver.wait(throwStubError, 0, 'goes boom').then(fail, assertIsStubError)
    })

    it('fails if condition returns a rejected promise', function () {
      let executor = new FakeExecutor()
      let driver = executor.createDriver()

      function condition() {
        return new Promise((_, reject) => reject(new StubError()))
      }

      return driver.wait(condition, 0, 'goes boom').then(fail, assertIsStubError)
    })

    it('supports message function if condition exceeds timeout', function () {
      let executor = new FakeExecutor()
      let driver = executor.createDriver()
      let message = () => 'goes boom'
      return driver
        .wait(() => false, 0.001, message)
        .then(fail, (e) => {
          assert.ok(/^goes boom\nWait timed out after \d+ms$/.test(e.message))
        })
    })

    it('handles if the message function throws an error after a condition exceeds timeout', function () {
      let executor = new FakeExecutor()
      let driver = executor.createDriver()
      let message = () => {
        throw new Error('message function error')
      }
      return driver
        .wait(() => false, 0.001, message)
        .then(fail, (e) => {
          assert.ok(/^message function error\nWait timed out after \d+ms$/.test(e.message))
        })
    })

    it('supports message function if condition returns a rejected promise', function () {
      let executor = new FakeExecutor()
      let driver = executor.createDriver()
      let condition = new Promise((res) => setTimeout(res, 100))
      let message = () => 'goes boom'
      return driver.wait(condition, 1, message).then(fail, (e) => {
        assert.ok(/^goes boom\nTimed out waiting for promise to resolve after \d+ms$/.test(e.message))
      })
    })

    it('handles if the message function returns an error after a rejected promise', function () {
      let executor = new FakeExecutor()
      let driver = executor.createDriver()
      let condition = new Promise((res) => setTimeout(res, 100))
      let message = () => {
        throw new Error('message function error')
      }
      return driver.wait(condition, 1, message).then(fail, (e) => {
        assert.ok(/^message function error\nTimed out waiting for promise to resolve after \d+ms$/.test(e.message))
      })
    })

    it('waits forever on a zero timeout', function () {
      let done = false
      setTimeout(() => (done = true), 150)

      let executor = new FakeExecutor()
      let driver = executor.createDriver()
      let waitResult = driver.wait(() => done, 0)

      return driver
        .sleep(75)
        .then(function () {
          assert.ok(!done)
          return driver.sleep(100)
        })
        .then(function () {
          assert.ok(done)
          return waitResult
        })
    })

    it('waits forever if timeout omitted', function () {
      let done = false
      setTimeout(() => (done = true), 150)

      let executor = new FakeExecutor()
      let driver = executor.createDriver()
      let waitResult = driver.wait(() => done)

      return driver
        .sleep(75)
        .then(function () {
          assert.ok(!done)
          return driver.sleep(100)
        })
        .then(function () {
          assert.ok(done)
          return waitResult
        })
    })

    it('times out when timer expires', function () {
      let executor = new FakeExecutor()
      let driver = executor.createDriver()

      let count = 0
      let wait = driver.wait(
        function () {
          count += 1
          let ms = count === 2 ? 65 : 5
          return promise.delayed(ms).then(function () {
            return false
          })
        },
        60,
        'counting to 3',
      )

      return wait.then(fail, function (e) {
        assert.strictEqual(2, count)
        assert.ok(e instanceof error.TimeoutError, 'Unexpected error: ' + e)
        assert.ok(/^counting to 3\nWait timed out after \d+ms$/.test(e.message))
      })
    })

    it('requires condition to be a promise or function', function () {
      let executor = new FakeExecutor()
      let driver = executor.createDriver()
      assert.throws(() => driver.wait(1234, 0))
    })

    it('promise that does not resolve before timeout', function () {
      let d = defer()

      let executor = new FakeExecutor()
      let driver = executor.createDriver()
      return driver.wait(d.promise, 5).then(fail, (e) => {
        assert.ok(e instanceof error.TimeoutError, 'Unexpected error: ' + e)
        assert.ok(
          /Timed out waiting for promise to resolve after \d+ms/.test(e.message),
          'unexpected error message: ' + e.message,
        )
      })
    })

    it('unbounded wait on promise resolution', function () {
      let messages = []
      let d = defer()

      let executor = new FakeExecutor()
      let driver = executor.createDriver()
      let waitResult = driver.wait(d.promise).then(function (value) {
        messages.push('b')
        assert.strictEqual(1234, value)
      })

      setTimeout(() => messages.push('a'), 5)
      return driver
        .sleep(10)
        .then(function () {
          assert.deepStrictEqual(['a'], messages)
          d.resolve(1234)
          return waitResult
        })
        .then(function () {
          assert.deepStrictEqual(['a', 'b'], messages)
        })
    })

    describe('supports custom wait functions', function () {
      it('waitSucceeds', function () {
        let executor = new FakeExecutor()
          .expect(CName.FIND_ELEMENTS, {
            using: 'css selector',
            value: '*[id="foo"]',
          })
          .andReturnSuccess([])
          .times(2)
          .expect(CName.FIND_ELEMENTS, {
            using: 'css selector',
            value: '*[id="foo"]',
          })
          .andReturnSuccess([WebElement.buildId('bar')])
          .end()

        const driver = executor.createDriver()
        return driver.wait(
          function () {
            return driver.findElements(By.id('foo')).then((els) => els.length > 0)
          },
          200,
          null,
          25,
        )
      })

      it('waitTimesout_timeoutCaught', function () {
        let executor = new FakeExecutor()
          .expect(CName.FIND_ELEMENTS, {
            using: 'css selector',
            value: '*[id="foo"]',
          })
          .andReturnSuccess([])
          .anyTimes()
          .end()

        const driver = executor.createDriver()
        return driver
          .wait(function () {
            return driver.findElements(By.id('foo')).then((els) => els.length > 0)
          }, 25)
          .then(fail, function (e) {
            assert.strictEqual('Wait timed out after ', e.message.substring(0, 'Wait timed out after '.length))
          })
      })
    })

    describe('supports condition objects', function () {
      it('wait succeeds', function () {
        let executor = new FakeExecutor()
          .expect(CName.FIND_ELEMENTS, {
            using: 'css selector',
            value: '*[id="foo"]',
          })
          .andReturnSuccess([])
          .times(2)
          .expect(CName.FIND_ELEMENTS, {
            using: 'css selector',
            value: '*[id="foo"]',
          })
          .andReturnSuccess([WebElement.buildId('bar')])
          .end()

        let driver = executor.createDriver()
        return driver.wait(until.elementLocated(By.id('foo')), 200, null, 25)
      })

      it('wait times out', function () {
        let executor = new FakeExecutor()
          .expect(CName.FIND_ELEMENTS, {
            using: 'css selector',
            value: '*[id="foo"]',
          })
          .andReturnSuccess([])
          .anyTimes()
          .end()

        let driver = executor.createDriver()
        return driver
          .wait(until.elementLocated(By.id('foo')), 5)
          .then(fail, (err) => assert.ok(err instanceof error.TimeoutError))
      })
    })

    describe('supports promise objects', function () {
      it('wait succeeds', function () {
        let promise = new Promise((resolve) => {
          setTimeout(() => resolve(1), 10)
        })

        let driver = new FakeExecutor().createDriver()
        return driver.wait(promise, 200).then((v) => assert.strictEqual(v, 1))
      })

      it('wait times out', function () {
        let promise = new Promise(() => {
          /* never resolves */
        })

        let driver = new FakeExecutor().createDriver()
        return driver.wait(promise, 5).then(fail, (err) => assert.ok(err instanceof error.TimeoutError))
      })

      it('wait fails if promise is rejected', function () {
        let err = Error('boom')
        let driver = new FakeExecutor().createDriver()
        return driver.wait(Promise.reject(err), 5).then(fail, (e) => assert.strictEqual(e, err))
      })
    })

    it('fails if not supported condition type provided', function () {
      let driver = new FakeExecutor().createDriver()
      assert.throws(() => driver.wait({}, 5), TypeError)
    })
  })

  describe('alert handling', function () {
    it('alertResolvesWhenPromisedTextResolves', function () {
      let driver = new FakeExecutor().createDriver()
      let deferredText = defer()

      let alert = new AlertPromise(driver, deferredText.promise)

      deferredText.resolve(new Alert(driver, 'foo'))
      return alert.getText().then((text) => assert.strictEqual(text, 'foo'))
    })

    it('cannotSwitchToAlertThatIsNotPresent', function () {
      let e = new error.NoSuchAlertError()
      let executor = new FakeExecutor().expect(CName.GET_ALERT_TEXT).andReturnError(e).end()

      return executor
        .createDriver()
        .switchTo()
        .alert()
        .then(assert.fail, (v) => assert.strictEqual(v, e))
    })

    it('commandsFailIfAlertNotPresent', function () {
      let e = new error.NoSuchAlertError()
      let executor = new FakeExecutor().expect(CName.GET_ALERT_TEXT).andReturnError(e).end()

      const driver = executor.createDriver()
      const alert = driver.switchTo().alert()

      const expectError = (v) => assert.strictEqual(v, e)

      return alert
        .getText()
        .then(fail, expectedError)
        .then(() => alert.accept())
        .then(fail, expectedError)
        .then(() => alert.dismiss())
        .then(fail, expectError)
        .then(() => alert.sendKeys('hi'))
        .then(fail, expectError)
    })
  })

  it('testFetchingLogs', function () {
    let executor = new FakeExecutor()
      .expect(CName.GET_LOG, { type: 'browser' })
      .andReturnSuccess([
        { level: 'INFO', message: 'hello', timestamp: 1234 },
        { level: 'DEBUG', message: 'abc123', timestamp: 5678 },
      ])
      .end()

    const driver = executor.createDriver()
    return driver
      .manage()
      .logs()
      .get('browser')
      .then(function (entries) {
        assert.strictEqual(2, entries.length)

        assert.ok(entries[0] instanceof logging.Entry)
        assert.strictEqual(logging.Level.INFO.value, entries[0].level.value)
        assert.strictEqual('hello', entries[0].message)
        assert.strictEqual(1234, entries[0].timestamp)

        assert.ok(entries[1] instanceof logging.Entry)
        assert.strictEqual(logging.Level.DEBUG.value, entries[1].level.value)
        assert.strictEqual('abc123', entries[1].message)
        assert.strictEqual(5678, entries[1].timestamp)
      })
  })

  it('testCommandsFailIfInitialSessionCreationFailed', function () {
    const session = Promise.reject(new StubError())

    const driver = new FakeExecutor().createDriver(session)
    const navigateResult = driver.get('some-url').then(fail, assertIsStubError)
    const quitResult = driver.quit().then(fail, assertIsStubError)
    return Promise.all([navigateResult, quitResult])
  })

  it('testWebElementCommandsFailIfInitialDriverCreationFailed', function () {
    const session = Promise.reject(new StubError())
    const driver = new FakeExecutor().createDriver(session)
    return driver.findElement(By.id('foo')).click().then(fail, assertIsStubError)
  })

  it('testWebElementCommansFailIfElementCouldNotBeFound', function () {
    let e = new error.NoSuchElementError('Unable to find element')
    let executor = new FakeExecutor()
      .expect(CName.FIND_ELEMENT, {
        using: 'css selector',
        value: '*[id="foo"]',
      })
      .andReturnError(e)
      .end()

    const driver = executor.createDriver()
    return driver
      .findElement(By.id('foo'))
      .click()
      .then(fail, (v) => assert.strictEqual(v, e))
  })

  it('testCannotFindChildElementsIfParentCouldNotBeFound', function () {
    let e = new error.NoSuchElementError('Unable to find element')
    let executor = new FakeExecutor()
      .expect(CName.FIND_ELEMENT, {
        using: 'css selector',
        value: '*[id="foo"]',
      })
      .andReturnError(e)
      .end()

    const driver = executor.createDriver()
    return driver
      .findElement(By.id('foo'))
      .findElement(By.id('bar'))
      .findElement(By.id('baz'))
      .then(fail, (v) => assert.strictEqual(v, e))
  })

  describe('actions()', function () {
    describe('move()', function () {
      it('no origin', function () {
        let executor = new FakeExecutor()
          .expect(CName.ACTIONS, {
            actions: [
              {
                type: 'pointer',
                id: 'default mouse',
                parameters: {
                  pointerType: 'mouse',
                },
                actions: [
                  {
                    duration: 100,
                    origin: 'viewport',
                    type: 'pointerMove',
                    x: 0,
                    y: 125,
                    altitudeAngle: 0,
                    azimuthAngle: 0,
                    width: 0,
                    height: 0,
                    pressure: 0,
                    tangentialPressure: 0,
                    tiltX: 0,
                    tiltY: 0,
                    twist: 0,
                  },
                ],
              },
            ],
          })
          .andReturnSuccess()
          .end()

        let driver = executor.createDriver()
        return driver.actions().move({ x: 0, y: 125 }).perform()
      })

      it('origin = element', function () {
        let executor = new FakeExecutor()
          .expect(CName.FIND_ELEMENT, {
            using: 'css selector',
            value: '*[id="foo"]',
          })
          .andReturnSuccess(WebElement.buildId('abc123'))
          .expect(CName.ACTIONS, {
            actions: [
              {
                type: 'pointer',
                id: 'default mouse',
                parameters: {
                  pointerType: 'mouse',
                },
                actions: [
                  {
                    duration: 100,
                    origin: WebElement.buildId('abc123'),
                    type: 'pointerMove',
                    x: 0,
                    y: 125,
                    altitudeAngle: 0,
                    azimuthAngle: 0,
                    width: 0,
                    height: 0,
                    pressure: 0,
                    tangentialPressure: 0,
                    tiltX: 0,
                    tiltY: 0,
                    twist: 0,
                  },
                ],
              },
            ],
          })
          .end()

        let driver = executor.createDriver()
        let element = driver.findElement(By.id('foo'))
        return driver.actions().move({ x: 0, y: 125, origin: element }).perform()
      })
    })
  })

  describe('manage()', function () {
    describe('setTimeouts()', function () {
      describe('throws if no timeouts are specified', function () {
        let driver
        before(() => (driver = new FakeExecutor().createDriver()))

        it('; no arguments', function () {
          assert.throws(() => driver.manage().setTimeouts(), TypeError)
        })

        it('; ignores unrecognized timeout keys', function () {
          assert.throws(() => driver.manage().setTimeouts({ foo: 123 }), TypeError)
        })

        it('; ignores positional arguments', function () {
          assert.throws(() => driver.manage().setTimeouts(1234, 56), TypeError)
        })
      })

      describe('throws timeout is not a number, null, or undefined', () => {
        let driver
        before(() => (driver = new FakeExecutor().createDriver()))

        function checkError(e) {
          return e instanceof TypeError && /expected "(script|pageLoad|implicit)" to be a number/.test(e.message)
        }

        it('script', function () {
          assert.throws(() => driver.manage().setTimeouts({ script: 'abc' }), checkError)
        })

        it('pageLoad', function () {
          assert.throws(() => driver.manage().setTimeouts({ pageLoad: 'abc' }), checkError)
        })

        it('implicit', function () {
          assert.throws(() => driver.manage().setTimeouts({ implicit: 'abc' }), checkError)
        })
      })

      it('can set multiple timeouts', function () {
        let executor = new FakeExecutor()
          .expect(CName.SET_TIMEOUT, { script: 1, pageLoad: 2, implicit: 3 })
          .andReturnSuccess()
          .end()
        let driver = executor.createDriver()
        return driver.manage().setTimeouts({ script: 1, pageLoad: 2, implicit: 3 })
      })

      it('falls back to legacy wire format if W3C version fails', () => {
        let executor = new FakeExecutor()
          .expect(CName.SET_TIMEOUT, { implicit: 3 })
          .andReturnError(Error('oops'))
          .expect(CName.SET_TIMEOUT, { type: 'implicit', ms: 3 })
          .andReturnSuccess()
          .end()
        let driver = executor.createDriver()
        return driver.manage().setTimeouts({ implicit: 3 })
      })
    })
  })
})