selenium-webdriver 3.142.7 → 4.0.0.alpha1

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

@@ -0,0 +1,47 @@
+# 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 Firefox
+      module Bridge
+
+        COMMANDS = {
+          install_addon: [:post, 'session/:session_id/moz/addon/install'],
+          uninstall_addon: [:post, 'session/:session_id/moz/addon/uninstall']
+        }.freeze
+
+        def commands(command)
+          COMMANDS[command] || super
+        end
+
+        def install_addon(path, temporary)
+          payload = {path: path}
+          payload[:temporary] = temporary unless temporary.nil?
+          execute :install_addon, {}, payload
+        end
+
+        def uninstall_addon(id)
+          execute :uninstall_addon, {}, {id: id}
+        end
+
+      end # Bridge
+    end # Firefox
+  end # WebDriver
+end # Selenium

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

@@ -20,30 +20,52 @@
 module Selenium
   module WebDriver
     module Firefox
-      module Driver
-        class << self
-
-          #
-          # Instantiates correct Firefox driver implementation
-          # @return [Marionette::Driver, Legacy::Driver]
-          #
-
-          def new(**opts)
-            if marionette?(opts)
-              Firefox::Marionette::Driver.new(opts)
-            else
-              Firefox::Legacy::Driver.new(opts)
-            end
-          end
-
-          private
-
-          def marionette?(opts)
-            opts.delete(:marionette) != false &&
-              (!opts[:desired_capabilities] || opts[:desired_capabilities][:marionette] != false)
-          end
+
+      #
+      # Driver implementation for Firefox using GeckoDriver.
+      # @api private
+      #
+
+      class Driver < WebDriver::Driver
+        include DriverExtensions::HasAddons
+        include DriverExtensions::HasWebStorage
+        include DriverExtensions::TakesScreenshot
+
+        def initialize(opts = {})
+          opts[:desired_capabilities] = create_capabilities(opts)
+
+          opts[:url] ||= service_url(opts)
+
+          listener = opts.delete(:listener)
+          desired_capabilities = opts.delete(:desired_capabilities)
+
+          @bridge = Remote::Bridge.new(opts)
+          @bridge.extend Bridge
+          @bridge.create_session(desired_capabilities)
+
+          super(@bridge, listener: listener)
         end
 
+        def browser
+          :firefox
+        end
+
+        def quit
+          super
+        ensure
+          @service&.stop
+        end
+
+        private
+
+        def create_capabilities(opts)
+          caps = opts.delete(:desired_capabilities) { Remote::Capabilities.firefox }
+          options = opts.delete(:options) { Options.new }
+          options = options.as_json
+          caps.merge!(options) unless options.empty?
+
+          caps
+        end
       end # Driver
     end # Firefox
   end # WebDriver

data/lib/selenium/webdriver/firefox/marionette/driver.rb

@@ -42,7 +42,7 @@ module Selenium
             desired_capabilities = opts.delete(:desired_capabilities)
             bridge = Remote::Bridge.new(opts)
             capabilities = bridge.create_session(desired_capabilities)
-            @bridge = Remote::W3C::Bridge.new(capabilities, bridge.session_id, **opts)
+            @bridge = Remote::W3C::Bridge.new(capabilities, bridge.session_id, opts)
             @bridge.extend Marionette::Bridge
 
             super(@bridge, listener: listener)

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

@@ -20,7 +20,7 @@
 module Selenium
   module WebDriver
     module Firefox
-      class Options < WebDriver::Common::Options
+      class Options
         attr_reader :args, :prefs, :options, :profile
         attr_accessor :binary, :log_level
 
@@ -139,7 +139,7 @@ module Selenium
           opts[:prefs] = @prefs unless @prefs.empty?
           opts[:log] = {level: @log_level} if @log_level
 
-          {KEY => generate_as_json(opts)}
+          {KEY => opts}
         end
 
         private

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

@@ -73,20 +73,9 @@ module Selenium
           model_prefs = read_model_prefs
 
           if model_prefs.empty?
-            @native_events     = DEFAULT_ENABLE_NATIVE_EVENTS
-            @secure_ssl        = DEFAULT_SECURE_SSL
-            @untrusted_issuer  = DEFAULT_ASSUME_UNTRUSTED_ISSUER
-            @load_no_focus_lib = DEFAULT_LOAD_NO_FOCUS_LIB
-
-            @additional_prefs  = {}
+            assign_default_preferences
           else
