selenium-webdriver 4.0.0.alpha2 → 4.0.0

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

@@ -39,23 +39,17 @@ module Selenium
           :timeouts,
           :unhandled_prompt_behavior,
           :strict_file_interactability,
+          :web_socket_url,
 
-          # remote-specific
-          :remote_session_id,
-
-          # TODO: (AR) deprecate compatibility with OSS-capabilities
-          :implicit_timeout,
-          :page_load_timeout,
-          :script_timeout
+          # remote-specific (webdriver.remote.sessionid)
+          :remote_session_id
         ].freeze
 
-        KNOWN.each do |key|
+        (KNOWN - %i[proxy timeouts]).each do |key|
           define_method key do
-            @capabilities.fetch(key)
+            @capabilities[key]
           end
 
-          next if key == :proxy
-
           define_method "#{key}=" do |value|
             @capabilities[key] = value
           end
@@ -83,27 +77,21 @@ module Selenium
 
           def edge(opts = {})
             new({
-              browser_name: 'MicrosoftEdge',
-              platform_name: :windows
+              browser_name: 'MicrosoftEdge'
             }.merge(opts))
           end
+          alias_method :microsoftedge, :edge
 
           def firefox(opts = {})
-            opts[:browser_version] = opts.delete(:version) if opts.key?(:version)
-            opts[:platform_name] = opts.delete(:platform) if opts.key?(:platform)
-            opts[:timeouts] = {}
-            opts[:timeouts]['implicit'] = opts.delete(:implicit_timeout) if opts.key?(:implicit_timeout)
-            opts[:timeouts]['pageLoad'] = opts.delete(:page_load_timeout) if opts.key?(:page_load_timeout)
-            opts[:timeouts]['script'] = opts.delete(:script_timeout) if opts.key?(:script_timeout)
-            new({browser_name: 'firefox'}.merge(opts))
+            new({
+              browser_name: 'firefox'
+            }.merge(opts))
           end
-
           alias_method :ff, :firefox
 
           def safari(opts = {})
             new({
-              browser_name: 'safari',
-              platform_name: :mac
+              browser_name: Selenium::WebDriver::Safari.technology_preview? ? "Safari Technology Preview" : 'safari'
             }.merge(opts))
           end
 
@@ -121,26 +109,23 @@ module Selenium
           end
           alias_method :ie, :internet_explorer
 
+          def always_match(capabilities)
+            new(always_match: capabilities)
+          end
+
+          def first_match(*capabilities)
+            new(first_match: capabilities)
+          end
+
           #
           # @api private
           #
 
           def json_create(data)
             data = data.dup
-
             caps = new
-            caps.browser_name = data.delete('browserName') if data.key?('browserName')
-            caps.browser_version = data.delete('browserVersion') if data.key?('browserVersion')
-            caps.platform_name = data.delete('platformName') if data.key?('platformName')
-            caps.accept_insecure_certs = data.delete('acceptInsecureCerts') if data.key?('acceptInsecureCerts')
-            caps.page_load_strategy = data.delete('pageLoadStrategy') if data.key?('pageLoadStrategy')
-
-            if data.key?('timeouts')
-              timeouts = data.delete('timeouts')
-              caps.implicit_timeout = timeouts['implicit'] if timeouts
-              caps.page_load_timeout = timeouts['pageLoad'] if timeouts
-              caps.script_timeout = timeouts['script'] if timeouts
-            end
+
+            process_timeouts(caps, data.delete('timeouts'))
 
             if data.key?('proxy')
               proxy = data.delete('proxy')
@@ -148,13 +133,34 @@ module Selenium
             end
 
             # Remote Server Specific
-            caps[:remote_session_id] = data.delete('webdriver.remote.sessionid') if data.key?('webdriver.remote.sessionid')
+            if data.key?('webdriver.remote.sessionid')
+              caps[:remote_session_id] = data.delete('webdriver.remote.sessionid')
+            end
+
+            KNOWN.each do |cap|
+              data_value = camel_case(cap)
+              caps[cap] = data.delete(data_value) if data.key?(data_value)
+            end
 
             # any remaining pairs will be added as is, with no conversion
             caps.merge!(data)
 
             caps
           end
