selenium-webdriver 3.0.0.beta4.0 → 4.0.0.alpha5

data/lib/selenium/webdriver/firefox/service.rb

@@ -1,5 +1,5 @@
-# encoding: utf-8
-#
+# frozen_string_literal: true
+
 # 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
@@ -20,46 +20,27 @@
 module Selenium
   module WebDriver
     module Firefox
-      #
-      # @api private
-      #
-
       class Service < WebDriver::Service
         DEFAULT_PORT = 4444
+        EXECUTABLE = 'geckodriver'
+        MISSING_TEXT = <<~ERROR
+          Unable to find Mozilla geckodriver. Please download the server from
+          https://github.com/mozilla/geckodriver/releases and place it somewhere on your PATH.
+          More info at https://developer.mozilla.org/en-US/docs/Mozilla/QA/Marionette/WebDriver.
+        ERROR
+        SHUTDOWN_SUPPORTED = false
 
         private
 
-        def start_process
-          server_command = [@executable_path, "--binary=#{Firefox::Binary.path}", "--port=#{@port}", *@extra_args]
-          @process       = ChildProcess.build(*server_command)
-
-          if $DEBUG
-            @process.io.inherit!
-          elsif Platform.windows?
-            # workaround stdio inheritance issue
-            # https://github.com/mozilla/geckodriver/issues/48
-            @process.io.stdout = @process.io.stderr = File.new(Platform.null_device, 'w')
-          end
-
-          @process.start
-        end
-
-        def stop_process
-          super
-          return unless Platform.windows? && !$DEBUG
-          begin
-            @process.io.close
-          rescue
-            nil
-          end
-        end
-
-        def stop_server
-          connect_to_server { |http| http.head('/shutdown') }
-        end
-
-        def cannot_connect_error_text
-          "unable to connect to Mozilla geckodriver #{@host}:#{@port}"
+        # Note: This processing is deprecated
+        def extract_service_args(driver_opts)
+          driver_args = super
+          driver_opts = driver_opts.dup
+          driver_args << "--binary=#{driver_opts[:binary]}" if driver_opts.key?(:binary)
+          driver_args << "--log=#{driver_opts[:log]}" if driver_opts.key?(:log)
+          driver_args << "--marionette-port=#{driver_opts[:marionette_port]}" if driver_opts.key?(:marionette_port)
+          driver_args << "--host=#{driver_opts[:host]}" if driver_opts.key?(:host)
+          driver_args
         end
       end # Service
     end # Firefox

data/lib/selenium/webdriver/ie.rb

@@ -1,5 +1,5 @@
-# encoding: utf-8
-#
+# frozen_string_literal: true
+
 # 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
@@ -17,31 +17,25 @@
 # specific language governing permissions and limitations
 # under the License.
 
-require 'selenium/webdriver/ie/bridge'
-require 'selenium/webdriver/ie/service'
-
 module Selenium
   module WebDriver
     module IE
-      MISSING_TEXT = <<-ERROR.tr("\n", '').freeze
-        Unable to find IEDriverServer. Please download the server from
-        http://selenium-release.storage.googleapis.com/index.html and place it
-        somewhere on your PATH. More info at https://github.com/SeleniumHQ/selenium/wiki/InternetExplorerDriver.
-      ERROR
+      autoload :Driver, 'selenium/webdriver/ie/driver'
+      autoload :Options, 'selenium/webdriver/ie/options'
+      autoload :Service, 'selenium/webdriver/ie/service'
 
       def self.driver_path=(path)
-        Platform.assert_executable path
-        @driver_path = path
+        WebDriver.logger.deprecate 'Selenium::WebDriver::IE#driver_path=',
+                                   'Selenium::WebDriver::IE::Service#driver_path=',
+                                   id: :driver_path
+        Selenium::WebDriver::IE::Service.driver_path = path
       end
 
       def self.driver_path
-        @driver_path ||= begin
-          path = Platform.find_binary('IEDriverServer')
-          raise Error::WebDriverError, MISSING_TEXT unless path
-          Platform.assert_executable path
-
-          path
-        end
+        WebDriver.logger.deprecate 'Selenium::WebDriver::IE#driver_path',
+                                   'Selenium::WebDriver::IE::Service#driver_path',
+                                   id: :driver_path
+        Selenium::WebDriver::IE::Service.driver_path
       end
     end # IE
   end # WebDriver

data/lib/selenium/webdriver/ie/driver.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+# 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.
+
+module Selenium
+  module WebDriver
+    module IE
+
+      #
+      # Driver implementation for Internet Explorer supporting
+      # both OSS and W3C dialects of JSON wire protocol.
+      # @api private
+      #
+
+      class Driver < WebDriver::Driver
+        include DriverExtensions::HasWebStorage
+        include DriverExtensions::TakesScreenshot
+
+        def browser
+          :internet_explorer
+        end
+      end # Driver
+    end # IE
+  end # WebDriver
+end # Selenium