-            # TODO: clean this up
-            @native_events     = model_prefs.delete(WEBDRIVER_PREFS[:native_events]) == 'true'
-            @secure_ssl        = model_prefs.delete(WEBDRIVER_PREFS[:untrusted_certs]) != 'true'
-            @untrusted_issuer  = model_prefs.delete(WEBDRIVER_PREFS[:untrusted_issuer]) == 'true'
-            # not stored in profile atm, so will always be false.
-            @load_no_focus_lib = model_prefs.delete(WEBDRIVER_PREFS[:load_no_focus_lib]) == 'true'
-            @additional_prefs  = model_prefs
+            assign_updated_preferences(model_prefs)
           end
 
           @extensions = {}
@@ -116,7 +105,7 @@ module Selenium
             raise TypeError, "expected one of #{VALID_PREFERENCE_TYPES.inspect}, got #{value.inspect}:#{value.class}"
           end
 
-          if value.is_a?(String) && Util.stringified?(value)
+          if value.is_a?(String) && stringified?(value)
             raise ArgumentError, "preference values must be plain strings: #{key.inspect} => #{value.inspect}"
           end
 
@@ -195,6 +184,24 @@ module Selenium
 
         private
 
+        def assign_default_preferences
+          @native_events     = DEFAULT_ENABLE_NATIVE_EVENTS
+          @secure_ssl        = DEFAULT_SECURE_SSL
+          @untrusted_issuer  = DEFAULT_ASSUME_UNTRUSTED_ISSUER
+          @load_no_focus_lib = DEFAULT_LOAD_NO_FOCUS_LIB
+
+          @additional_prefs  = {}
+        end
+
+        def assign_updated_preferences(model_prefs)
+          @native_events     = model_prefs.delete(WEBDRIVER_PREFS[:native_events]) == 'true'
+          @secure_ssl        = model_prefs.delete(WEBDRIVER_PREFS[:untrusted_certs]) != 'true'
+          @untrusted_issuer  = model_prefs.delete(WEBDRIVER_PREFS[:untrusted_issuer]) == 'true'
+          # not stored in profile atm, so will always be false.
+          @load_no_focus_lib = model_prefs.delete(WEBDRIVER_PREFS[:load_no_focus_lib]) == 'true'
+          @additional_prefs  = model_prefs
+        end
+
         def set_manual_proxy_preference(key, value)
           return unless value
 
@@ -275,6 +282,10 @@ module Selenium
             end
           end
         end
+
+        def stringified?(str)
+          /^".*"$/.match?(str)
+        end
       end # Profile
     end # Firefox
   end # WebDriver

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

@@ -25,14 +25,14 @@ module Selenium
       #
 
       class Service < WebDriver::Service
-        @default_port = 4444
-        @executable = 'geckodriver'
-        @missing_text = <<~ERROR
+        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
+        SHUTDOWN_SUPPORTED = false
 
         private
 

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

@@ -37,7 +37,11 @@ module Selenium
           opts[:url] ||= service_url(opts)
 
           listener = opts.delete(:listener)
-          @bridge = Remote::Bridge.handshake(**opts)
+          desired_capabilities = opts.delete(:desired_capabilities)
+
+          @bridge = Remote::Bridge.new(opts)
+          @bridge.create_session(desired_capabilities)
+
           super(@bridge, listener: listener)
         end
 
@@ -56,23 +60,6 @@ module Selenium
         def create_capabilities(opts)
           caps = opts.delete(:desired_capabilities) { Remote::Capabilities.internet_explorer }
           options = opts.delete(:options) { Options.new }
-
-          if opts.delete(:introduce_flakiness_by_ignoring_security_domains)
-            WebDriver.logger.deprecate ':introduce_flakiness_by_ignoring_security_domains',
-                                       'Selenium::WebDriver::IE::Options#ignore_protected_mode_settings='
-            options.ignore_protected_mode_settings = true
-          end
-
-          native_events = opts.delete(:native_events)
-          unless native_events.nil?
-            WebDriver.logger.deprecate ':native_events', 'Selenium::WebDriver::IE::Options#native_events='
-            options.native_events = native_events
-          end
-
-          # Backward compatibility with older IEDriverServer versions
-          caps[:ignore_protected_mode_settings] = options.ignore_protected_mode_settings
-          caps[:native_events] = options.native_events
-
           options = options.as_json
           caps.merge!(options) unless options.empty?
 

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

@@ -20,7 +20,7 @@
 module Selenium
   module WebDriver
     module IE
