selenium-webdriver 3.142.7 → 4.9.0

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

@@ -24,48 +24,58 @@ module Selenium
       # Specification of the desired and/or actual capabilities of the browser that the
       # server is being asked to create.
       #
+
       class Capabilities
-        DEFAULTS = {
-          browser_name: '',
-          version: '',
-          platform: :any,
-          javascript_enabled: false,
-          css_selectors_enabled: false,
-          takes_screenshot: false,
-          native_events: false,
-          rotatable: false,
-          firefox_profile: nil,
-          proxy: nil
-        }.freeze
-
-        DEFAULTS.each_key do |key|
-          if key != :javascript_enabled
-            define_method key do
-              @capabilities.fetch(key)
-            end
+        KNOWN = [
+          :browser_name,
+          :browser_version,
+          :platform_name,
+          :accept_insecure_certs,
+          :page_load_strategy,
+          :proxy,
+          :set_window_rect,
+          :timeouts,
+          :unhandled_prompt_behavior,
+          :strict_file_interactability,
+          :web_socket_url,
+
+          # remote-specific (webdriver.remote.sessionid)
+          :remote_session_id
+        ].freeze
+
+        (KNOWN - %i[proxy timeouts]).each do |key|
+          define_method key do
+            @capabilities[key]
           end
 
-          next if key == :proxy
-
           define_method "#{key}=" do |value|
             @capabilities[key] = value
           end
         end
 
         #
-        # Returns javascript_enabled capability.
-        # It is true if not set explicitly.
+        # Backward compatibility
         #
-        def javascript_enabled
-          javascript_enabled = @capabilities.fetch(:javascript_enabled)
-          javascript_enabled.nil? ? true : javascript_enabled
+
+        def version
+          WebDriver.logger.deprecate('`Capabilities#version`', '`Capabilities#browser_version`', id: :jwp_caps)
+          browser_version
         end
 
-        alias_method :css_selectors_enabled?, :css_selectors_enabled
-        alias_method :javascript_enabled?, :javascript_enabled
-        alias_method :native_events?, :native_events
-        alias_method :takes_screenshot?, :takes_screenshot
-        alias_method :rotatable?, :rotatable
+        def version=(value)
+          WebDriver.logger.deprecate('`Capabilities#version=`', '`Capabilities#browser_version=`', id: :jwp_caps)
+          self.browser_version = value
+        end
+
+        def platform
+          WebDriver.logger.deprecate('`Capabilities#platform`', '`Capabilities#platform_name`', id: :jwp_caps)
+          platform_name
+        end
+
+        def platform=(value)
+          WebDriver.logger.deprecate('`Capabilities#platform=`', '`Capabilities#platform_name=`', id: :jwp_caps)
+          self.platform_name = value
+        end
 
         #
         # Convenience methods for the common choices.
@@ -73,81 +83,59 @@ module Selenium
 
         class << self
           def chrome(opts = {})
+            WebDriver.logger.deprecate('Remote::Capabilities.chrome', 'Options.chrome', id: :caps_browsers)
             new({
-              browser_name: 'chrome',
-              javascript_enabled: true,
-              css_selectors_enabled: true
+              browser_name: 'chrome'
             }.merge(opts))
           end
 
           def edge(opts = {})
+            WebDriver.logger.deprecate('Remote::Capabilities.edge', 'Options.edge', id: :caps_browsers)
             new({
-              browser_name: 'MicrosoftEdge',
-              platform: :windows
+              browser_name: 'MicrosoftEdge'
             }.merge(opts))
           end
+          alias 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', marionette: true}.merge(opts))
-          end
-
-          def firefox_legacy(opts = {})
+            WebDriver.logger.deprecate('Remote::Capabilities.firefox', 'Options.firefox', id: :caps_browsers)
             new({
-              browser_name: 'firefox',
-              javascript_enabled: true,
-              takes_screenshot: true,
-              css_selectors_enabled: true
+              browser_name: 'firefox'
             }.merge(opts))
           end
+          alias ff firefox
 
-          def htmlunit(opts = {})
+          def safari(opts = {})
+            WebDriver.logger.deprecate('Remote::Capabilities.safari', 'Options.safari', id: :caps_browsers)
             new({
-              browser_name: 'htmlunit'
+              browser_name: Selenium::WebDriver::Safari.technology_preview? ? 'Safari Technology Preview' : 'safari'
             }.merge(opts))
           end
 
-          def htmlunitwithjs(opts = {})
+          def htmlunit(opts = {})
+            WebDriver.logger.deprecate('Remote::Capabilities.htmlunit',
+                                       'as argument in constructor',
+                                       id: :caps_browsers)
             new({
-              browser_name: 'htmlunit',
-              javascript_enabled: true
+              browser_name: 'htmlunit'
             }.merge(opts))
           end
 
           def internet_explorer(opts = {})