data/lib/selenium/webdriver/ie/options.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+# 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.
+
+module Selenium
+  module WebDriver
+    module IE
+      class Options < WebDriver::Options
+        KEY = 'se:ieOptions'
+        SCROLL_TOP = 0
+        SCROLL_BOTTOM = 1
+        CAPABILITIES = {
+          browser_attach_timeout: 'browserAttachTimeout',
+          element_scroll_behavior: 'elementScrollBehavior',
+          full_page_screenshot: 'ie.enableFullPageScreenshot',
+          ensure_clean_session: 'ie.ensureCleanSession',
+          file_upload_dialog_timeout: 'ie.fileUploadDialogTimeout',
+          force_create_process_api: 'ie.forceCreateProcessApi',
+          force_shell_windows_api: 'ie.forceShellWindowsApi',
+          ignore_protected_mode_settings: 'ignoreProtectedModeSettings',
+          ignore_zoom_level: 'ignoreZoomSetting',
+          initial_browser_url: 'initialBrowserUrl',
+          native_events: 'nativeEvents',
+          persistent_hover: 'enablePersistentHover',
+          require_window_focus: 'requireWindowFocus',
+          use_per_process_proxy: 'ie.usePerProcessProxy',
+          validate_cookie_document_type: 'ie.validateCookieDocumentType'
+        }.freeze
+
+        CAPABILITIES.each_key do |key|
+          define_method key do
+            @options[key]
+          end
+
+          define_method "#{key}=" do |value|
+            @options[key] = value
+          end
+        end
+
+        attr_reader :args
+
+        #
+        # Create a new Options instance
+        #
+        # @example
+        #   options = Selenium::WebDriver::IE::Options.new(args: ['--host=127.0.0.1'])
+        #   driver = Selenium::WebDriver.for(:ie, options: options)
+        #
+        # @example
+        #   options = Selenium::WebDriver::IE::Options.new
+        #   options.element_scroll_behavior = Selenium::WebDriver::IE::Options::SCROLL_BOTTOM
+        #   driver = Selenium::WebDriver.for(:ie, options: options)
+        #
+        # @param [Hash] opts the pre-defined options
+        # @option opts [Array<String>] args
+        # @option opts [Integer] browser_attach_timeout
+        # @option opts [Integer] element_scroll_behavior Either SCROLL_TOP or SCROLL_BOTTOM
+        # @option opts [Boolean] full_page_screenshot
+        # @option opts [Boolean] ensure_clean_session
+        # @option opts [Integer] file_upload_dialog_timeout
+        # @option opts [Boolean] force_create_process_api
+        # @option opts [Boolean] force_shell_windows_api
+        # @option opts [Boolean] ignore_protected_mode_settings
+        # @option opts [Boolean] ignore_zoom_level
+        # @option opts [String] initial_browser_url
+        # @option opts [Boolean] native_events
+        # @option opts [Boolean] persistent_hover
+        # @option opts [Boolean] require_window_focus
+        # @option opts [Boolean] use_per_process_proxy
+        # @option opts [Boolean] validate_cookie_document_type
+        #
+
+        def initialize(args: nil, **opts)
+          super(opts)
+
+          @args = (args || []).to_set
+          @options[:native_events] = true if @options[:native_events].nil?
+        end
+
+        #
+        # Add a command-line argument to use when starting Internet Explorer.
+        #
+        # @param [String] arg The command-line argument to add
+        #
+
+        def add_argument(arg)
+          @args << arg
+        end
+
+        #
+        # @api private
+        #
+
+        def as_json(*)
+          options = super
+          options['ie.browserCommandLineSwitches'] = @args.to_a.join(' ') if @args.any?
+
+          {KEY => generate_as_json(options)}
+        end
+      end # Options
+    end # IE
+  end # WebDriver
+end # Selenium

data/lib/selenium/webdriver/ie/service.rb

@@ -1,5 +1,5 @@
-# encoding: utf-8
-#
+# frozen_string_literal: true
+
 # 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
@@ -20,29 +20,29 @@
 module Selenium
   module WebDriver
     module IE
-      #
-      # @api private
-      #
-
       class Service < WebDriver::Service
         DEFAULT_PORT = 5555
+        EXECUTABLE = 'IEDriverServer'
+        MISSING_TEXT = <<~ERROR
+          Unable to find IEDriverServer. Please download the server from
+          http://selenium-release.storage.googleapis.com/index.html and place it somewhere on your PATH.
+          More info at https://github.com/SeleniumHQ/selenium/wiki/InternetExplorerDriver.
+        ERROR
+        SHUTDOWN_SUPPORTED = true
 
         private
 
