selenium-webdriver 4.35.0 → 4.47.0

data/lib/selenium/webdriver/common/logger.rb

@@ -55,9 +55,32 @@ module Selenium
         @ignored = Array(ignored)
         @allowed = Array(allowed)
         @first_warning = false
+        @level_forced = false
+        @output_forced = false
+      end
+
+      #
+      # Forces debug level and prevents it from being overridden.
+      #
+      def debug!
+        @level_forced = true
+        @logger.level = :debug
+      end
+
+      #
+      # Forces output to stderr and prevents it from being overridden.
+      #
+      def stderr!
+        @output_forced = true
+        @logger.reopen($stderr)
       end
 
       def level=(level)
+        if @level_forced
+          warn('Logger level is forced; ignoring override', id: :logger)
+          return
+        end
+
         if level == :info && @logger.level == :info
           info(':info is now the default log level, to see additional logging, set log level to :debug')
         end
@@ -71,6 +94,11 @@ module Selenium
       # @param [String] io
       #
       def output=(io)
+        if @output_forced
+          warn('Logger output is forced; ignoring override', id: :logger)
+          return
+        end
+
         @logger.reopen(io)
       end
 

data/lib/selenium/webdriver/common/manager.rb

@@ -79,6 +79,8 @@ module Selenium
       #
 
       def delete_cookie(name)
+        raise ArgumentError, 'Cookie name cannot be null or empty' if name.nil? || name.to_s.strip.empty?
+
         @bridge.delete_cookie name
       end
 

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

@@ -71,8 +71,12 @@ module Selenium
       def initialize(**opts)
         self.class.set_capabilities
 
+        opts[:web_socket_url] = opts.delete(:bidi) if opts.key?(:bidi)
+
         @options = opts
         @options[:browser_name] = self.class::BROWSER
+
+        enable_bidi! if @options[:web_socket_url]
       end
 
       #
@@ -91,6 +95,20 @@ module Selenium
         @options[name] = value
       end
 
+      #
+      # Enables WebDriver BiDi by requesting the W3C webSocketUrl capability.
+      #
+      # @return [Boolean]
+      #
+
+      def enable_bidi!
+        @options[:web_socket_url] = true
+      end
+
+      def bidi?
+        !!@options[:web_socket_url]
+      end
+
       def ==(other)
         return false unless other.is_a? self.class
 
@@ -120,22 +138,43 @@ module Selenium
         browser_options = {self.class::KEY => browser_options} if defined?(self.class::KEY)
 
         process_browser_options(browser_options)
-        generate_as_json(w3c_options.merge(browser_options))
+        generate_as_json(merge_browser_options(w3c_options, browser_options))
       end
 
       private
 
+      # Preserve a hand-built vendor options hash (e.g. passed through #add_option) by merging it
+      # with the binding's own, rather than letting one silently overwrite the other.
+      def merge_browser_options(w3c_options, browser_options)
+        w3c_options.merge(browser_options) do |_key, w3c_value, browser_value|
+          if w3c_value.is_a?(Hash) && browser_value.is_a?(Hash)
+            browser_value.merge(w3c_value)
+          else
+            browser_value
+          end
+        end
+      end
+
       def w3c?(key)
         W3C_OPTIONS.include?(key) || key.to_s.include?(':')
       end
 
       def process_w3c_options(options)
         w3c_options = options.select { |key, val| w3c?(key) && !val.nil? }
-        w3c_options[:unhandled_prompt_behavior] &&= w3c_options[:unhandled_prompt_behavior]&.to_s&.tr('_', ' ')
+        w3c_options[:unhandled_prompt_behavior] &&=
+          process_unhandled_prompt_behavior_value(w3c_options[:unhandled_prompt_behavior])
         options.delete_if { |key, _val| w3c?(key) }
         w3c_options
       end
 
+      def process_unhandled_prompt_behavior_value(value)
+        if value.is_a?(Hash)
+          value.transform_values { |v| process_unhandled_prompt_behavior_value(v) }
+        else
+          value&.to_s&.tr('_', ' ')
+        end
+      end
+
       def process_browser_options(_browser_options)
         nil
       end

