[rb] allow setting socket timeout and interval from http client

Author: titusfortner

rb/lib/selenium/webdriver/bidi.rb

@@ -31,8 +31,8 @@ class BiDi
       autoload :InterceptedAuth, 'selenium/webdriver/bidi/network/intercepted_auth'
       autoload :InterceptedItem, 'selenium/webdriver/bidi/network/intercepted_item'
 
-      def initialize(url:)
-        @ws = WebSocketConnection.new(url: url)
+      def initialize(url:, http:)
+        @ws = WebSocketConnection.new(url: url, http: http)
       end
 
       def close

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

@@ -21,19 +21,23 @@
 
 module Selenium
   module WebDriver
+    #
+    # WebSocketConnection manages lifecycle of sockets for Devtools and BiDi implementations.
+    # @api private
+    #
+
     class WebSocketConnection
       CONNECTION_ERRORS = [
         Errno::ECONNRESET, # connection is aborted (browser process was killed)
         Errno::EPIPE # broken pipe (browser process was killed)
       ].freeze
 
-      RESPONSE_WAIT_TIMEOUT = 30
-      RESPONSE_WAIT_INTERVAL = 0.1
-
       MAX_LOG_MESSAGE_SIZE = 9999
 
-      def initialize(url:)
+      def initialize(url:, http: nil)
         @callback_threads = ThreadGroup.new
+        @socket_timeout = http&.socket_timeout || 30
+        @socket_interval = http&.socket_interval || 0.1
 
         @session_id = nil
         @url = url
@@ -147,7 +151,7 @@ def callback_thread(params)
       end
 
       def wait
-        @wait ||= Wait.new(timeout: RESPONSE_WAIT_TIMEOUT, interval: RESPONSE_WAIT_INTERVAL)
+        @wait ||= Wait.new(timeout: @socket_timeout, interval: @socket_interval)
       end
 
       def socket

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

@@ -26,7 +26,7 @@ class BiDiBridge < Bridge
         def create_session(capabilities)
           super
           socket_url = @capabilities[:web_socket_url]
-          @bidi = Selenium::WebDriver::BiDi.new(url: socket_url)
+          @bidi = Selenium::WebDriver::BiDi.new(url: socket_url, http: @http)
         end
 
         def get(url)

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

@@ -22,20 +22,21 @@ module Selenium
   module WebDriver
     module Remote
       module Http
-        # @api private
         class Default < Common
           attr_writer :proxy
 
-          attr_accessor :open_timeout, :read_timeout
+          attr_accessor :open_timeout, :read_timeout, :socket_timeout, :socket_interval
 
           # 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 [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)
+          def initialize(open_timeout: nil, read_timeout: nil, socket_timeout: 30, socket_interval: 0.1)
             @open_timeout = open_timeout
             @read_timeout = read_timeout
+            @socket_timeout = socket_timeout
+            @socket_interval = socket_interval
             super()
           end
 

rb/sig/lib/selenium/webdriver/common/websocket_connection.rbs

@@ -7,6 +7,10 @@ module Selenium
 
       @session_id: untyped
 
+      @socket_interval: float
+
+      @socket_timeout: int
+
       @url: untyped
 
       @socket_thread: untyped

rb/sig/lib/selenium/webdriver/remote/http/default.rbs

@@ -18,6 +18,10 @@ module Selenium
 
           attr_accessor read_timeout: untyped
 
+          attr_accessor socket_timeout: int
+
+          attr_accessor socket_interval: float
+
           def initialize: (?open_timeout: untyped?, ?read_timeout: untyped?) -> void
 
           def close: () -> untyped

rb/spec/integration/selenium/webdriver/spec_support/test_environment.rb

@@ -31,6 +31,7 @@ def initialize
           WebDriver.logger.ignore(:logger_info)
           SeleniumManager.bin_path = root.join('bazel-bin/rb/bin').to_s if File.exist?(root.join('bazel-bin/rb/bin'))
 
+          ENV['WEBDRIVER_BIDI'] = 'true'
           @driver = ENV.fetch('WD_SPEC_DRIVER', 'chrome').tr('-', '_').to_sym
           @driver_instance = nil
           @remote_server = nil
@@ -168,14 +169,17 @@ def root
           @root ||= Pathname.new('../../../../../../../').realpath(__FILE__)
         end
 
-        def create_driver!(listener: nil, **, &block)
+        def create_driver!(listener: nil, **opts, &block)
           check_for_previous_error
 
+          socket_timeout = opts.delete(:socket_timeout)
+          http_client = WebDriver::Remote::Http::Default.new(socket_timeout: socket_timeout) if socket_timeout
+
           method = :"#{driver}_driver"
           instance = if private_methods.include?(method)
-                       send(method, listener: listener, options: build_options(**))
+                       send(method, listener: listener, http_client: http_client, options: build_options(**opts))
                      else
-                       WebDriver::Driver.for(driver, listener: listener, options: build_options(**))
+                       WebDriver::Driver.for(driver, listener: listener, options: build_options(**opts))
                      end
           @create_driver_error_count -= 1 unless @create_driver_error_count.zero?
           if block

rb/spec/unit/selenium/webdriver/remote/http/default_spec.rb

@@ -36,17 +36,21 @@ module Http
 
             expect(http.open_timeout).to eq 60
             expect(http.read_timeout).to eq 60
+            expect(http.socket_timeout).to eq 30
+            expect(http.socket_interval).to eq 0.1
           end
 
           describe '#initialize' do
-            let(:client) { described_class.new(read_timeout: 22, open_timeout: 23) }
-
-            it 'accepts read timeout options' do
+            it 'constructs values' do
+              client = described_class.new(read_timeout: 22,
+                                           open_timeout: 23,
+                                           socket_timeout: 4,
+                                           socket_interval: 0.5)
               expect(client.open_timeout).to eq 23
-            end
-
-            it 'accepts open timeout options' do
               expect(client.read_timeout).to eq 22
+              expect(client.socket_timeout).to eq 4
+              expect(client.socket_interval).to eq 0.5
+
             end
           end