+
+          def camel_case(str_or_sym)
+            str_or_sym.to_s.gsub(/_([a-z])/) { Regexp.last_match(1).upcase }
+          end
+
+          private
+
+          def process_timeouts(caps, timeouts)
+            return if timeouts.nil?
+
+            caps.implicit_timeout = timeouts['implicit']
+            caps.page_load_timeout = timeouts['pageLoad']
+            caps.script_timeout = timeouts['script']
+          end
         end
 
         #
@@ -169,8 +175,9 @@ module Selenium
         #
 
         def initialize(opts = {})
-          @capabilities = opts
-          self.proxy = opts.delete(:proxy)
+          @capabilities = {}
+          self.proxy = opts.delete(:proxy) if opts[:proxy]
+          @capabilities.merge!(opts)
         end
 
         #
@@ -195,6 +202,10 @@ module Selenium
           end
         end
 
+        def proxy
+          @capabilities[:proxy]
+        end
+
         def proxy=(proxy)
           case proxy
           when Hash
@@ -206,33 +217,46 @@ module Selenium
           end
         end
 
+        def timeouts
+          @capabilities[:timeouts] ||= {}
+        end
+
+        def timeouts=(timeouts)
+          @capabilities[:timeouts] = timeouts
+        end
+
+        def implicit_timeout
+          timeouts[:implicit]
+        end
+
+        def implicit_timeout=(timeout)
+          timeouts[:implicit] = timeout
+        end
+
+        def page_load_timeout
+          timeouts[:page_load] || timeouts[:pageLoad]
+        end
+
+        def page_load_timeout=(timeout)
+          timeouts[:page_load] = timeout
+        end
+
+        def script_timeout
+          timeouts[:script]
+        end
+
+        def script_timeout=(timeout)
+          timeouts[:script] = timeout
+        end
+
         #
         # @api private
         #
 
         def as_json(*)
-          hash = {}
-
-          @capabilities.each do |key, value|
-            case key
-            when :platform
-              hash['platform'] = value.to_s.upcase
-            when :proxy
-              if value
-                hash['proxy'] = value.as_json
-                hash['proxy']['proxyType'] &&= hash['proxy']['proxyType'].downcase
-                hash['proxy']['noProxy'] = hash['proxy']['noProxy'].split(', ') if hash['proxy']['noProxy'].is_a?(String)
-              end
-            when String
-              hash[key.to_s] = value
-            when Symbol
-              hash[camel_case(key.to_s)] = value
-            else
-              raise TypeError, "expected String or Symbol, got #{key.inspect}:#{key.class} / #{value.inspect}"
-            end
+          @capabilities.each_with_object({}) do |(key, value), hash|
+            hash[convert_key(key)] = process_capabilities(key, value, hash)
           end
-
-          hash
         end
 
         def to_json(*)
@@ -253,10 +277,44 @@ module Selenium
 
         private
 
-        def camel_case(str)
-          str.gsub(/_([a-z])/) { Regexp.last_match(1).upcase }
+        def process_capabilities(key, value, hash)
+          case value
+          when Array
+            value.map { |v| process_capabilities(key, v, hash) }
+          when Hash
+            value.each_with_object({}) do |(k, v), h|
+              h[convert_key(k)] = process_capabilities(k, v, h)
+            end
+          when Capabilities, Options
+            value.as_json
+          else
+            convert_value(key, value)
+          end
         end
 
+        def convert_key(key)
+          case key
+          when String
+            key.to_s
+          when Symbol
+            self.class.camel_case(key)
+          else
+            raise TypeError, "expected String or Symbol, got #{key.inspect}:#{key.class}"
+          end
+        end
+
+        def convert_value(key, value)
+          case key
+          when :platform
+            value.to_s.upcase
+          when :proxy
+            value&.as_json
+          when :unhandled_prompt_behavior
+            value.is_a?(Symbol) ? value.to_s.tr('_', ' ') : value
+          else
+            value
+          end
+        end
       end # Capabilities
     end # Remote
   end # WebDriver

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

@@ -77,11 +77,16 @@ module Selenium
           find_elements: [:post, 'session/:session_id/elements'],
           find_child_element: [:post, 'session/:session_id/element/:id/element'],
           find_child_elements: [:post, 'session/:session_id/element/:id/elements'],