-        def stop_server
-          # server can only be stopped as process
-        end
-
-        def start_process
-          server_command = [@executable_path, "--port=#{@port}", *@extra_args]
-          @process       = ChildProcess.new(*server_command)
-
-          @process.io.inherit! if $DEBUG
-          @process.start
-        end
-
-        def cannot_connect_error_text
-          "unable to connect to IE server #{@host}:#{@port}"
+        # Note: This processing is deprecated
+        def extract_service_args(driver_opts)
+          driver_args = super
+          driver_opts = driver_opts.dup
+          driver_args << "--log-level=#{driver_opts[:log_level].to_s.upcase}" if driver_opts.key?(:log_level)
+          driver_args << "--log-file=#{driver_opts[:log_file]}" if driver_opts.key?(:log_file)
+          driver_args << "--implementation=#{driver_opts[:implementation].to_s.upcase}" if driver_opts.key?(:implementation)
+          driver_args << "--host=#{driver_opts[:host]}" if driver_opts.key?(:host)
+          driver_args << "--extract_path=#{driver_opts[:extract_path]}" if driver_opts.key?(:extract_path)
+          driver_args << "--silent" if driver_opts[:silent] == true
+          driver_args
         end
       end # Server
     end # IE

data/lib/selenium/webdriver/remote.rb

@@ -1,5 +1,5 @@
-# encoding: utf-8
-#
+# frozen_string_literal: true
+
 # 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
@@ -19,21 +19,19 @@
 
 require 'uri'
 
-require 'selenium/webdriver/remote/capabilities'
-require 'selenium/webdriver/remote/w3c_capabilities'
-require 'selenium/webdriver/remote/bridge'
-require 'selenium/webdriver/remote/w3c_bridge'
-require 'selenium/webdriver/remote/server_error'
-require 'selenium/webdriver/remote/response'
-require 'selenium/webdriver/remote/commands'
-require 'selenium/webdriver/remote/w3c_commands'
-require 'selenium/webdriver/remote/http/common'
-require 'selenium/webdriver/remote/http/default'
-
 module Selenium
   module WebDriver
-    # @api private
     module Remote
-    end # Remote
-  end # WebDriver
-end # Selenium
+      autoload :Bridge, 'selenium/webdriver/remote/bridge'
+      autoload :Driver, 'selenium/webdriver/remote/driver'
+      autoload :Response, 'selenium/webdriver/remote/response'
+      autoload :ServerError, 'selenium/webdriver/remote/server_error'
+      autoload :Capabilities, 'selenium/webdriver/remote/capabilities'
+      autoload :COMMANDS, 'selenium/webdriver/remote/commands'
+      module Http
+        autoload :Common, 'selenium/webdriver/remote/http/common'
+        autoload :Default, 'selenium/webdriver/remote/http/default'
+      end
+    end
+  end
+end

data/lib/selenium/webdriver/remote/bridge.rb

@@ -1,5 +1,5 @@
-# encoding: utf-8
-#
+# frozen_string_literal: true
+
 # 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
@@ -20,96 +20,43 @@
 module Selenium
   module WebDriver
     module Remote
-      #
-      # Low level bridge to the remote server, through which the rest of the API works.
-      #
-      # @api private
-      #
-
       class Bridge
-        include BridgeHelper
-
-        # TODO: constant shouldn't be modified in class
-        COMMANDS = {}
-
-        #
-        # Defines a wrapper method for a command, which ultimately calls #execute.
-        #
-        # @param name [Symbol]
-        #   name of the resulting method
-        # @param url [String]
-        #   a URL template, which can include some arguments, much like the definitions on the server.
-        #   the :session_id parameter is implicitly handled, but the remainder will become required method arguments.
-        # @param verb [Symbol]
-        #   the appropriate http verb, such as :get, :post, or :delete
-        #
+        include Atoms
 
-        def self.command(name, verb, url)
-          COMMANDS[name] = [verb, url.freeze]
-        end
+        PORT = 4444
 
         attr_accessor :context, :http, :file_detector
         attr_reader :capabilities
 
         #
-        # Initializes the bridge with the given server URL.
-        #
-        # @param url         [String] url for the remote server
-        # @param http_client [Object] an HTTP client instance that implements the same protocol as Http::Default
-        # @param desired_capabilities [Capabilities] an instance of Remote::Capabilities describing the capabilities you want
+        # Initializes the bridge with the given server URL
+        # @param [String, URI] :url url for the remote server
+        # @param [Object] :http_client an HTTP client instance that implements the same protocol as Http::Default
+        # @api private
         #
 
-        def initialize(opts = {})
-          opts = opts.dup
-
-          port = opts.delete(:port) || 4444
-          http_client = opts.delete(:http_client) { Http::Default.new }
-          desired_capabilities = opts.delete(:desired_capabilities) { Capabilities.firefox }
-          url = opts.delete(:url) { "http://#{Platform.localhost}:#{port}/wd/hub" }
-
-          unless opts.empty?
-            raise ArgumentError, "unknown option#{'s' if opts.size != 1}: #{opts.inspect}"
-          end
-
-          if desired_capabilities.is_a?(Symbol)
-            unless Capabilities.respond_to?(desired_capabilities)
-              raise Error::WebDriverError, "invalid desired capability: #{desired_capabilities.inspect}"
-            end
-
-            desired_capabilities = Capabilities.send(desired_capabilities)
-          end
-
+        def initialize(http_client: nil, url:)
           uri = url.is_a?(URI) ? url : URI.parse(url)