data/lib/selenium/webdriver/common/platform.rb

@@ -51,9 +51,7 @@ module Selenium
       end
 
       def ci
-        if ENV['TRAVIS']
-          :travis
-        elsif ENV['JENKINS']
+        if ENV['JENKINS']
           :jenkins
         elsif ENV['APPVEYOR']
           :appveyor

data/lib/selenium/webdriver/common/proxy.rb

@@ -29,7 +29,6 @@ module Selenium
       }.freeze
 
       ALLOWED = {type: 'proxyType',
-                 ftp: 'ftpProxy',
                  http: 'httpProxy',
                  no_proxy: 'noProxy',
                  pac: 'proxyAutoconfigUrl',
@@ -76,12 +75,6 @@ module Selenium
       end
       alias eql? ==
 
-      def ftp=(value)
-        WebDriver.logger.deprecate('FTP proxy support', nil, id: :ftp_proxy)
-        self.type = :manual
-        @ftp = value
-      end
-
       def http=(value)
         self.type = :manual
         @http = value
@@ -143,9 +136,8 @@ module Selenium
       def as_json(*)
         json_result = {
           'proxyType' => TYPES[type].downcase,
-          'ftpProxy' => ftp,
           'httpProxy' => http,
-          'noProxy' => no_proxy.is_a?(String) ? no_proxy.split(', ') : no_proxy,
+          'noProxy' => no_proxy.is_a?(String) ? no_proxy.split(',').map(&:strip).reject(&:empty?) : no_proxy,
           'proxyAutoconfigUrl' => pac,
           'sslProxy' => ssl,
           'autodetect' => auto_detect,

data/lib/selenium/webdriver/common/selenium_manager.rb

@@ -50,7 +50,8 @@ module Selenium
         def binary
           @binary ||= begin
             if (location = ENV.fetch('SE_MANAGER_PATH', nil))
-              WebDriver.logger.debug("Selenium Manager set by ENV['SE_MANAGER_PATH']: #{location}")
+              WebDriver.logger.debug("Selenium Manager set by ENV['SE_MANAGER_PATH']: #{location}",
+                                     id: :selenium_manager)
             end
             location ||= platform_location
 

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

@@ -69,7 +69,6 @@ module Selenium
       def initialize(path: nil, port: nil, log: nil, args: nil)
         port ||= self.class::DEFAULT_PORT
         args ||= []
-        path ||= env_path
 
         @executable_path = path
         @host = Platform.localhost
@@ -88,7 +87,7 @@ module Selenium
       end
 
       def launch
-        @executable_path ||= env_path || find_driver_path
+        @executable_path ||= DriverFinder.new(nil, self).driver_path
         ServiceManager.new(self).tap(&:start)
       end
 
@@ -96,13 +95,10 @@ module Selenium
         self.class::SHUTDOWN_SUPPORTED
       end
 
-      def find_driver_path
-        default_options = WebDriver.const_get("#{self.class.name&.split('::')&.[](2)}::Options").new
-        DriverFinder.new(default_options, self).driver_path
-      end
+      private
 
-      def env_path
-        ENV.fetch(self.class::DRIVER_PATH_ENV_KEY, nil)
+      def warn_driver_log_override
+        WebDriver.logger.warn('SE_DEBUG is set; overriding user-specified driver logging settings', id: :se_debug)
       end
     end # Service
   end # WebDriver

data/lib/selenium/webdriver/common/service_manager.rb

@@ -80,7 +80,13 @@ module Selenium
       def build_process(*command)
         WebDriver.logger.debug("Executing Process #{command}", id: :driver_service)
         @process = ChildProcess.build(*command)
-        @io ||= WebDriver.logger.io if WebDriver.logger.debug?
+        if ENV.key?('SE_DEBUG')
+          if @io && @io != WebDriver.logger.io
+            WebDriver.logger.warn('SE_DEBUG is set; overriding user-specified driver log output to use stderr',
+                                  id: :se_debug)
+          end
+          @io = WebDriver.logger.io
+        end
         @process.io = @io if @io
 
         @process
@@ -127,10 +133,36 @@ module Selenium
       end
 
       def connect_until_stable
-        socket_poller = SocketPoller.new @host, @port, START_TIMEOUT
-        return if socket_poller.connected?
+        deadline = current_time + START_TIMEOUT
+
+        loop do
+          error = check_connection_error
+          return unless error
+
+          raise Error::WebDriverError, "#{cannot_connect_error_text}: #{error}" if current_time > deadline
+
+          sleep 0.1
+        end
+      end
+
+      def check_connection_error
+        response = Net::HTTP.start(@host, @port, open_timeout: 0.5, read_timeout: 1) do |http|
+          http.get('/status', {'Connection' => 'close'})
+        end
+
+        return "status returned #{response.code}\n#{response.body}" unless response.is_a?(Net::HTTPSuccess)
+
+        status = JSON.parse(response.body)
+        ready = status['ready'] || status.dig('value', 'ready')
+        "driver not ready: #{response.body}" unless ready
+      rescue Errno::ECONNREFUSED, Errno::ECONNRESET, Errno::EPIPE, Errno::ETIMEDOUT,
+             Errno::EADDRNOTAVAIL, Errno::EHOSTUNREACH, Net::OpenTimeout, Net::ReadTimeout,
+             EOFError, SocketError, Net::HTTPBadResponse, JSON::ParserError => e
+        "#{e.class}: #{e.message}"
+      end
 
-        raise Error::WebDriverError, cannot_connect_error_text
+      def current_time
+        Process.clock_gettime(Process::CLOCK_MONOTONIC)
       end
 
       def cannot_connect_error_text

data/lib/selenium/webdriver/common/socket_poller.rb

@@ -93,7 +93,7 @@ module Selenium
           true
         rescue *NOT_CONNECTED_ERRORS
           sock&.close
-          WebDriver.logger.debug("polling for socket on #{[@host, @port].inspect}", id: :driver_service)
+          WebDriver.logger.debug("polling for socket on #{[@host, @port].inspect}", id: :socket_poller)
           false
         end
       end

data/lib/selenium/webdriver/common/takes_screenshot.rb

@@ -36,7 +36,7 @@ module Selenium
                                 'It should end with .png extension',
                                 id: :screenshot
         end
-        WebDriver.logger.debug("Saving screenshot to #{Dir.pwd}/#{png_path}")
+        WebDriver.logger.debug("Saving screenshot to #{Dir.pwd}/#{png_path}", id: :screenshot)
         File.open(png_path, 'wb') { |f| f << screenshot_as(:png, full_page: full_page) }
       end
 

data/lib/selenium/webdriver/common/virtual_authenticator/credential.rb

@@ -47,7 +47,7 @@ module Selenium
           new(id: decode(opts['credentialId']),
               resident_credential: opts['isResidentCredential'],
               rp_id: opts['rpId'],
-              private_key: opts['privateKey'],
+              private_key: decode(opts['privateKey']),
               sign_count: opts['signCount'],
               user_handle: user_handle)
         end

data/lib/selenium/webdriver/common/wait.rb

@@ -37,7 +37,8 @@ module Selenium
         @timeout  = opts.fetch(:timeout, DEFAULT_TIMEOUT)
         @interval = opts.fetch(:interval, DEFAULT_INTERVAL)
         @message  = opts[:message]
-        @ignored  = Array(opts[:ignore] || Error::NoSuchElementError)
+        @message_provider = opts[:message_provider]
+        @ignored = Array(opts[:ignore] || Error::NoSuchElementError)
       end
 
       #
@@ -64,6 +65,8 @@ module Selenium
 
         msg = if @message
                 @message.dup
+              elsif @message_provider
+                @message_provider.call
               else
                 "timed out after #{@timeout} seconds"
               end

data/lib/selenium/webdriver/common/websocket_connection.rb

@@ -24,7 +24,10 @@ module Selenium
     class WebSocketConnection
       CONNECTION_ERRORS = [
         Errno::ECONNRESET, # connection is aborted (browser process was killed)
-        Errno::EPIPE # broken pipe (browser process was killed)
+        Errno::EPIPE, # broken pipe (browser process was killed)
+        Errno::EBADF, # file descriptor already closed (double-close or GC)
+        IOError, # Ruby socket read/write after close
+        EOFError # socket reached EOF after remote closed cleanly
       ].freeze
 
       RESPONSE_WAIT_TIMEOUT = 30
@@ -35,6 +38,11 @@ module Selenium
       def initialize(url:)
         @callback_threads = ThreadGroup.new
 
+        @callbacks_mtx = Mutex.new
+        @messages_mtx = Mutex.new
+        @closing_mtx = Mutex.new
+
+        @closing = false
         @session_id = nil
         @url = url
 
@@ -43,9 +51,26 @@ module Selenium
       end
 
       def close
-        @callback_threads.list.each(&:exit)
-        @socket_thread.exit
-        socket.close
+        @closing_mtx.synchronize do
+          return if @closing
+
+          @closing = true
+        end
+
+        begin
+          socket.close
+        rescue *CONNECTION_ERRORS => e
+          WebDriver.logger.debug "WebSocket listener closed: #{e.class}: #{e.message}", id: :ws
+          # already closed
+        end
+
+        # Let threads unwind instead of calling exit
+        @socket_thread&.join(0.5)
+        @callback_threads.list.each do |thread|
+          thread.join(0.5)
+        rescue StandardError => e
+          WebDriver.logger.debug "Failed to join thread during close: #{e.class}: #{e.message}", id: :ws
+        end
       end
 
       def callbacks
@@ -53,62 +78,73 @@ module Selenium
       end
 
       def add_callback(event, &block)
-        callbacks[event] << block
-        block.object_id
+        @callbacks_mtx.synchronize do
+          callbacks[event] << block
+          block.object_id
+        end
       end
 
       def remove_callback(event, id)
-        return if callbacks[event].reject! { |callback| callback.object_id == id }
+        @callbacks_mtx.synchronize do
+          return if @closing
+
+          callbacks_for_event = callbacks[event]
+          return if callbacks_for_event.reject! { |cb| cb.object_id == id }
 
-        ids = callbacks[event]&.map(&:object_id)
-        raise Error::WebDriverError, "Callback with ID #{id} does not exist for event #{event}: #{ids}"
+          ids = callbacks_for_event.map(&:object_id)
+          raise Error::WebDriverError, "Callback with ID #{id} does not exist for event #{event}: #{ids}"
+        end
       end
 
       def send_cmd(**payload)
         id = next_id
         data = payload.merge(id: id)
-        WebDriver.logger.debug "WebSocket -> #{data}"[...MAX_LOG_MESSAGE_SIZE], id: :bidi
+        WebDriver.logger.debug "WebSocket -> #{data}"[...MAX_LOG_MESSAGE_SIZE], id: :ws
         data = JSON.generate(data)
         out_frame = WebSocket::Frame::Outgoing::Client.new(version: ws.version, data: data, type: 'text')
-        socket.write(out_frame.to_s)
 
-        wait.until { messages.delete(id) }
+        begin
+          socket.write(out_frame.to_s)
+        rescue *CONNECTION_ERRORS => e
+          raise e, "WebSocket is closed (#{e.class}: #{e.message})"
+        end
+
+        wait.until { @messages_mtx.synchronize { messages.delete(id) } }
       end
 
       private
 
-      # We should be thread-safe to use the hash without synchronization
-      # because its keys are WebSocket message identifiers and they should be
-      # unique within a devtools session.
       def messages
         @messages ||= {}
       end
 
       def process_handshake
         socket.print(ws.to_s)
-        ws << socket.readpartial(1024)
+        ws << socket.readpartial(1024) until ws.finished?
       end
 
       def attach_socket_listener
         Thread.new do
-          Thread.current.abort_on_exception = true
           Thread.current.report_on_exception = false
 
-          until socket.eof?
+          loop do
+            break if @closing
+
             incoming_frame << socket.readpartial(1024)
 
             while (frame = incoming_frame.next)
+              break if @closing
+
               message = process_frame(frame)
               next unless message['method']
 
-              params = message['params']
-              callbacks[message['method']].each do |callback|
-                @callback_threads.add(callback_thread(params, &callback))
+              @messages_mtx.synchronize { callbacks[message['method']].dup }.each do |callback|
+                @callback_threads.add(callback_thread(message['params'], &callback))
               end
             end
           end
-        rescue *CONNECTION_ERRORS
-          Thread.stop
+        rescue *CONNECTION_ERRORS, WebSocket::Error => e
+          WebDriver.logger.debug "WebSocket listener closed: #{e.class}: #{e.message}", id: :ws
         end
       end
 
@@ -122,27 +158,27 @@ module Selenium
         # Firefox will periodically fail on unparsable empty frame
         return {} if message.empty?
 
-        message = JSON.parse(message)
-        messages[message['id']] = message
-        WebDriver.logger.debug "WebSocket <- #{message}"[...MAX_LOG_MESSAGE_SIZE], id: :bidi
+        msg = JSON.parse(message)
+        @messages_mtx.synchronize { messages[msg['id']] = msg if msg.key?('id') }
 
-        message
+        WebDriver.logger.debug "WebSocket <- #{msg}"[...MAX_LOG_MESSAGE_SIZE], id: :ws
+        msg
       end
 
       def callback_thread(params)
         Thread.new do
-          Thread.current.abort_on_exception = true
-
-          # We might end up blocked forever when we have an error in event.
-          # For example, if network interception event raises error,
-          # the browser will keep waiting for the request to be proceeded
-          # before returning back to the original thread. In this case,
-          # we should at least print the error.
-          Thread.current.report_on_exception = true
+          Thread.current.abort_on_exception = false
+          Thread.current.report_on_exception = false
+          next if @closing
 
           yield params
-        rescue Error::WebDriverError, *CONNECTION_ERRORS
-          Thread.stop
+        rescue Error::WebDriverError, *CONNECTION_ERRORS => e
+          WebDriver.logger.debug "Callback aborted: #{e.class}: #{e.message}", id: :ws
+        rescue StandardError => e
+          next if @closing
+
+          bt = Array(e.backtrace).first(5).join("\n")
+          WebDriver.logger.error "Callback error: #{e.class}: #{e.message}\n#{bt}", id: :ws
         end
       end
 

data/lib/selenium/webdriver/common.rb

@@ -18,6 +18,7 @@
 # under the License.
 
 require 'selenium/webdriver/common/error'
+require 'selenium/webdriver/common/client_config'
 require 'selenium/webdriver/common/local_driver'
 require 'selenium/webdriver/common/driver_finder'
 require 'selenium/webdriver/common/platform'
@@ -75,9 +76,9 @@ require 'selenium/webdriver/common/driver_extensions/prints_page'
 require 'selenium/webdriver/common/driver_extensions/uploads_files'
 require 'selenium/webdriver/common/driver_extensions/full_page_screenshot'
 require 'selenium/webdriver/common/driver_extensions/has_addons'
-require 'selenium/webdriver/common/driver_extensions/has_bidi'
 require 'selenium/webdriver/common/driver_extensions/has_devtools'
 require 'selenium/webdriver/common/driver_extensions/has_file_downloads'
+require 'selenium/webdriver/common/driver_extensions/has_session_events'
 require 'selenium/webdriver/common/driver_extensions/has_authentication'
 require 'selenium/webdriver/common/driver_extensions/has_logs'
 require 'selenium/webdriver/common/driver_extensions/has_log_events'

data/lib/selenium/webdriver/devtools/response.rb

@@ -34,9 +34,9 @@ module Selenium
             id: id,
             code: params['responseStatusCode'],
             body: (Base64.strict_decode64(encoded_body) if encoded_body),
-            headers: params.fetch('responseHeaders', []).each_with_object({}) do |header, hash|
-              hash[header['name']] = header['value']
-            end
+            headers: params.fetch('responseHeaders', []).to_h do |header|
+                       [header['name'], header['value']]
+                     end
           )
         end
 

data/lib/selenium/webdriver/devtools.rb

@@ -84,7 +84,7 @@ module Selenium
       def start_session(target_type:)
         targets = target.get_targets.dig('result', 'targetInfos')
         found_target = targets.find { |target| target['type'] == target_type }
-        raise Error::WebDriverError, "Target type '#{target_type}' not found" unless found_target
+        raise Error::NoSuchTargetError, "Target type '#{target_type}' not found" unless found_target
 
         session = target.attach_to_target(target_id: found_target['targetId'], flatten: true)
         @session_id = session.dig('result', 'sessionId')

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

@@ -30,9 +30,10 @@ module Selenium
       class Driver < Chromium::Driver
         include LocalDriver
 
-        def initialize(options: nil, service: nil, url: nil, **)
-          caps, url = initialize_local_driver(options, service, url)
-          super(caps: caps, url: url, **)
+        def initialize(options: nil, service: nil, url: nil, http_client: nil, client_config: nil, **)
+          initialize_local_driver(options, service, url, http_client, client_config) do |caps, client|
+            super(caps: caps, http_client: client, **)
+          end
         end
 
         def browser

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

@@ -25,6 +25,20 @@ module Selenium
         EXECUTABLE = 'msedgedriver'
         SHUTDOWN_SUPPORTED = true
         DRIVER_PATH_ENV_KEY = 'SE_EDGEDRIVER'
+
+        def initialize(args: nil, **)
+          args = Array(args.dup)
+          # yes, it is --enable-chrome-logs, even on msedgedriver; skip when CHROME_LOG_FILE is set
+          args << '--enable-chrome-logs' unless ENV.key?('CHROME_LOG_FILE') || args.include?('--enable-chrome-logs')
+
+          if ENV.key?('SE_DEBUG')
+            warn_driver_log_override if args.reject! { |arg| arg.include?('log-level') || arg.include?('silent') }
+            args << '--verbose'
+          end
+
+          super
+        end
+
         def log
           return @log unless @log.is_a? String
 

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

@@ -29,16 +29,14 @@ module Selenium
         EXTENSIONS = [DriverExtensions::HasAddons,
                       DriverExtensions::FullPageScreenshot,
                       DriverExtensions::HasContext,
-                      DriverExtensions::HasBiDi,
-                      DriverExtensions::HasLogEvents,
-                      DriverExtensions::HasNetworkInterception,
                       DriverExtensions::PrintsPage].freeze
 
         include LocalDriver
 
-        def initialize(options: nil, service: nil, url: nil, **)
-          caps, url = initialize_local_driver(options, service, url)
-          super(caps: caps, url: url, **)
+        def initialize(options: nil, service: nil, url: nil, http_client: nil, client_config: nil, **)
+          initialize_local_driver(options, service, url, http_client, client_config) do |caps, client|
+            super(caps: caps, http_client: client, **)
+          end
         end
 
         def browser

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

@@ -69,6 +69,7 @@ module Selenium
           @options[:prefs]['remote.active-protocols'] = 1
           @options[:env] ||= {}
           @options[:log] ||= {level: log_level} if log_level
+          @vendor_options = {}
 
           process_profile(@options.delete(:profile))
         end
@@ -102,6 +103,23 @@ module Selenium
           @options[:prefs][name] = value
         end
 
+        #
+        # Add a Firefox-specific capability nested in the `moz:firefoxOptions`
+        # object that is not yet exposed through a dedicated method. This is the
+        # escape hatch for legitimate vendor capabilities the bindings do not model.
+        #
+        # @example Set an option not handled by other methods
+        #   options = Selenium::WebDriver::Firefox::Options.new
+        #   options.add_firefox_option('unhandledCapability', 'value')
+        #
+        # @param [String, Symbol] name Name of the capability, as expected by geckodriver
+        # @param [Object] value Value of the capability
+        #
+
+        def add_firefox_option(name, value)
+          @vendor_options[name.to_s] = value
+        end
+
         #
         # Sets Firefox profile.
         #
@@ -153,6 +171,7 @@ module Selenium
         def process_browser_options(browser_options)
           browser_options['moz:debuggerAddress'] = true if @debugger_address
           options = browser_options[KEY]
+          options.merge!(@vendor_options)
           options['binary'] ||= Firefox.path if Firefox.path
           options['profile'] = @profile if @profile
         end