+            WebDriver.logger.deprecate('Remote::Capabilities.ie', 'Options.ie', id: :caps_browsers)
             new({
               browser_name: 'internet explorer',
-              platform: :windows,
-              takes_screenshot: true,
-              css_selectors_enabled: true,
-              native_events: true
+              platform_name: :windows
             }.merge(opts))
           end
-          alias_method :ie, :internet_explorer
+          alias ie internet_explorer
 
-          def phantomjs(opts = {})
-            WebDriver.logger.deprecate 'Selenium support for PhantomJS', 'headless Chrome/Firefox or HTMLUnit'
-            new({
-              browser_name: 'phantomjs',
-              javascript_enabled: true,
-              takes_screenshot: true,
-              css_selectors_enabled: true
-            }.merge(opts))
+          def always_match(capabilities)
+            new(always_match: capabilities)
           end
 
-          def safari(opts = {})
-            new({
-              browser_name: 'safari',
-              platform: :mac,
-              javascript_enabled: true,
-              takes_screenshot: true,
-              css_selectors_enabled: true
-            }.merge(opts))
+          def first_match(*capabilities)
+            new(first_match: capabilities)
           end
 
           #
@@ -156,41 +144,62 @@ module Selenium
 
           def json_create(data)
             data = data.dup
-
             caps = new
-            caps.browser_name          = data.delete('browserName')
-            caps.version               = data.delete('version')
-            caps.platform              = data.delete('platform').downcase.tr(' ', '_').to_sym if data.key?('platform')
-            caps.javascript_enabled    = data.delete('javascriptEnabled')
-            caps.css_selectors_enabled = data.delete('cssSelectorsEnabled')
-            caps.takes_screenshot      = data.delete('takesScreenshot')
-            caps.native_events         = data.delete('nativeEvents')
-            caps.rotatable             = data.delete('rotatable')
-            caps.proxy                 = Proxy.json_create(data['proxy']) if data.key?('proxy') && !data['proxy'].empty?
+
+            process_timeouts(caps, data.delete('timeouts'))
+
+            if data.key?('proxy')
+              proxy = data.delete('proxy')
+              caps.proxy = Proxy.json_create(proxy) unless proxy.nil? || proxy.empty?
+            end
+
+            # Remote Server Specific
+            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
 
         #
-        # @option :browser_name           [String] required browser name
-        # @option :version                [String] required browser version number
-        # @option :platform               [Symbol] one of :any, :win, :mac, or :x
-        # @option :javascript_enabled     [Boolean] does the driver have javascript enabled?
-        # @option :css_selectors_enabled  [Boolean] does the driver support CSS selectors?
-        # @option :takes_screenshot       [Boolean] can this driver take screenshots?
-        # @option :native_events          [Boolean] does this driver use native events?
-        # @option :proxy                  [Selenium::WebDriver::Proxy, Hash] proxy configuration
+        # @param [Hash] opts
+        # @option :browser_name             [String] required browser name
+        # @option :browser_version          [String] required browser version number
+        # @option :platform_name            [Symbol] one of :any, :win, :mac, or :x
+        # @option :accept_insecure_certs    [Boolean] does the driver accept insecure SSL certifications?
+        # @option :proxy                    [Selenium::WebDriver::Proxy, Hash] proxy configuration
         #
         # @api public
         #
 
         def initialize(opts = {})
-          @capabilities = DEFAULTS.merge(opts)
-          self.proxy    = opts.delete(:proxy)
+          @capabilities = {}
+          self.proxy = opts.delete(:proxy) if opts[:proxy]
+          @capabilities.merge!(opts)
         end
 
         #
@@ -215,6 +224,10 @@ module Selenium
           end
         end
 
+        def proxy
+          @capabilities[:proxy]
+        end
+
         def proxy=(proxy)
           case proxy
           when Hash
@@ -226,37 +239,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(*) # rubocop:disable Metrics/CyclomaticComplexity
-          hash = {}
-
-          @capabilities.each do |key, value|
-            case key
-            when :platform
-              hash['platform'] = value.to_s.upcase
-            when :firefox_profile
-              if value
-                WebDriver.logger.deprecate(':firefox_profile capabilitiy', 'Selenium::WebDriver::Firefox::Options#profile')
-                hash['firefox_profile'] = value.as_json['zip']
-              end
-            when :proxy
-              hash['proxy'] = value.as_json if value
-            when String, :firefox_binary
-              if key == :firefox_binary && value
-                WebDriver.logger.deprecate(':firefox_binary capabilitiy', 'Selenium::WebDriver::Firefox::Options#binary')
-              end
-              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
+        def as_json(*)
+          @capabilities.each_with_object({}) do |(key, value), hash|
+            hash[convert_key(key)] = process_capabilities(key, value, hash)
           end
-
-          hash
         end
 
         def to_json(*)