+          find_shadow_child_element: [:post, 'session/:session_id/shadow/:id/element'],
+          find_shadow_child_elements: [:post, 'session/:session_id/shadow/:id/elements'],
           get_active_element: [:get, 'session/:session_id/element/active'],
+          get_element_shadow_root: [:get, 'session/:session_id/element/:id/shadow'],
           is_element_selected: [:get, 'session/:session_id/element/:id/selected'],
           get_element_attribute: [:get, 'session/:session_id/element/:id/attribute/:name'],
           get_element_property: [:get, 'session/:session_id/element/:id/property/:name'],
           get_element_css_value: [:get, 'session/:session_id/element/:id/css/:property_name'],
+          get_element_aria_role: [:get, 'session/:session_id/element/:id/computedrole'],
+          get_element_aria_label: [:get, 'session/:session_id/element/:id/computedlabel'],
           get_element_text: [:get, 'session/:session_id/element/:id/text'],
           get_element_tag_name: [:get, 'session/:session_id/element/:id/name'],
           get_element_rect: [:get, 'session/:session_id/element/:id/rect'],
@@ -109,6 +114,7 @@ module Selenium
           # timeouts
           #
 
+          get_timeouts: [:get, 'session/:session_id/timeouts'],
           set_timeout: [:post, 'session/:session_id/timeouts'],
 
           #
@@ -117,6 +123,7 @@ module Selenium
 
           actions: [:post, 'session/:session_id/actions'],
           release_actions: [:delete, 'session/:session_id/actions'],
+          print_page: [:post, 'session/:session_id/print'],
 
           #
           # Element Operations

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

@@ -28,30 +28,33 @@ module Selenium
 
       class Driver < WebDriver::Driver
         include DriverExtensions::UploadsFiles
-        include DriverExtensions::TakesScreenshot
         include DriverExtensions::HasSessionId
-        include DriverExtensions::Rotatable
         include DriverExtensions::HasRemoteStatus
-        include DriverExtensions::HasWebStorage
-
-        def initialize(opts = {})
-          listener = opts.delete(:listener)
-          desired_capabilities = opts.delete(:desired_capabilities) { Capabilities.new }
 
+        def initialize(bridge: nil, listener: nil, **opts)
+          desired_capabilities = opts[:desired_capabilities]
           if desired_capabilities.is_a?(Symbol)
-            unless Capabilities.respond_to?(desired_capabilities)
+            unless Remote::Capabilities.respond_to?(desired_capabilities)
               raise Error::WebDriverError, "invalid desired capability: #{desired_capabilities.inspect}"
             end
 
-            desired_capabilities = Capabilities.__send__(desired_capabilities)
+            opts[:desired_capabilities] = Remote::Capabilities.__send__(desired_capabilities)
           end
+          opts[:url] ||= "http://#{Platform.localhost}:4444/wd/hub"
+          super
+          @bridge.file_detector = ->((filename, *)) { File.exist?(filename) && filename.to_s }
+        end
 
-          @bridge = Bridge.new(opts)
-          @bridge.create_session(desired_capabilities, opts.delete(:options))
+        private
 
-          super(@bridge, listener: listener)
+        def devtools_url
+          capabilities['se:cdp']
         end
 
+        def devtools_version
+          capabilities['se:cdpVersion']&.split('.')&.first ||
+            raise(Error::WebDriverError, "DevTools is not supported by the Remote Server")
+        end
       end # Driver
     end # Remote
   end # WebDriver

data/lib/selenium/webdriver/remote/http/common.rb

@@ -30,13 +30,8 @@ module Selenium
             'User-Agent' => "selenium/#{WebDriver::VERSION} (ruby #{Platform.os})"
           }.freeze
 
-          attr_accessor :timeout
           attr_writer :server_url
 
-          def initialize
-            @timeout = nil
-          end
-
           def quit_errors
             [IOError]
           end

data/lib/selenium/webdriver/remote/http/default.rb

@@ -28,8 +28,7 @@ module Selenium
         class Default < Common
           attr_writer :proxy
 