-      class Options < WebDriver::Common::Options
+      class Options
         KEY = 'se:ieOptions'
         SCROLL_TOP = 0
         SCROLL_BOTTOM = 1
@@ -130,7 +130,7 @@ module Selenium
           opts['ie.browserCommandLineSwitches'] = @args.to_a.join(' ') if @args.any?
           opts.merge!(@options)
 
-          {KEY => generate_as_json(opts)}
+          {KEY => opts}
         end
       end # Options
     end # IE

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

@@ -25,14 +25,14 @@ module Selenium
       #
 
       class Service < WebDriver::Service
-        @default_port = 5555
-        @executable = 'IEDriverServer'
-        @missing_text = <<~ERROR
+        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
+        SHUTDOWN_SUPPORTED = true
 
         private
 

data/lib/selenium/webdriver/remote.rb

@@ -26,10 +26,6 @@ require 'selenium/webdriver/remote/server_error'
 require 'selenium/webdriver/remote/http/common'
 require 'selenium/webdriver/remote/http/default'
 
+require 'selenium/webdriver/remote/bridge'
 require 'selenium/webdriver/remote/capabilities'
-require 'selenium/webdriver/remote/oss/bridge'
-require 'selenium/webdriver/remote/oss/commands'
-
-require 'selenium/webdriver/remote/w3c/bridge'
-require 'selenium/webdriver/remote/w3c/capabilities'
-require 'selenium/webdriver/remote/w3c/commands'
+require 'selenium/webdriver/remote/commands'

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

@@ -22,48 +22,11 @@ module Selenium
     module Remote
       class Bridge
         include Atoms
-        include BridgeHelper
 
         PORT = 4444
-        COMMANDS = {
-          new_session: [:post, 'session']
-        }.freeze
 
         attr_accessor :context, :http, :file_detector
-        attr_reader :capabilities, :dialect
-
-        #
-        # Implements protocol handshake which:
-        #
-        #   1. Creates session with driver.
-        #   2. Sniffs response.
-        #   3. Based on the response, understands which dialect we should use.
-        #
-        # @return [OSS:Bridge, W3C::Bridge]
-        #
-        def self.handshake(**opts)
-          desired_capabilities = opts.delete(:desired_capabilities) { Capabilities.new }
-
-          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
-
-          bridge = new(opts)
-          capabilities = bridge.create_session(desired_capabilities, opts.delete(:options))
-
-          case bridge.dialect
-          when :oss
-            Remote::OSS::Bridge.new(capabilities, bridge.session_id, **opts)
-          when :w3c
-            Remote::W3C::Bridge.new(capabilities, bridge.session_id, **opts)
-          else
-            raise WebDriverError, 'cannot understand dialect'
-          end
-        end
+        attr_reader :capabilities
 
         #
         # Initializes the bridge with the given server URL
@@ -86,7 +49,7 @@ module Selenium
           end
 
           uri = url.is_a?(URI) ? url : URI.parse(url)
-          uri.path += '/' unless uri.path =~ %r{\/$}
+          uri.path += '/' unless %r{\/$}.match?(uri.path)
 
           http_client.server_url = uri
 
@@ -95,37 +58,18 @@ module Selenium
         end
 
         #
-        # Creates session handling both OSS and W3C dialects.
+        # Creates session.
         #
 
         def create_session(desired_capabilities, options = nil)
           response = execute(:new_session, {}, merged_capabilities(desired_capabilities, options))
 
           @session_id = response['sessionId']
-          oss_status = response['status']
-          value = response['value']
-
-          if value.is_a?(Hash)
-            @session_id = value['sessionId'] if value.key?('sessionId')
-
-            if value.key?('capabilities')
-              value = value['capabilities']
-            elsif value.key?('value')
-              value = value['value']
-            end
-          end
+          capabilities = response['capabilities']
 
           raise Error::WebDriverError, 'no sessionId in returned payload' unless @session_id
 
-          if oss_status
-            WebDriver.logger.info 'Detected OSS dialect.'
-            @dialect = :oss
-            Capabilities.json_create(value)
-          else
-            WebDriver.logger.info 'Detected W3C dialect.'
-            @dialect = :w3c
-            W3C::Capabilities.json_create(value)
-          end
+          @capabilities = Capabilities.json_create(capabilities)
         end
 
         #
@@ -143,6 +87,466 @@ module Selenium
           end
         end
 