-          uri.path += '/' unless uri.path =~ %r{\/$}
-
-          http_client.server_url = uri
-
-          @http = http_client
-          @capabilities = create_session(desired_capabilities)
+          uri.path += '/' unless %r{\/$}.match?(uri.path)
 
+          @http = http_client || Http::Default.new
+          @http.server_url = uri
           @file_detector = nil
         end
 
-        def browser
-          @browser ||= (
-            name = @capabilities.browser_name
-            name ? name.tr(' ', '_').to_sym : 'unknown'
-          )
-        end
+        #
+        # Creates session.
+        #
+
+        def create_session(desired_capabilities, options = nil)
+          response = execute(:new_session, {}, merged_capabilities(desired_capabilities, options))
+
+          @session_id = response['sessionId']
+          capabilities = response['capabilities']
 
-        def driver_extensions
-          [
-            DriverExtensions::HasInputDevices,
-            DriverExtensions::UploadsFiles,
-            DriverExtensions::TakesScreenshot,
-            DriverExtensions::HasSessionId,
-            DriverExtensions::Rotatable,
-            DriverExtensions::HasTouchScreen,
-            DriverExtensions::HasLocation,
-            DriverExtensions::HasNetworkConnection,
-            DriverExtensions::HasRemoteStatus,
-            DriverExtensions::HasWebStorage
-          ]
+          raise Error::WebDriverError, 'no sessionId in returned payload' unless @session_id
+
+          @capabilities = Capabilities.json_create(capabilities)
         end
 
         #
@@ -120,12 +67,11 @@ module Selenium
           @session_id || raise(Error::WebDriverError, 'no current session exists')
         end
 
-        def create_session(desired_capabilities)
-          resp = raw_execute :newSession, {}, {desiredCapabilities: desired_capabilities}
-          @session_id = resp['sessionId']
-          return Capabilities.json_create resp['value'] if @session_id
-
-          raise Error::WebDriverError, 'no sessionId in returned payload'
+        def browser
+          @browser ||= begin
+            name = @capabilities.browser_name
+            name ? name.tr(' ', '_').to_sym : 'unknown'
+          end
         end
 
         def status
@@ -136,20 +82,17 @@ module Selenium
           execute :get, {}, {url: url}
         end
 
-        def session_capabilities
-          Capabilities.json_create execute(:getCapabilities)
-        end
-
         def implicit_wait_timeout=(milliseconds)
-          execute :implicitlyWait, {}, {ms: milliseconds}
+          timeout('implicit', milliseconds)
         end
 
         def script_timeout=(milliseconds)
-          execute :setScriptTimeout, {}, {ms: milliseconds}
+          timeout('script', milliseconds)
         end
 
         def timeout(type, milliseconds)
-          execute :setTimeout, {}, {type: type, ms: milliseconds}
+          type = 'pageLoad' if type == 'page load'
+          execute :set_timeout, {}, {type => milliseconds}
         end
 
         #
@@ -157,23 +100,19 @@ module Selenium
         #
 
         def accept_alert
-          execute :acceptAlert
+          execute :accept_alert
         end
 
         def dismiss_alert
-          execute :dismissAlert
+          execute :dismiss_alert
         end
 
         def alert=(keys)