-          attr_accessor :open_timeout
-          attr_accessor :read_timeout
+          attr_accessor :open_timeout, :read_timeout
 
           # Initializes object.
           # Warning: Setting {#open_timeout} to non-nil values will cause a separate thread to spawn.
@@ -39,6 +38,7 @@ module Selenium
           def initialize(open_timeout: nil, read_timeout: nil)
             @open_timeout = open_timeout
             @read_timeout = read_timeout
+            super()
           end
 
           def close
@@ -55,14 +55,18 @@ module Selenium
                 http.verify_mode = OpenSSL::SSL::VERIFY_NONE
               end
 
-              # Defaulting open_timeout to nil to be consistent with Ruby 2.2 and earlier.
-              http.open_timeout = open_timeout
+              http.open_timeout = open_timeout if open_timeout
               http.read_timeout = read_timeout if read_timeout
 
-              http.start
+              start(http)
+              http
             end
           end
 
+          def start(http)
+            http.start
+          end
+
           MAX_RETRIES = 3
 
           def request(verb, url, headers, payload, redirects = 0)
@@ -84,15 +88,15 @@ module Selenium
               retries += 1
               sleep 2
               retry
-            rescue Errno::EADDRNOTAVAIL => ex
+            rescue Errno::EADDRNOTAVAIL => e
               # a retry is sometimes needed when the port becomes temporarily unavailable
               raise if retries >= MAX_RETRIES
 
               retries += 1
               sleep 2
               retry
-            rescue Errno::ECONNREFUSED => ex
-              raise ex.class, "using proxy: #{proxy.http}" if use_proxy?
+            rescue Errno::ECONNREFUSED => e
+              raise e.class, "using proxy: #{proxy.http}" if use_proxy?
 
               raise
             end
@@ -123,12 +127,14 @@ module Selenium
           def new_http_client
             if use_proxy?
               url = @proxy.http
-              raise Error::WebDriverError, "expected HTTP proxy, got #{@proxy.inspect}" unless proxy.respond_to?(:http) && url
+              unless proxy.respond_to?(:http) && url
+                raise Error::WebDriverError,
+                      "expected HTTP proxy, got #{@proxy.inspect}"
+              end
 
               proxy = URI.parse(url)
 
-              clazz = Net::HTTP::Proxy(proxy.host, proxy.port, proxy.user, proxy.password)
-              clazz.new(server_url.host, server_url.port)
+              Net::HTTP.new(server_url.host, server_url.port, proxy.host, proxy.port, proxy.user, proxy.password)
             else
               Net::HTTP.new server_url.host, server_url.port
             end

data/lib/selenium/webdriver/remote/http/persistent.rb

@@ -25,12 +25,22 @@ module Selenium
       module Http
         # @api private
         class Persistent < Default
+          def initialize(open_timeout: nil, read_timeout: nil)
+            WebDriver.logger.deprecate("Selenium::WebDriver::Remote::Http::Persistent",
+                                       id: :http_persistent) { "The default HTTP client now uses persistence." }
+            super
+          end
+
           def close
             @http&.shutdown
           end
 
           private
 
+          def start(*)
+            # no need to explicitly start connection
+          end
+
           def new_http_client
             proxy = nil
 
@@ -42,12 +52,7 @@ module Selenium
               proxy = URI.parse(url)
             end
 
-            if Net::HTTP::Persistent::VERSION >= '3'
-              Net::HTTP::Persistent.new name: 'webdriver', proxy: proxy
-            else
-              WebDriver.logger.warn 'Support for this version of net-http-persistent is deprecated. Please upgrade.'
-              Net::HTTP::Persistent.new 'webdriver', proxy
-            end
+            Net::HTTP::Persistent.new name: 'webdriver', proxy: proxy
           end
 
           def response_for(request)

data/lib/selenium/webdriver/remote.rb

@@ -18,14 +18,20 @@
 # under the License.
 
 require 'uri'
-
-require 'selenium/webdriver/remote/bridge'
-require 'selenium/webdriver/remote/driver'
-require 'selenium/webdriver/remote/response'
 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/commands'
+module Selenium
+  module WebDriver
+    module Remote
+      autoload :Bridge, 'selenium/webdriver/remote/bridge'
+      autoload :Driver, 'selenium/webdriver/remote/driver'
+      autoload :Response, 'selenium/webdriver/remote/response'
+      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/safari/driver.rb

