selenium-webdriver 4.45.0 → 4.46.0

data/lib/selenium/webdriver/bidi/support/check_generated.rb

@@ -0,0 +1,55 @@
+# 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.
+
+require 'json'
+require_relative 'bidi_generate'
+
+module BiDiGenerate
+  # Verifies the checked-in protocol .rb match what the generator would produce from the
+  # current schema — catching a hand-edit or a forgotten regeneration. Re-renders each module
+  # in memory (no file writes) and compares. The .rbs are covered by Steep.
+  def self.check!(schema_rootpath)
+    modules = build_ir(Schema.new(JSON.parse(File.read(schema_path(schema_rootpath)))))
+    protocol_dir = File.expand_path('../protocol', __dir__)
+    template = File.join(__dir__, 'templates', 'module.rb.erb')
+
+    stale = modules.reject do |mod|
+      path = File.join(protocol_dir, "#{mod.filename}.rb")
+      File.exist?(path) && File.read(path) == render(mod, template)
+    end
+    return if stale.empty?
+
+    warn "Generated BiDi protocol code is stale or hand-edited: #{stale.map { |m| "#{m.filename}.rb" }.sort.join(', ')}"
+    warn 'Regenerate with: bazel run //rb/lib/selenium/webdriver:bidi-generate'
+    exit 1
+  end
+
+  # $(rootpath) is relative to the runfiles root; __dir__ anchors us there so it resolves the
+  # same way locally and on RBE (an execpath would not). This file lives at
+  # rb/lib/selenium/webdriver/bidi/support, so expand six levels up to the root — File.expand_path
+  # is separator-agnostic, unlike stripping a "/"-spelled suffix (which would miss on Windows).
+  # The cwd-relative rootpath fallback matches how spec_support's `rlocation` resolves.
+  def self.schema_path(rootpath)
+    runfiles_root = File.expand_path('../../../../../..', __dir__)
+    [File.join(runfiles_root, rootpath), rootpath].find { |p| File.exist?(p) } ||
+      raise("BiDi schema not found (looked for #{rootpath})")
+  end
+end
+
+BiDiGenerate.check!(ARGV.fetch(0)) if $PROGRAM_NAME == __FILE__

data/lib/selenium/webdriver/bidi/transport.rb

@@ -0,0 +1,52 @@
+# 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
+    class BiDi
+      # The seam between the generated Protocol layer and the websocket: serializes a
+      # command's params, sends it, and parses the reply into its declared type.
+      #
+      # @api private
+      class Transport
+        def initialize(connection)
+          @connection = connection
+        end
+
+        def execute(cmd:, params: nil, result: nil)
+          reply = @connection.send_cmd(method: cmd, params: serialize(params))
+          raise Error::WebDriverError, error_message(reply) if reply['error']
+
+          value = reply['result']
+          result ? result.from_json(value) : value
+        end
+
+        private
+
+        def serialize(params)
+          params&.as_json || {}
+        end
+
+        def error_message(reply)
+          "#{reply['error']}: #{reply['message']}\n#{reply['stacktrace']}"
+        end
+      end # Transport
+    end # BiDi
+  end # WebDriver
+end # Selenium

data/lib/selenium/webdriver/bidi.rb

@@ -35,6 +35,9 @@ module Selenium
         @ws = WebSocketConnection.new(url: url)
       end
 
+      # @api private
+      attr_reader :ws
+
       def close
         @ws.close
       end

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

@@ -30,9 +30,9 @@ module Selenium
       class Driver < Chromium::Driver
         include LocalDriver
 