+        def status
+          execute :status
+        end
+
+        def get(url)
+          execute :get, {}, {url: url}
+        end
+
+        def implicit_wait_timeout=(milliseconds)
+          timeout('implicit', milliseconds)
+        end
+
+        def script_timeout=(milliseconds)
+          timeout('script', milliseconds)
+        end
+
+        def timeout(type, milliseconds)
+          type = 'pageLoad' if type == 'page load'
+          execute :set_timeout, {}, {type => milliseconds}
+        end
+
+        #
+        # alerts
+        #
+
+        def accept_alert
+          execute :accept_alert
+        end
+
+        def dismiss_alert
+          execute :dismiss_alert
+        end
+
+        def alert=(keys)
+          execute :send_alert_text, {}, {value: keys.split(//), text: keys}
+        end
+
+        def alert_text
+          execute :get_alert_text
+        end
+
+        #
+        # navigation
+        #
+
+        def go_back
+          execute :back
+        end
+
+        def go_forward
+          execute :forward
+        end
+
+        def url
+          execute :get_current_url
+        end
+
+        def title
+          execute :get_title
+        end
+
+        def page_source
+          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 :switch_to_window, {}, {handle: name}
+        end
+
+        def switch_to_frame(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 :switch_to_parent_frame
+        end
+
+        def switch_to_default_content
+          switch_to_frame nil
+        end
+
+        QUIT_ERRORS = [IOError].freeze
+
+        def quit
+          execute :delete_session
+          http.close
+        rescue *QUIT_ERRORS
+        end
+
+        def close
+          execute :close_window
+        end
+
+        def refresh
+          execute :refresh
+        end
+
+        #
+        # window handling
+        #
+
+        def window_handles
+          execute :get_window_handles
+        end
+
+        def window_handle
+          execute :get_window_handle
+        end
+
+        def resize_window(width, height, handle = :current)
+          raise Error::WebDriverError, 'Switch to desired window before changing its size' unless handle == :current
+
+          set_window_rect(width: width, height: height)
+        end
+
+        def window_size(handle = :current)
+          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 minimize_window
+          execute :minimize_window
+        end
+
+        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 :take_screenshot
+        end
+
+        #
+        # HTML 5
+        #
+
+        def local_storage_item(key, value = nil)
+          if value
+            execute_script("localStorage.setItem('#{key}', '#{value}')")
+          else
+            execute_script("return localStorage.getItem('#{key}')")
+          end
+        end
+
+        def remove_local_storage_item(key)
+          execute_script("localStorage.removeItem('#{key}')")
+        end
+
+        def local_storage_keys
+          execute_script('return Object.keys(localStorage)')
+        end
+
+        def clear_local_storage
+          execute_script('localStorage.clear()')
+        end
+
+        def local_storage_size
+          execute_script('return localStorage.length')
+        end
+
+        def session_storage_item(key, value = nil)
+          if value
+            execute_script("sessionStorage.setItem('#{key}', '#{value}')")
+          else
+            execute_script("return sessionStorage.getItem('#{key}')")
+          end
+        end
+
+        def remove_session_storage_item(key)
+          execute_script("sessionStorage.removeItem('#{key}')")
+        end
+
+        def session_storage_keys
+          execute_script('return Object.keys(sessionStorage)')
+        end
+
+        def clear_session_storage
+          execute_script('sessionStorage.clear()')
+        end
+
+        def session_storage_size
+          execute_script('return sessionStorage.length')
+        end
+
+        def location
+          raise Error::UnsupportedOperationError, 'The W3C standard does not currently support getting location'
+        end
+
+        def set_location(_lat, _lon, _alt)
+          raise Error::UnsupportedOperationError, 'The W3C standard does not currently support setting location'
+        end
+
+        def network_connection
+          raise Error::UnsupportedOperationError, 'The W3C standard does not currently support getting network connection'
+        end
+
+        def network_connection=(_type)
+          raise Error::UnsupportedOperationError, 'The W3C standard does not currently support setting network connection'
+        end
+
+        #
+        # javascript execution
+        #
+
+        def execute_script(script, *args)
+          result = execute :execute_script, {}, {script: script, args: args}
+          unwrap_script_result result
+        end
+
+        def execute_async_script(script, *args)
+          result = execute :execute_async_script, {}, {script: script, args: args}
+          unwrap_script_result result
+        end
+
+        #
+        # cookies
+        #
+
+        def manage
+          @manage ||= WebDriver::Manager.new(self)
+        end
+
+        def add_cookie(cookie)
+          execute :add_cookie, {}, {cookie: cookie}
+        end
+
+        def delete_cookie(name)
+          execute :delete_cookie, name: name
+        end
+
+        def cookie(name)
+          execute :get_cookie, name: name
+        end
+
+        def cookies
+          execute :get_all_cookies
+        end
+
+        def delete_all_cookies
+          execute :delete_all_cookies
+        end
+
+        #
+        # actions
+        #
+
+        def action(async = false)
+          ActionBuilder.new self,
+                            Interactions.pointer(:mouse, name: 'mouse'),
+                            Interactions.key('keyboard'),
+                            async
+        end
+        alias_method :actions, :action
+
+        def mouse
+          raise Error::UnsupportedOperationError, '#mouse is no longer supported, use #action instead'
+        end
+
+        def keyboard
+          raise Error::UnsupportedOperationError, '#keyboard is no longer supported, use #action instead'
+        end
+
+        def send_actions(data)
+          execute :actions, {}, {actions: data}
+        end
+
+        def release_actions
+          execute :release_actions
+        end
+
+        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_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
+
+          # 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)
+            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 :upload_file, {}, {file: Zipper.zip_file(local_file)}
+        end
+
+        def clear_element(element)
+          execute :element_clear, id: element
+        end
+
+        def submit_element(element)
+          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 :set_screen_orientation, {}, {orientation: orientation}
+        end
+
+        def screen_orientation
+          execute :get_screen_orientation
+        end
+
+        #
+        # element properties
+        #
+
+        def element_tag_name(element)
+          execute :get_element_tag_name, id: element
+        end
+
+        def element_attribute(element, 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)
+          element_property element, 'value'
+        end
+
+        def element_text(element)
+          execute :get_element_text, id: element
+        end
+
+        def element_location(element)
+          data = execute :get_element_rect, id: element
+
+          Point.new data['x'], data['y']
+        end
+
+        def element_rect(element)
+          data = execute :get_element_rect, id: element
+
+          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 :get_element_rect, id: element
+
+          Dimension.new data['width'], data['height']
+        end
+
+        def element_enabled?(element)
+          execute :is_element_enabled, id: element
+        end
+
+        def element_selected?(element)
+          execute :is_element_selected, id: element
+        end
+
+        def element_displayed?(element)
+          WebDriver.logger.info 'Using script for :isDisplayed'
+          execute_atom :isDisplayed, element
+        end
+
+        def element_value_of_css_property(element, prop)
+          execute :get_element_css_value, id: element, property_name: prop
+        end
+
+        #
+        # finding elements
+        #
+
+        def active_element
+          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_locators(how, what)
+
+          id = if parent
+                 execute :find_child_element, {id: parent}, {using: how, value: what}
+               else
+                 execute :find_element, {}, {using: how, value: what}
+               end
+          Element.new self, element_id_from(id)
+        end
+
+        def find_elements_by(how, what, parent = nil)
+          how, what = convert_locators(how, what)
+
+          ids = if parent
+                  execute :find_child_elements, {id: parent}, {using: how, value: what}
+                else
+                  execute :find_elements, {}, {using: how, value: what}
+                end
+
+          ids.map { |id| Element.new self, element_id_from(id) }
+        end
+
         private
 
         #
@@ -164,7 +568,7 @@ module Selenium
           end
 
           WebDriver.logger.info("-> #{verb.to_s.upcase} #{path}")
-          http.call(verb, path, command_hash)
+          http.call(verb, path, command_hash)['value']
         end
 
         def escaper
@@ -172,23 +576,65 @@ module Selenium
         end
 
         def commands(command)
-          raise NotImplementedError unless command == :new_session
-
           COMMANDS[command]
         end
 
-        def merged_capabilities(oss_capabilities, options = nil)
-          w3c_capabilities = W3C::Capabilities.from_oss(oss_capabilities)
-          w3c_capabilities.merge!(options.as_json) if options
+        def merged_capabilities(capabilities, options = nil)
+          capabilities.merge!(options.as_json) if options
 
           {
-            desiredCapabilities: oss_capabilities,
             capabilities: {
-              firstMatch: [w3c_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_locators(how, what)
+          case how
+          when 'class name'
+            how = 'css selector'
+            what = ".#{escape_css(what)}"
+          when 'id'
+            how = 'css selector'
+            what = "##{escape_css(what)}"
+          when 'name'
+            how = 'css selector'
+            what = "*[name='#{escape_css(what)}']"
+          when 'tag name'
+            how = 'css selector'
+          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.empty? && string[0].match?(/[[:digit:]]/)
+
+          string
+        end
       end # Bridge
     end # Remote
   end # WebDriver