@@ -27,44 +27,13 @@ module Selenium
       #
 
       class Driver < WebDriver::Driver
-        include DriverExtensions::HasDebugger
-        include DriverExtensions::HasPermissions
-        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
+        EXTENSIONS = [DriverExtensions::HasDebugger,
+                      DriverExtensions::HasApplePermissions,
+                      DriverExtensions::HasWebStorage].freeze
 
         def browser
           :safari
         end
-
-        def quit
-          super
-        ensure
-          @service&.stop
-        end
-
-        private
-
-        def create_capabilities(opts = {})
-          caps = opts.delete(:desired_capabilities) { Remote::Capabilities.safari }
-          options = opts.delete(:options) { Options.new }
-          caps.merge!(options.as_json)
-          caps
-        end
-
       end # Driver
     end # Safari
   end # WebDriver

data/lib/selenium/webdriver/safari/{bridge.rb → features.rb}

@@ -20,17 +20,17 @@
 module Selenium
   module WebDriver
     module Safari
-      module Bridge
+      module Features
 
         # https://developer.apple.com/library/content/documentation/NetworkingInternetWeb/Conceptual/WebDriverEndpointDoc/Commands/Commands.html
-        COMMANDS = {
-          get_permissions: [:get, '/session/:session_id/apple/permissions'],
-          set_permissions: [:post, '/session/:session_id/apple/permissions'],
-          attach_debugger: [:post, '/session/:session_id/apple/attach_debugger']
+        SAFARI_COMMANDS = {
+          get_permissions: [:get, 'session/:session_id/apple/permissions'],
+          set_permissions: [:post, 'session/:session_id/apple/permissions'],
+          attach_debugger: [:post, 'session/:session_id/apple/attach_debugger']
         }.freeze
 
         def commands(command)
-          COMMANDS[command] || super
+          SAFARI_COMMANDS[command] || self.class::COMMANDS[command]
         end
 
         def permissions

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

@@ -20,40 +20,21 @@
 module Selenium
   module WebDriver
     module Safari
-      class Options
-        attr_accessor :automatic_inspection, :automatic_profiling
+      class Options < WebDriver::Options
+        attr_accessor :options
 
-        #
-        # Create a new Options instance for W3C-capable versions of Safari.
-        #
-        # @example
-        #   options = Selenium::WebDriver::Safari::Options.new(automatic_inspection: true)
-        #   driver = Selenium::WebDriver.for :safari, options: options
-        #
-        # @param [Hash] opts the pre-defined options to create the Safari::Options with
-        # @option opts [Boolean] :automatic_inspection Preloads Web Inspector and JavaScript debugger. Default is false
-        # @option opts [Boolean] :automatic_profiling Preloads Web Inspector and starts a timeline recording. Default is false
-        #
         # @see https://developer.apple.com/documentation/webkit/about_webdriver_for_safari
-        #
+        CAPABILITIES = {automatic_inspection: 'safari:automaticInspection',
+                        automatic_profiling: 'safari:automaticProfiling'}.freeze
+        BROWSER = 'safari'
 
-        def initialize(**opts)
-          @automatic_inspection = opts.delete(:automatic_inspection) || false
-          @automatic_profiling = opts.delete(:automatic_profiling) || false
-        end
-
-        #
-        # @api private
-        #
-
-        def as_json(*)
-          opts = {}
+        def add_option(name, value = nil)
+          key = name.is_a?(Hash) ? name.keys.first : name
+          raise ArgumentError, 'Safari does not support options that are not namespaced' unless key.to_s.include?(':')
 
-          opts['safari:automaticInspection'] = true if @automatic_inspection
-          opts['safari:automaticProfiling'] = true if @automatic_profiling
-
-          opts
+          super
         end
+
       end # Options
     end # Safari
   end # WebDriver

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

@@ -20,10 +20,6 @@
 module Selenium
   module WebDriver
     module Safari
-      #
-      # @api private
-      #
-
       class Service < WebDriver::Service
         DEFAULT_PORT = 7050
         EXECUTABLE = 'safaridriver'