@@ -268,7 +290,8 @@ module Selenium
 
           as_json == other.as_json
         end
-        alias_method :eql?, :==
+
+        alias eql? ==
 
         protected
 
@@ -276,8 +299,43 @@ 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

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

@@ -20,7 +20,6 @@
 module Selenium
   module WebDriver
     module Remote
-
       #
       # Driver implementation for remote server.
       # @api private
@@ -28,23 +27,39 @@ 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)
-          @bridge = Bridge.handshake(opts)
-          if @bridge.dialect == :oss
-            extend DriverExtensions::HasTouchScreen
-            extend DriverExtensions::HasLocation
-            extend DriverExtensions::HasNetworkConnection
-          end
-          super(@bridge, listener: listener)
+
+        def initialize(capabilities: nil, options: nil, service: nil, url: nil, **opts)
+          raise ArgumentError, "Can not set :service object on #{self.class}" if service
+
+          url ||= "http://#{Platform.localhost}:4444/wd/hub"
+          caps = process_options(options, capabilities)
+          super(caps: caps, url: url, **opts)
+          @bridge.file_detector = ->((filename, *)) { File.exist?(filename) && filename.to_s }
+        end
+
+        private
+
+        def devtools_url
+          capabilities['se:cdp']
+        end
+
+        def devtools_version
+          cdp_version = capabilities['se:cdpVersion']&.split('.')&.first
+          raise Error::WebDriverError, 'DevTools is not supported by the Remote Server' unless cdp_version
+
+          Integer(cdp_version)
         end
 
+        def process_options(options, capabilities)
+          if options && capabilities
+            msg = "Don't use both :options and :capabilities when initializing #{self.class}, prefer :options"
+            raise ArgumentError, msg
+          elsif options.nil? && capabilities.nil?
+            raise ArgumentError, "#{self.class} needs :options to be set"
+          end
+          options ? options.as_json : generate_capabilities(capabilities)
+        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/curb.rb

@@ -22,7 +22,6 @@ require 'curb'
 module Selenium
   module WebDriver
     module Remote
-
       module Http
         #
         # An alternative to the default Net::HTTP client.
@@ -38,7 +37,6 @@ module Selenium
         #
 
         class Curb < Common
-
           def quit_errors
             [Curl::Err::RecvError] + super
           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,15 +38,7 @@ module Selenium
           def initialize(open_timeout: nil, read_timeout: nil)
             @open_timeout = open_timeout
             @read_timeout = read_timeout
-          end
-
-          # Maintaining backward compatibility.
-          # @param [Numeric] value - Timeout in seconds to apply to both open timeout and read timeouts.
-          # @deprecated Please set the specific desired timeout {#read_timeout} or {#open_timeout} directly.
-          def timeout=(value)
-            WebDriver.logger.deprecate ':timeout=', '#read_timeout= and #open_timeout='
-            self.open_timeout = value
-            self.read_timeout = value
+            super()
           end
 
           def close
@@ -64,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)
@@ -80,9 +75,10 @@ module Selenium
             begin
               request = new_request_for(verb, url, headers, payload)
               response = response_for(request)
-            rescue Errno::ECONNABORTED, Errno::ECONNRESET, Errno::EADDRINUSE
-              # a retry is sometimes needed on Windows XP where we may quickly
-              # run out of ephemeral ports
+            rescue Errno::ECONNABORTED, Errno::ECONNRESET, Errno::EADDRINUSE, Errno::EADDRNOTAVAIL
+              # a retry is sometimes needed:
+              #   on Windows XP where we may quickly run out of ephemeral ports
+              #   when the port becomes temporarily unavailable
               #
               # A more robust solution is bumping the MaxUserPort setting
               # as described here:
@@ -93,15 +89,8 @@ module Selenium
               retries += 1
               sleep 2
               retry
-            rescue Errno::EADDRNOTAVAIL => ex
-              # 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
@@ -111,6 +100,7 @@ module Selenium
 
               request(:get, URI.parse(response['Location']), DEFAULT_HEADERS.dup, nil, redirects + 1)
             else
+              WebDriver.logger.debug("   <<<  #{response.instance_variable_get(:@header).inspect}")
               create_response response.code, response.body, response.content_type
             end
           end
@@ -132,12 +122,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
@@ -145,8 +137,8 @@ module Selenium
 
           def proxy
             @proxy ||= begin
-              proxy = ENV['http_proxy'] || ENV['HTTP_PROXY']
-              no_proxy = ENV['no_proxy'] || ENV['NO_PROXY']
+              proxy = ENV.fetch('http_proxy', nil) || ENV.fetch('HTTP_PROXY', nil)
+              no_proxy = ENV.fetch('no_proxy', nil) || ENV.fetch('NO_PROXY', nil)
 
               if proxy
                 proxy = "http://#{proxy}" unless proxy.start_with?('http://')