-          execute :setAlertValue, {}, {text: keys.to_s}
+          execute :send_alert_text, {}, {value: keys.split(//), text: keys}
         end
 
         def alert_text
-          execute :getAlertText
-        end
-
-        def authentication(credentials)
-          execute :setAuthentication, {}, credentials
+          execute :get_alert_text
         end
 
         #
@@ -181,51 +120,68 @@ module Selenium
         #
 
         def go_back
-          execute :goBack
+          execute :back
         end
 
         def go_forward
-          execute :goForward
+          execute :forward
         end
 
         def url
-          execute :getCurrentUrl
+          execute :get_current_url
         end
 
         def title
-          execute :getTitle
+          execute :get_title
         end
 
         def page_source
-          execute :getPageSource
+          execute_script('var source = document.documentElement.outerHTML;' \
+                            'if (!source) { source = new XMLSerializer().serializeToString(document); }' \
+                            'return source;')
+        end
+
+        #
+        # Create a new top-level browsing context
+        # https://w3c.github.io/webdriver/#new-window
+        # @param type [String] Supports two values: 'tab' and 'window'.
+        #  Use 'tab' if you'd like the new window to share an OS-level window
+        #  with the current browsing context.
+        #  Use 'window' otherwise
+        # @return [Hash] Containing 'handle' with the value of the window handle
+        #  and 'type' with the value of the created window type
+        #
+        def new_window(type)
+          execute :new_window, {}, {type: type}
         end
 
         def switch_to_window(name)
-          execute :switchToWindow, {}, {name: name}
+          execute :switch_to_window, {}, {handle: name}
         end
 
         def switch_to_frame(id)
-          execute :switchToFrame, {}, {id: id}
+          id = find_element_by('id', id) if id.is_a? String
+          execute :switch_to_frame, {}, {id: id}
         end
 
         def switch_to_parent_frame
-          execute :switchToParentFrame
+          execute :switch_to_parent_frame
         end
 
         def switch_to_default_content
-          switch_to_frame(nil)
+          switch_to_frame nil
         end
 
         QUIT_ERRORS = [IOError].freeze
 
         def quit
-          execute :quit
+          execute :delete_session
           http.close
         rescue *QUIT_ERRORS
         end
 
         def close
-          execute :close
+          execute :close_window
         end
 
         def refresh
@@ -237,42 +193,62 @@ module Selenium
         #
 
         def window_handles
-          execute :getWindowHandles
+          execute :get_window_handles
         end
 
         def window_handle
-          execute :getCurrentWindowHandle
+          execute :get_window_handle
         end
 
         def resize_window(width, height, handle = :current)
-          execute :setWindowSize, {window_handle: handle},
-                  {width: width,
-                   height: height}
-        end
+          raise Error::WebDriverError, 'Switch to desired window before changing its size' unless handle == :current
 
-        def maximize_window(handle = :current)
-          execute :maximizeWindow, window_handle: handle
+          set_window_rect(width: width, height: height)
         end
 
         def window_size(handle = :current)
-          data = execute :getWindowSize, window_handle: handle
+          raise Error::UnsupportedOperationError, 'Switch to desired window before getting its size' unless handle == :current
 
+          data = execute :get_window_rect
           Dimension.new data['width'], data['height']
         end
 
-        def reposition_window(x, y, handle = :current)
-          execute :setWindowPosition, {window_handle: handle},
-                  {x: x, y: y}
+        def minimize_window
+          execute :minimize_window
         end
 
-        def window_position(handle = :current)
-          data = execute :getWindowPosition, window_handle: handle
+        def maximize_window(handle = :current)
+          raise Error::UnsupportedOperationError, 'Switch to desired window before changing its size' unless handle == :current
+
+          execute :maximize_window
+        end
 
+        def full_screen_window
+          execute :fullscreen_window
+        end
+
+        def reposition_window(x, y)
+          set_window_rect(x: x, y: y)
+        end
+
+        def window_position
+          data = execute :get_window_rect
           Point.new data['x'], data['y']
         end
 
+        def set_window_rect(x: nil, y: nil, width: nil, height: nil)
+          params = {x: x, y: y, width: width, height: height}
+          params.update(params) { |_k, v| Integer(v) unless v.nil? }
+          execute :set_window_rect, {}, params
+        end
+
+        def window_rect
+          data = execute :get_window_rect
+          Rectangle.new data['x'], data['y'], data['width'], data['height']
+        end
+
         def screenshot
-          execute :screenshot
+          execute :take_screenshot
         end
 
         #
@@ -281,68 +257,66 @@ module Selenium
 
         def local_storage_item(key, value = nil)
           if value
-            execute :setLocalStorageItem, {}, {key: key, value: value}
+            execute_script("localStorage.setItem('#{key}', '#{value}')")
           else
-            execute :getLocalStorageItem, key: key
+            execute_script("return localStorage.getItem('#{key}')")
           end
         end
 
         def remove_local_storage_item(key)
-          execute :removeLocalStorageItem, key: key
+          execute_script("localStorage.removeItem('#{key}')")
         end
 
         def local_storage_keys
-          execute :getLocalStorageKeys
+          execute_script('return Object.keys(localStorage)')
         end
 
         def clear_local_storage
-          execute :clearLocalStorage
+          execute_script('localStorage.clear()')
         end
 
         def local_storage_size
-          execute :getLocalStorageSize
+          execute_script('return localStorage.length')
         end
 
         def session_storage_item(key, value = nil)
           if value
-            execute :setSessionStorageItem, {}, {key: key, value: value}
+            execute_script("sessionStorage.setItem('#{key}', '#{value}')")
           else
-            execute :getSessionStorageItem, key: key
+            execute_script("return sessionStorage.getItem('#{key}')")
           end
         end
 
         def remove_session_storage_item(key)
-          execute :removeSessionStorageItem, key: key
+          execute_script("sessionStorage.removeItem('#{key}')")
         end
 
         def session_storage_keys
-          execute :getSessionStorageKeys
+          execute_script('return Object.keys(sessionStorage)')
         end
 
         def clear_session_storage
-          execute :clearSessionStorage
+          execute_script('sessionStorage.clear()')
         end
 
         def session_storage_size
-          execute :getSessionStorageSize
+          execute_script('return sessionStorage.length')
         end
 
         def location
-          obj = execute(:getLocation) || {}
-          Location.new obj['latitude'], obj['longitude'], obj['altitude']
+          raise Error::UnsupportedOperationError, 'The W3C standard does not currently support getting location'
         end
 
-        def set_location(lat, lon, alt)
-          loc = {latitude: lat, longitude: lon, altitude: alt}
-          execute :setLocation, {}, {location: loc}
+        def set_location(_lat, _lon, _alt)
+          raise Error::UnsupportedOperationError, 'The W3C standard does not currently support setting location'
         end
 
         def network_connection
-          execute :getNetworkConnection
+          raise Error::UnsupportedOperationError, 'The W3C standard does not currently support getting network connection'
         end
 
-        def network_connection=(type)
-          execute :setNetworkConnection, {}, {parameters: {type: type}}
+        def network_connection=(_type)
+          raise Error::UnsupportedOperationError, 'The W3C standard does not currently support setting network connection'
         end
 
         #
@@ -350,16 +324,12 @@ module Selenium
         #
 
         def execute_script(script, *args)
-          assert_javascript_enabled
-
-          result = execute :executeScript, {}, {script: script, args: args}
+          result = execute :execute_script, {}, {script: script, args: args}
           unwrap_script_result result
         end
 
         def execute_async_script(script, *args)
-          assert_javascript_enabled
-
-          result = execute :executeAsyncScript, {}, {script: script, args: args}
+          result = execute :execute_async_script, {}, {script: script, args: args}
           unwrap_script_result result
         end
 
@@ -367,166 +337,103 @@ module Selenium
         # cookies
         #
 
+        def manage
+          @manage ||= WebDriver::Manager.new(self)
+        end
+
         def add_cookie(cookie)
-          execute :addCookie, {}, {cookie: cookie}
+          execute :add_cookie, {}, {cookie: cookie}
         end
 
         def delete_cookie(name)
-          execute :deleteCookie, name: name
+          execute :delete_cookie, name: name
+        end
+
+        def cookie(name)
+          execute :get_cookie, name: name
         end
 
         def cookies
-          execute :getCookies
+          execute :get_all_cookies
         end
 
         def delete_all_cookies
-          execute :deleteAllCookies
+          execute :delete_all_cookies
         end
 
         #
         # actions
         #
 
-        def click_element(element)
-          execute :clickElement, id: element
-        end
-
-        def click
-          execute :click, {}, {button: 0}
-        end
-
-        def double_click
-          execute :doubleClick
+        def action(async = false)
+          ActionBuilder.new self,
+                            Interactions.pointer(:mouse, name: 'mouse'),
+                            Interactions.key('keyboard'),
+                            async
         end
+        alias_method :actions, :action
 
-        def context_click
-          execute :click, {}, {button: 2}
+        def mouse
+          raise Error::UnsupportedOperationError, '#mouse is no longer supported, use #action instead'
         end
 
-        def mouse_down
-          execute :mouseDown
+        def keyboard
+          raise Error::UnsupportedOperationError, '#keyboard is no longer supported, use #action instead'
         end
 
-        def mouse_up
-          execute :mouseUp
+        def send_actions(data)
+          execute :actions, {}, {actions: data}
         end
 
-        def mouse_move_to(element, x = nil, y = nil)
-          params = {element: element}
-
-          if x && y
-            params[:xoffset] = x
-            params[:yoffset] = y
-          end
-
-          execute :mouseMoveTo, {}, params
+        def release_actions
+          execute :release_actions
         end
 
-        def send_keys_to_active_element(key)
-          execute :sendKeysToActiveElement, {}, {value: key}
+        def click_element(element)
+          execute :element_click, id: element
         end
 
         def send_keys_to_element(element, keys)
+          # TODO: rework file detectors before Selenium 4.0
           if @file_detector
-            local_file = @file_detector.call(keys)
-            keys = upload(local_file) if local_file
+            local_files = keys.first.split("\n").map { |key| @file_detector.call(Array(key)) }.compact
+            if local_files.any?
+              keys = local_files.map { |local_file| upload(local_file) }
+              keys = Array(keys.join("\n"))
+            end
           end
 
-          execute :sendKeysToElement, {id: element}, {value: Array(keys)}
+          # Keep .split(//) for backward compatibility for now
+          text = keys.join('')
+          execute :element_send_keys, {id: element}, {value: text.split(//), text: text}
         end
 
         def upload(local_file)
           unless File.file?(local_file)
-            raise Error::WebDriverError, "you may only upload files: #{local_file.inspect}"
+            WebDriver.logger.debug("File detector only works with files. #{local_file.inspect} isn`t a file!")
+            raise Error::WebDriverError, "You are trying to work with something that isn't a file."
           end
 
-          execute :uploadFile, {}, {file: Zipper.zip_file(local_file)}
+          execute :upload_file, {}, {file: Zipper.zip_file(local_file)}
         end
 
         def clear_element(element)
-          execute :clearElement, id: element
+          execute :element_clear, id: element
         end
 
         def submit_element(element)
-          execute :submitElement, id: element
-        end
-
-        def drag_element(element, right_by, down_by)
-          execute :dragElement, {id: element}, {x: right_by, y: down_by}
-        end
-
-        def touch_single_tap(element)
-          execute :touchSingleTap, {}, {element: element}
-        end
-
-        def touch_double_tap(element)
-          execute :touchDoubleTap, {}, {element: element}
-        end
-
-        def touch_long_press(element)
-          execute :touchLongPress, {}, {element: element}
-        end
-
-        def touch_down(x, y)
-          execute :touchDown, {}, {x: x, y: y}
-        end
-
-        def touch_up(x, y)
-          execute :touchUp, {}, {x: x, y: y}
-        end
-
-        def touch_move(x, y)
-          execute :touchMove, {}, {x: x, y: y}
-        end
-
-        def touch_scroll(element, x, y)
-          if element
-            execute :touchScroll, {}, {element: element,
-                                       xoffset: x,
-                                       yoffset: y}
-          else
-            execute :touchScroll, {}, {xoffset: x, yoffset: y}
-          end
-        end
-
-        def touch_flick(xspeed, yspeed)
-          execute :touchFlick, {}, {xspeed: xspeed, yspeed: yspeed}
-        end
-
-        def touch_element_flick(element, right_by, down_by, speed)
-          execute :touchFlick, {}, {element: element,
-                                    xoffset: right_by,
-                                    yoffset: down_by,
-                                    speed: speed}
+          form = find_element_by('xpath', "./ancestor-or-self::form", element)
+          execute_script("var e = arguments[0].ownerDocument.createEvent('Event');" \
+                            "e.initEvent('submit', true, true);" \
+                            'if (arguments[0].dispatchEvent(e)) { arguments[0].submit() }', form.as_json)
         end
 
         def screen_orientation=(orientation)
-          execute :setScreenOrientation, {}, {orientation: orientation}
+          execute :set_screen_orientation, {}, {orientation: orientation}
         end
 
         def screen_orientation
-          execute :getScreenOrientation
-        end
-
-        #
-        # logs
-        #
-
-        def available_log_types
-          types = execute :getAvailableLogTypes
-          Array(types).map(&:to_sym)
-        end
-
-        def log(type)
-          data = execute :getLog, {}, {type: type.to_s}
-
-          Array(data).map do |l|
-            begin
-              LogEntry.new l.fetch('level', 'UNKNOWN'), l.fetch('timestamp'), l.fetch('message')
-            rescue KeyError
-              next
-            end
-          end
+          execute :get_screen_orientation
         end
 
         #
@@ -534,53 +441,64 @@ module Selenium
         #
 
         def element_tag_name(element)
-          execute :getElementTagName, id: element
+          execute :get_element_tag_name, id: element
         end
 
         def element_attribute(element, name)
-          execute :getElementAttribute, id: element.ref, name: name
+          WebDriver.logger.info "Using script for :getAttribute of #{name}"
+          execute_atom :getAttribute, element, name
+        end
+
+        def element_property(element, name)
+          execute :get_element_property, id: element.ref, name: name
         end
 
         def element_value(element)
-          execute :getElementValue, id: element
+          element_property element, 'value'
         end
 
         def element_text(element)
-          execute :getElementText, id: element
+          execute :get_element_text, id: element
         end
 
         def element_location(element)
-          data = execute :getElementLocation, id: element
+          data = execute :get_element_rect, id: element
 
           Point.new data['x'], data['y']
         end
 
-        def element_location_once_scrolled_into_view(element)
-          data = execute :getElementLocationOnceScrolledIntoView, id: element
+        def element_rect(element)
+          data = execute :get_element_rect, id: element
 
-          Point.new data['x'], data['y']
+          Rectangle.new data['x'], data['y'], data['width'], data['height']
+        end
+
+        def element_location_once_scrolled_into_view(element)
+          send_keys_to_element(element, [''])
+          element_location(element)
         end
 
         def element_size(element)
-          data = execute :getElementSize, id: element
+          data = execute :get_element_rect, id: element
 
           Dimension.new data['width'], data['height']
         end
 
         def element_enabled?(element)
-          execute :isElementEnabled, id: element
+          execute :is_element_enabled, id: element
         end
 
         def element_selected?(element)
-          execute :isElementSelected, id: element
+          execute :is_element_selected, id: element
         end
 
         def element_displayed?(element)
-          execute :isElementDisplayed, id: element
+          WebDriver.logger.info 'Using script for :isDisplayed'
+          execute_atom :isDisplayed, element
         end
 
         def element_value_of_css_property(element, prop)
-          execute :getElementValueOfCssProperty, id: element, property_name: prop
+          execute :get_element_css_value, id: element, property_name: prop
         end
 
         #
@@ -588,26 +506,34 @@ module Selenium
         #
 
         def active_element
-          Element.new self, element_id_from(execute(:getActiveElement))
+          Element.new self, element_id_from(execute(:get_active_element))
         end
 
         alias_method :switch_to_active_element, :active_element
 
         def find_element_by(how, what, parent = nil)
+          how, what = convert_locator(how, what)
+
+          return execute_atom(:findElements, Support::RelativeLocator.new(what).as_json).first if how == 'relative'
+
           id = if parent
-                 execute :findChildElement, {id: parent}, {using: how, value: what}
+                 execute :find_child_element, {id: parent}, {using: how, value: what.to_s}
                else
-                 execute :findElement, {}, {using: how, value: what}
+                 execute :find_element, {}, {using: how, value: what.to_s}
                end
 
           Element.new self, element_id_from(id)
         end
 
         def find_elements_by(how, what, parent = nil)
+          how, what = convert_locator(how, what)
+
+          return execute_atom :findElements, Support::RelativeLocator.new(what).as_json if how == 'relative'
+
           ids = if parent
-                  execute :findChildElements, {id: parent}, {using: how, value: what}
+                  execute :find_child_elements, {id: parent}, {using: how, value: what.to_s}
                 else
-                  execute :findElements, {}, {using: how, value: what}
+                  execute :find_elements, {}, {using: how, value: what.to_s}
                 end
 
           ids.map { |id| Element.new self, element_id_from(id) }
@@ -615,33 +541,17 @@ module Selenium
 
         private
 
-        def assert_javascript_enabled
-          return if capabilities.javascript_enabled?
-          raise Error::UnsupportedOperationError, 'underlying webdriver instance does not support javascript'
-        end
-
-        #
-        # executes a command on the remote server.
-        #
-        #
-        # Returns the 'value' of the returned payload
-        #
-
-        def execute(*args)
-          raw_execute(*args)['value']
-        end
-
         #
         # executes a command on the remote server.
         #
         # @return [WebDriver::Remote::Response]
         #
 
-        def raw_execute(command, opts = {}, command_hash = nil)
-          verb, path = COMMANDS[command] || raise(ArgumentError, "unknown command: #{command.inspect}")
+        def execute(command, opts = {}, command_hash = nil)
+          verb, path = commands(command) || raise(ArgumentError, "unknown command: #{command.inspect}")
           path = path.dup
 
-          path[':session_id'] = @session_id if path.include?(':session_id')
+          path[':session_id'] = session_id if path.include?(':session_id')
 
           begin
             opts.each { |key, value| path[key.inspect] = escaper.escape(value.to_s) }
@@ -649,12 +559,83 @@ module Selenium
             raise ArgumentError, "#{opts.inspect} invalid for #{command.inspect}"
           end
 
-          puts "-> #{verb.to_s.upcase} #{path}" if $DEBUG
-          http.call verb, path, command_hash
+          WebDriver.logger.info("-> #{verb.to_s.upcase} #{path}")
+          http.call(verb, path, command_hash)['value']
         end
 
         def escaper
-          @escaper ||= defined?(URI::Parser) ? URI::Parser.new : URI
+          @escaper ||= defined?(URI::Parser) ? URI::DEFAULT_PARSER : URI
+        end
+
+        def commands(command)
+          COMMANDS[command]
+        end
+
+        def merged_capabilities(capabilities, options = nil)
+          capabilities.merge!(options.as_json) if options
+
+          {
+            capabilities: {
+              firstMatch: [capabilities]
+            }
+          }
+        end
+
+        def unwrap_script_result(arg)
+          case arg
+          when Array
+            arg.map { |e| unwrap_script_result(e) }
+          when Hash
+            element_id = element_id_from(arg)
+            return Element.new(self, element_id) if element_id
+
+            arg.each { |k, v| arg[k] = unwrap_script_result(v) }
+          else
+            arg
+          end
+        end
+
+        def element_id_from(id)
+          id['ELEMENT'] || id['element-6066-11e4-a52e-4f735466cecf']
+        end
+
+        def convert_locator(how, what)
+          how = SearchContext::FINDERS[how.to_sym] || how
+
+          case how
+          when 'class name'
+            how = 'css selector'
+            what = ".#{escape_css(what.to_s)}"
+          when 'id'
+            how = 'css selector'
+            what = "##{escape_css(what.to_s)}"
+          when 'name'
+            how = 'css selector'
+            what = "*[name='#{escape_css(what.to_s)}']"
+          when 'tag name'
+            how = 'css selector'
+          end
+
+          if what.is_a?(Hash)
+            what = what.each_with_object({}) do |(h, w), hash|
+              h, w = convert_locator(h.to_s, w)
+              hash[h] = w
+            end
+          end
+
+          [how, what]
+        end
+
+        ESCAPE_CSS_REGEXP = /(['"\\#.:;,!?+<>=~*^$|%&@`{}\-\[\]\(\)])/.freeze
+        UNICODE_CODE_POINT = 30
+
+        # Escapes invalid characters in CSS selector.
+        # @see https://mathiasbynens.be/notes/css-escapes
+        def escape_css(string)
+          string = string.gsub(ESCAPE_CSS_REGEXP) { |match| "\\#{match}" }
+          string = "\\#{UNICODE_CODE_POINT + Integer(string[0])} #{string[1..-1]}" if string[0]&.match?(/[[:digit:]]/)
+
+          string
         end
       end # Bridge
     end # Remote