-        def initialize(options: nil, service: nil, url: nil, **)
-          initialize_local_driver(options, service, url) do |caps, driver_url|
-            super(caps: caps, url: driver_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
 

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

@@ -0,0 +1,97 @@
+# 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.
+
+require 'uri'
+
+module Selenium
+  module WebDriver
+    #
+    # Configuration for HTTP clients.
+    #
+
+    class ClientConfig
+      class << self
+        attr_accessor :default_extra_headers
+        attr_writer :default_user_agent
+
+        def default_user_agent
+          @default_user_agent ||= "selenium/#{WebDriver::VERSION} (ruby #{Platform.os})"
+        end
+      end
+
+      attr_accessor :open_timeout, :read_timeout, :max_redirects, :proxy
+      attr_writer :extra_headers, :user_agent
+      attr_reader :server_url
+
+      #
+      # @param [Numeric] open_timeout Seconds to wait for the connection to open.
+      # @param [Numeric] read_timeout Seconds to wait for a response.
+      # @param [Integer] max_redirects Maximum number of redirects to follow.
+      # @param [Proxy] proxy Proxy to use for the connection.
+      # @param [Hash] extra_headers Additional headers to send with each request.
+      # @param [String] user_agent Value to send as the User-Agent header.
+      # @param [String, URI] server_url URL of the server to connect to.
+      #
+      def initialize(open_timeout: 60,
+                     read_timeout: 120,
+                     max_redirects: 20,
+                     proxy: nil,
+                     extra_headers: nil,
+                     user_agent: nil,
+                     server_url: nil)
+        @open_timeout = open_timeout
+        @read_timeout = read_timeout
+        @max_redirects = max_redirects
+        @proxy = proxy || proxy_from_environment
+        @extra_headers = extra_headers
+        @user_agent = user_agent
+        self.server_url = server_url
+      end
+
+      def user_agent
+        @user_agent || self.class.default_user_agent
+      end
+
+      def extra_headers
+        @extra_headers || self.class.default_extra_headers
+      end
+
+      def server_url=(url)
+        if url.nil?
+          @server_url = nil
+        else
+          url = url.to_s
+          url += '/' unless url.end_with?('/')
+          @server_url = URI.parse(url)
+        end
+      end
+
+      private
+
+      def proxy_from_environment
+        proxy = ENV.fetch('http_proxy', nil) || ENV.fetch('HTTP_PROXY', nil)
+        return unless proxy
+
+        no_proxy = ENV.fetch('no_proxy', nil) || ENV.fetch('NO_PROXY', nil)
+        proxy = "http://#{proxy}" unless proxy.match?(%r{\Ahttps?://})
+        Proxy.new(http: proxy, no_proxy: no_proxy)
+      end
+    end
+  end
+end

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

@@ -319,9 +319,9 @@ module Selenium
 
       attr_reader :bridge
 
-      def create_bridge(caps:, url:, http_client: nil)
+      def create_bridge(caps:, http_client:)
         klass = caps['webSocketUrl'] ? Remote::BiDiBridge : Remote::Bridge
-        klass.new(http_client: http_client, url: url).tap do |bridge|
+        klass.new(http_client: http_client).tap do |bridge|
           bridge.create_session(caps)
         end
       end

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

@@ -20,15 +20,16 @@
 module Selenium
   module WebDriver
     module LocalDriver
-      def initialize_local_driver(options, service, url)
-        raise ArgumentError, "Can't initialize #{self.class} with :url" if url
+      def initialize_local_driver(options, service, url, http_client, client_config)
+        assert_local_arguments(url, http_client, client_config)
 
         service ||= Service.send(browser)
         caps = process_options(options, service)
-        url = service_url(service)
+        http_client ||= Remote::Http::Default.new(client_config: client_config)
+        http_client.server_url = service_url(service)
 
         begin
-          yield(caps, url) if block_given?
+          yield(caps, http_client) if block_given?
         rescue Selenium::WebDriver::Error::WebDriverError
           @service_manager&.stop
           raise
@@ -54,6 +55,16 @@ module Selenium
         options.browser_version = nil if options.respond_to?(:binary) && options.binary
         options.as_json
       end
+
+      private
+
+      def assert_local_arguments(url, http_client, client_config)
+        if url || client_config&.server_url
+          raise ArgumentError, "Can't set the server URL for #{self.class}; the service provides it"
+        elsif http_client && client_config
+          raise ArgumentError, 'Cannot use both :http_client and :client_config'
+        end
+      end
     end
   end
 end

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

@@ -145,7 +145,7 @@ module Selenium
           '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.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'

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

@@ -30,9 +30,9 @@ module Selenium
       class Driver < Chromium::Driver
         include LocalDriver
 
-        def initialize(options: nil, service: nil, url: nil, **)
-          initialize_local_driver(options, service, url) do |caps, driver_url|
-            super(caps: caps, url: driver_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
 

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

@@ -36,9 +36,9 @@ module Selenium
 
         include LocalDriver
 
-        def initialize(options: nil, service: nil, url: nil, **)
-          initialize_local_driver(options, service, url) do |caps, driver_url|
-            super(caps: caps, url: driver_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
 

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

@@ -31,9 +31,9 @@ module Selenium
 
         include LocalDriver
 
-        def initialize(options: nil, service: nil, url: nil, **)
-          initialize_local_driver(options, service, url) do |caps, driver_url|
-            super(caps: caps, url: driver_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
 

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

@@ -17,16 +17,21 @@
 # specific language governing permissions and limitations
 # under the License.
 
+require 'selenium/webdriver/bidi'
+require 'selenium/webdriver/bidi/transport'
+
 module Selenium
   module WebDriver
     module Remote
       class BiDiBridge < Bridge
-        attr_reader :bidi
+        attr_reader :bidi, :transport
 
         def create_session(capabilities)
           super
           socket_url = @capabilities[:web_socket_url]
           @bidi = Selenium::WebDriver::BiDi.new(url: socket_url)
+          # Share the BiDi object's socket until the bridge owns the connection directly.
+          @transport = BiDi::Transport.new(@bidi.ws)
         end
 
         def get(url)

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

@@ -51,20 +51,13 @@ module Selenium
         end
 
         #
-        # Initializes the bridge with the given server URL
-        # @param [String, URI] url url for the remote server
-        # @param [Object] http_client an HTTP client instance that implements the same protocol as Http::Default
+        # @param [Object] http_client a configured HTTP client implementing the same protocol as Http::Default
         # @api private
         #
 
-        def initialize(url:, http_client: nil)
-          uri = url.is_a?(URI) ? url : URI.parse(url)
-          uri.path += '/' unless uri.path.end_with?('/')
-
-          @http = http_client || Http::Default.new
-          @http.server_url = uri
+        def initialize(http_client:)
+          @http = http_client
           @file_detector = nil
-
           @locator_converter = self.class.locator_converter
         end
 
@@ -605,6 +598,11 @@ module Selenium
           raise(WebDriver::Error::WebDriverError, msg)
         end
 
+        def transport
+          msg = 'BiDi must be enabled by setting #web_socket_url to true in options class'
+          raise(WebDriver::Error::WebDriverError, msg)
+        end
+
         def command_list
           COMMANDS
         end

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

@@ -31,12 +31,14 @@ module Selenium
         include DriverExtensions::HasFileDownloads
         include DriverExtensions::HasSessionEvents
 
-        def initialize(capabilities: nil, options: nil, service: nil, url: nil, **)
-          raise ArgumentError, "Can not set :service object on #{self.class}" if service
+        def initialize(capabilities: nil, options: nil, service: nil, url: nil, http_client: nil, client_config: nil,
+                       **)
+          assert_arguments(service, url, http_client, client_config)
 
-          url ||= "http://#{Platform.localhost}:4444/wd/hub"
           caps = process_options(options, capabilities)
-          super(caps: caps, url: url, **)
+          http_client ||= Remote::Http::Default.new(client_config: client_config)
+          http_client.server_url = url || client_config&.server_url || "http://#{Platform.localhost}:4444/wd/hub"
+          super(caps: caps, http_client: http_client, **)
           @bridge.file_detector = ->((filename, *)) { File.exist?(filename) && filename.to_s }
           command_list = @bridge.command_list
           @bridge.extend(WebDriver::Remote::Features)
@@ -45,6 +47,12 @@ module Selenium
 
         private
 
+        def assert_arguments(service, url, http_client, client_config)
+          raise ArgumentError, "Can not set :service object on #{self.class}" if service
+          raise ArgumentError, 'Cannot use both :http_client and :client_config' if http_client && client_config
+          raise ArgumentError, 'Cannot use both :url and a ClientConfig#server_url' if url && client_config&.server_url
+        end
+
         def devtools_url
           capabilities['se:cdp']
         end

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

@@ -31,15 +31,32 @@ module Selenium
           BINARY_ENCODINGS = [Encoding::BINARY, Encoding::ASCII_8BIT].freeze
 
           class << self
-            attr_accessor :extra_headers
-            attr_writer :user_agent
-
             def user_agent
-              @user_agent ||= "selenium/#{WebDriver::VERSION} (ruby #{Platform.os})"
+              ClientConfig.default_user_agent
+            end
+
+            def user_agent=(value)
+              ClientConfig.default_user_agent = value
+            end
+
+            def extra_headers
+              ClientConfig.default_extra_headers
+            end
+
+            def extra_headers=(value)
+              ClientConfig.default_extra_headers = value
             end
           end
 
-          attr_writer :server_url
+          attr_reader :client_config
+
+          def initialize(client_config: nil)
+            @client_config = client_config || ClientConfig.new
+          end
+
+          def server_url=(url)
+            client_config.server_url = url
+          end
 
           def quit_errors
             [IOError]
@@ -76,17 +93,13 @@ module Selenium
           def common_headers
             @common_headers ||= begin
               headers = DEFAULT_HEADERS.dup
-              headers['User-Agent'] = Common.user_agent
-              headers = headers.merge(Common.extra_headers || {})
-
-              headers
+              headers['User-Agent'] = client_config.user_agent
+              headers.merge(client_config.extra_headers || {})
             end
           end
 
           def server_url
-            return @server_url if @server_url
-
-            raise Error::WebDriverError, 'server_url not set'
+            client_config.server_url || raise(Error::WebDriverError, 'server_url not set')
           end
 
           def request(*)

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

@@ -24,19 +24,41 @@ module Selenium
       module Http
         # @api private
         class Default < Common
-          attr_writer :proxy
-
-          attr_accessor :open_timeout, :read_timeout
-
           # Initializes object.
           # Warning: Setting {#open_timeout} to non-nil values will cause a separate thread to spawn.
           # Debuggers that freeze the process will not be able to evaluate any operations if that happens.
+          # @param [ClientConfig] client_config - Configuration used to build the HTTP client.
           # @param [Numeric] open_timeout - Open timeout to apply to HTTP client.
           # @param [Numeric] read_timeout - Read timeout (seconds) to apply to HTTP client.
-          def initialize(open_timeout: nil, read_timeout: nil)
-            @open_timeout = open_timeout
-            @read_timeout = read_timeout
-            super()
+          def initialize(client_config: nil, open_timeout: nil, read_timeout: nil)
+            if client_config && (open_timeout || read_timeout)
+              raise ArgumentError, 'Cannot use both :client_config and :open_timeout/:read_timeout'
+            end
+
+            client_config ||= ClientConfig.new
+            client_config.open_timeout = open_timeout if open_timeout
+            client_config.read_timeout = read_timeout if read_timeout
+            super(client_config: client_config)
+          end
+
+          def open_timeout
+            client_config.open_timeout
+          end
+
+          def read_timeout
+            client_config.read_timeout
+          end
+
+          def open_timeout=(value)
+            client_config.open_timeout = value
+          end
+
+          def read_timeout=(value)
+            client_config.read_timeout = value
+          end
+
+          def proxy=(value)
+            client_config.proxy = value
           end
 
           def close
@@ -94,16 +116,20 @@ module Selenium
             end
 
             if response.is_a? Net::HTTPRedirection
-              WebDriver.logger.debug("Redirect to #{response['Location']}; times: #{redirects}")
-              raise Error::WebDriverError, 'too many redirects' if redirects >= MAX_REDIRECTS
-
-              request(:get, URI.parse(response['Location']), DEFAULT_HEADERS.dup, nil, redirects + 1)
+              follow_redirect(response, redirects)
             else
               WebDriver.logger.debug("   <<<  #{response.instance_variable_get(:@header).inspect}", id: :header)
               create_response response.code, response.body, response.content_type
             end
           end
 
+          def follow_redirect(response, redirects)
+            WebDriver.logger.debug("Redirect to #{response['Location']}; times: #{redirects}")
+            raise Error::WebDriverError, 'too many redirects' if redirects >= client_config.max_redirects
+
+            request(:get, URI.parse(response['Location']), DEFAULT_HEADERS.dup, nil, redirects + 1)
+          end
+
           def new_request_for(verb, url, headers, payload)
             req = Net::HTTP.const_get(verb.to_s.capitalize).new(url.path, headers)
 
@@ -120,52 +146,43 @@ module Selenium
 
           def new_http_client
             if use_proxy?
-              url = @proxy.http
+              url = proxy.http
               unless proxy.respond_to?(:http) && url
                 raise Error::WebDriverError,
-                      "expected HTTP proxy, got #{@proxy.inspect}"
+                      "expected HTTP proxy, got #{proxy.inspect}"
               end
 
-              proxy = URI.parse(url)
+              proxy_uri = URI.parse(url)
 
-              Net::HTTP.new(server_url.host, server_url.port, proxy.host, proxy.port, proxy.user, proxy.password)
+              Net::HTTP.new(server_url.host, server_url.port,
+                            proxy_uri.host, proxy_uri.port, proxy_uri.user, proxy_uri.password)
             else
               Net::HTTP.new server_url.host, server_url.port
             end
           end
 
           def proxy
-            @proxy ||= begin
-              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://')
-                Proxy.new(http: proxy, no_proxy: no_proxy)
-              end
-            end
+            client_config.proxy
           end
 
           def use_proxy?
             return false if proxy.nil?
+            return true unless proxy.no_proxy
 
-            if proxy.no_proxy
-              ignored = proxy.no_proxy.split(',').any? do |host|
-                host == '*' ||
-                  host == server_url.host || (
-                begin
-                  IPAddr.new(host).include?(server_url.host)
-                rescue ArgumentError
-                  false
-                end
-              )
-              end
+            !proxy_ignored?
+          end
 
-              !ignored
-            else
-              true
+          def proxy_ignored?
+            proxy.no_proxy.split(',').map(&:strip).reject(&:empty?).any? do |host|
+              host == '*' || host == server_url.host || ip_match?(host)
             end
           end
+
+          def ip_match?(host)
+            IPAddr.new(host).include?(server_url.host)
+          rescue ArgumentError
+            false
+          end
         end # Default
       end # Http
     end # Remote

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

@@ -31,9 +31,9 @@ module Selenium
 
         include LocalDriver
 
-        def initialize(options: nil, service: nil, url: nil, **)
-          initialize_local_driver(options, service, url) do |caps, driver_url|
-            super(caps: caps, url: driver_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
 

data/lib/selenium/webdriver/version.rb

@@ -19,6 +19,6 @@
 
 module Selenium
   module WebDriver
-    VERSION = '4.45.0'
+    VERSION = '4.46.0'
   end # WebDriver
 end # Selenium