selenium-webdriver 4.23.0 → 4.31.0

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

@@ -0,0 +1,139 @@
+# 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_relative 'network/url_pattern'
+
+module Selenium
+  module WebDriver
+    class BiDi
+      class Network
+        EVENTS = {
+          before_request: 'network.beforeRequestSent',
+          response_started: 'network.responseStarted',
+          response_completed: 'network.responseCompleted',
+          auth_required: 'network.authRequired',
+          fetch_error: 'network.fetchError'
+        }.freeze
+
+        PHASES = {
+          before_request: 'beforeRequestSent',
+          response_started: 'responseStarted',
+          auth_required: 'authRequired'
+        }.freeze
+
+        def initialize(bidi)
+          @bidi = bidi
+        end
+
+        def add_intercept(phases: [], contexts: nil, url_patterns: nil, pattern_type: :string)
+          url_patterns = url_patterns && pattern_type ? UrlPattern.format_pattern(url_patterns, pattern_type) : nil
+          @bidi.send_cmd('network.addIntercept',
+                         phases: phases,
+                         contexts: contexts,
+                         urlPatterns: url_patterns)
+        end
+
+        def remove_intercept(intercept)
+          @bidi.send_cmd('network.removeIntercept', intercept: intercept)
+        end
+
+        def continue_with_auth(request_id, username, password)
+          @bidi.send_cmd(
+            'network.continueWithAuth',
+            request: request_id,
+            action: 'provideCredentials',
+            credentials: {
+              type: 'password',
+              username: username,
+              password: password
+            }
+          )
+        end
+
+        def continue_without_auth(request_id)
+          @bidi.send_cmd(
+            'network.continueWithAuth',
+            request: request_id,
+            action: 'default'
+          )
+        end
+
+        def cancel_auth(request_id)
+          @bidi.send_cmd(
+            'network.continueWithAuth',
+            request: request_id,
+            action: 'cancel'
+          )
+        end
+
+        def continue_request(**args)
+          @bidi.send_cmd(
+            'network.continueRequest',
+            request: args[:id],
+            body: args[:body],
+            cookies: args[:cookies],
+            headers: args[:headers],
+            method: args[:method],
+            url: args[:url]
+          )
+        end
+
+        def fail_request(request_id)
+          @bidi.send_cmd(
+            'network.failRequest',
+            request: request_id
+          )
+        end
+
+        def continue_response(**args)
+          @bidi.send_cmd(
+            'network.continueResponse',
+            request: args[:id],
+            cookies: args[:cookies],
+            credentials: args[:credentials],
+            headers: args[:headers],
+            reasonPhrase: args[:reason],
+            statusCode: args[:status]
+          )
+        end
+
+        def provide_response(**args)
+          @bidi.send_cmd(
+            'network.provideResponse',
+            request: args[:id],
+            body: args[:body],
+            cookies: args[:cookies],
+            headers: args[:headers],
+            reasonPhrase: args[:reason],
+            statusCode: args[:status]
+          )
+        end
+
+        def set_cache_behavior(behavior, *contexts)
+          @bidi.send_cmd('network.setCacheBehavior', cacheBehavior: behavior, contexts: contexts)
+        end
+
+        def on(event, &block)
+          event = EVENTS[event] if event.is_a?(Symbol)
+          @bidi.add_callback(event, &block)
+          @bidi.session.subscribe(event)
+        end
+      end # Network
+    end # BiDi
+  end # WebDriver
+end # Selenium

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

@@ -23,7 +23,7 @@ module Selenium
       class Struct < ::Struct
         class << self
           def new(*args, &block)
-            super(*args) do
+            super do
               define_method(:initialize) do |**kwargs|
                 converted_kwargs = kwargs.transform_keys { |key| self.class.camel_to_snake(key.to_s).to_sym }
                 super(*converted_kwargs.values_at(*self.class.members))
@@ -37,8 +37,6 @@ module Selenium
           end
         end
       end
-    end
-
-    # BiDi
+    end # BiDi
   end # WebDriver
 end # Selenium

data/lib/selenium/webdriver/bidi.rb

@@ -25,6 +25,11 @@ module Selenium
       autoload :LogHandler, 'selenium/webdriver/bidi/log_handler'
       autoload :BrowsingContext, 'selenium/webdriver/bidi/browsing_context'
       autoload :Struct, 'selenium/webdriver/bidi/struct'
+      autoload :Network, 'selenium/webdriver/bidi/network'
+      autoload :InterceptedRequest, 'selenium/webdriver/bidi/network/intercepted_request'
+      autoload :InterceptedResponse, 'selenium/webdriver/bidi/network/intercepted_response'
+      autoload :InterceptedAuth, 'selenium/webdriver/bidi/network/intercepted_auth'
+      autoload :InterceptedItem, 'selenium/webdriver/bidi/network/intercepted_item'
 
       def initialize(url:)
         @ws = WebSocketConnection.new(url: url)

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

@@ -24,6 +24,7 @@ module Selenium
         DEFAULT_PORT = 9515
         EXECUTABLE = 'chromedriver'
         SHUTDOWN_SUPPORTED = true
+        DRIVER_PATH_ENV_KEY = 'SE_CHROMEDRIVER'
 
         def log
           return @log unless @log.is_a? String

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

@@ -32,7 +32,6 @@ module Selenium
                       DriverExtensions::HasFedCmDialog,
                       DriverExtensions::HasNetworkConditions,
                       DriverExtensions::HasNetworkInterception,
-                      DriverExtensions::HasWebStorage,
                       DriverExtensions::HasLaunching,
                       DriverExtensions::HasPermissions,
                       DriverExtensions::DownloadsFiles,

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

@@ -64,16 +64,10 @@ module Selenium
         return unless @pid
         return if exited?
 
-        WebDriver.logger.debug("Sending TERM to process: #{@pid}", id: :process)
-        terminate(@pid)
-        poll_for_exit(timeout)
-
-        WebDriver.logger.debug("  -> stopped #{@pid}", id: :process)
-      rescue TimeoutError, Errno::EINVAL
-        WebDriver.logger.debug("    -> sending KILL to process: #{@pid}", id: :process)
-        kill(@pid)
-        wait
-        WebDriver.logger.debug("      -> killed #{@pid}", id: :process)
+        terminate_and_wait_else_kill(timeout)
+      rescue Errno::ECHILD, Errno::ESRCH => e
+        # Process exited earlier than terminate/kill could catch
+        WebDriver.logger.debug("    -> process: #{@pid} does not exist (#{e.class.name})", id: :process)
       end
 
       def alive?
@@ -91,6 +85,9 @@ module Selenium
         WebDriver.logger.debug("  -> exit code is #{exit_code.inspect}", id: :process)
 
         !!exit_code
+      rescue Errno::ECHILD, Errno::ESRCH
+        WebDriver.logger.debug("  -> process: #{@pid} already finished", id: :process)
+        true
       end
 
       def poll_for_exit(timeout)
@@ -110,20 +107,29 @@ module Selenium
 
       private
 
+      def terminate_and_wait_else_kill(timeout)
+        WebDriver.logger.debug("Sending TERM to process: #{@pid}", id: :process)
+        terminate(@pid)
+        poll_for_exit(timeout)
+
+        WebDriver.logger.debug("  -> stopped #{@pid}", id: :process)
+      rescue TimeoutError, Errno::EINVAL
+        WebDriver.logger.debug("    -> sending KILL to process: #{@pid}", id: :process)
+        kill(@pid)
+        wait
+        WebDriver.logger.debug("      -> killed #{@pid}", id: :process)
+      end
+
       def terminate(pid)
         Process.kill(SIGTERM, pid)
       end
 
       def kill(pid)
         Process.kill(SIGKILL, pid)
-      rescue Errno::ECHILD, Errno::ESRCH
-        # already dead
       end
 
       def waitpid2(pid, flags = 0)
         Process.waitpid2(pid, flags)
-      rescue Errno::ECHILD
-        # already dead
       end
     end # ChildProcess
   end # WebDriver

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

@@ -104,15 +104,8 @@ module Selenium
       # @see Script
       #
 
-      def script(*args)
-        if args.any?
-          WebDriver.logger.deprecate('`Driver#script` as an alias for `#execute_script`',
-                                     '`Driver#execute_script`',
-                                     id: :driver_script)
-          execute_script(*args)
-        else
-          @script ||= WebDriver::Script.new(bridge)
-        end
+      def script
+        @script ||= WebDriver::Script.new(bridge)
       end
 
       #
@@ -188,7 +181,7 @@ module Selenium
         bridge.quit
       ensure
         @service_manager&.stop
-        @devtools&.close
+        @devtools&.each_value(&:close)
       end
 
       #
@@ -264,6 +257,15 @@ module Selenium
         bridge.add_virtual_authenticator(options)
       end
 
+      #
+      # @return [Network]
+      # @see Network
+      #
+
+      def network
+        @network ||= WebDriver::Network.new(bridge)
+      end
+
       #-------------------------------- sugar  --------------------------------
 
       #

data/lib/selenium/webdriver/common/driver_extensions/has_devtools.rb

@@ -27,12 +27,13 @@ module Selenium
         # @return [DevTools]
         #
 
-        def devtools
-          @devtools ||= begin
+        def devtools(target_type: 'page')
+          @devtools ||= {}
+          @devtools[target_type] ||= begin
             require 'selenium/devtools'
             Selenium::DevTools.version ||= devtools_version
             Selenium::DevTools.load_version
-            Selenium::WebDriver::DevTools.new(url: devtools_url)
+            Selenium::WebDriver::DevTools.new(url: devtools_url, target_type: target_type)
           end
         end
       end # HasDevTools

data/lib/selenium/webdriver/common/driver_extensions/has_log_events.rb

@@ -57,6 +57,13 @@ module Selenium
         #
 
         def on_log_event(kind, &block)
+          if browser == :firefox
+            WebDriver.logger.deprecate(
+              'Driver#on_log_event on Firefox',
+              'the script.add_console_message_handler or the script.add_javascript_error_handler methods',
+              id: :on_log_event
+            )
+          end
           raise Error::WebDriverError, "Don't know how to handle #{kind} events" unless KINDS.include?(kind)
 
           enabled = log_listeners[kind].any?

data/lib/selenium/webdriver/common/driver_extensions/has_network_interception.rb

@@ -60,6 +60,13 @@ module Selenium
         #
 
         def intercept(&block)
+          if browser == :firefox
+            WebDriver.logger.deprecate(
+              'Driver#intercept on Firefox',
+              'the new bidi.network.add_intercept method',
+              id: :intercept
+            )
+          end
           @interceptor ||= DevTools::NetworkInterceptor.new(devtools)
           @interceptor.intercept(&block)
         end

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

@@ -50,9 +50,11 @@ module Selenium
           super(URLS[class_name] ? "#{msg}; #{SUPPORT_MSG} #{URLS[class_name]}" : msg)
         end
 
+        # steep:ignore:start
         def class_name
-          self.class.name&.split('::')&.last&.to_sym
+          self.class.name.split('::')&.last&.to_sym
         end
+        # steep:ignore:end
       end
 
       #

data/lib/selenium/webdriver/common/fedcm/account.rb

@@ -21,8 +21,8 @@ module Selenium
   module WebDriver
     module FedCM
       # Represents an account displayed in a FedCm account list.
-      # See: https://fedidcg.github.io/FedCM/#dictdef-identityprovideraccount
-      #      https://fedidcg.github.io/FedCM/#webdriver-accountlist
+      # See: https://w3c-fedid.github.io/FedCM/#dictdef-identityprovideraccount
+      #      https://w3c-fedid.github.io/FedCM/#webdriver-accountlist
       class Account
         LOGIN_STATE_SIGNIN = 'SignIn'
         LOGIN_STATE_SIGNUP = 'SignUp'
@@ -30,9 +30,7 @@ module Selenium
         attr_reader :account_id, :email, :name, :given_name, :picture_url,
                     :idp_config_url, :login_state, :terms_of_service_url, :privacy_policy_url
 
-        # Initializes a new account with the provided attributes.
-        #
-        # @param [Hash]
+        # steep:ignore:start
         def initialize(**args)
           @account_id = args['accountId']
           @email = args['email']
@@ -44,6 +42,7 @@ module Selenium
           @terms_of_service_url = args['termsOfServiceUrl']
           @privacy_policy_url = args['privacyPolicyUrl']
         end
+        # steep:ignore:end
       end # Account
     end # FedCM
   end # WebDriver

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

@@ -167,7 +167,7 @@ module Selenium
 
         id << :deprecations if @allowed.include?(:deprecations)
 
-        message = +"[DEPRECATION] #{old} is deprecated"
+        message = "[DEPRECATION] #{old} is deprecated"
         message << if new
                      ". Use #{new} instead."
                    else
@@ -193,8 +193,8 @@ module Selenium
 
       def discard_or_log(level, message, id)
         id = Array(id)
-        return if (@ignored & id).any?
-        return if @allowed.any? && (@allowed & id).none?
+        return if @ignored.intersect?(id)
+        return if @allowed.any? && !@allowed.intersect?(id)
 
         return if ::Logger::Severity.const_get(level.upcase) < @logger.level
 

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

@@ -65,7 +65,7 @@ module Selenium
       # Get the cookie with the given name
       #
       # @param [String] name the name of the cookie
-      # @return [Hash, nil] the cookie, or nil if it wasn't found.
+      # @return [Hash] the cookie, or throws a NoSuchCookieError if it wasn't found.
       #
 
       def cookie_named(name)

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

@@ -0,0 +1,102 @@
+# 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 'forwardable'
+
+module Selenium
+  module WebDriver
+    class Network
+      extend Forwardable
+
+      attr_reader :callbacks, :network
+      alias bidi network
+
+      def_delegators :network, :continue_with_auth, :continue_with_request, :continue_with_response
+
+      def initialize(bridge)
+        @network = BiDi::Network.new(bridge.bidi)
+        @callbacks = {}
+      end
+
+      def remove_handler(id)
+        intercept = callbacks[id]
+        network.remove_intercept(intercept['intercept'])
+        callbacks.delete(id)
+      end
+
+      def clear_handlers
+        callbacks.each_key { |id| remove_handler(id) }
+      end
+
+      def add_authentication_handler(username = nil, password = nil, *filter, pattern_type: nil, &block)
+        selected_block =
+          if username && password
+            proc { |auth| auth.authenticate(username, password) }
+          else
+            block
+          end
+
+        add_handler(
+          :auth_required,
+          BiDi::Network::PHASES[:auth_required],
+          BiDi::InterceptedAuth,
+          filter,
+          pattern_type: pattern_type,
+          &selected_block
+        )
+      end
+
+      def add_request_handler(*filter, pattern_type: nil, &block)
+        add_handler(
+          :before_request,
+          BiDi::Network::PHASES[:before_request],
+          BiDi::InterceptedRequest,
+          filter,
+          pattern_type: pattern_type,
+          &block
+        )
+      end
+
+      def add_response_handler(*filter, pattern_type: nil, &block)
+        add_handler(
+          :response_started,
+          BiDi::Network::PHASES[:response_started],
+          BiDi::InterceptedResponse,
+          filter,
+          pattern_type: pattern_type,
+          &block
+        )
+      end
+
+      private
+
+      def add_handler(event_type, phase, intercept_type, filter, pattern_type: nil)
+        intercept = network.add_intercept(phases: [phase], url_patterns: [filter].flatten, pattern_type: pattern_type)
+        callback_id = network.on(event_type) do |event|
+          request = event['request']
+          intercepted_item = intercept_type.new(network, request)
+          yield(intercepted_item)
+        end
+
+        callbacks[callback_id] = intercept
+        callback_id
+      end
+    end # Network
+  end # WebDriver
+end # Selenium

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

@@ -69,6 +69,7 @@ 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
@@ -87,16 +88,22 @@ module Selenium
       end
 
       def launch
-        @executable_path ||= begin
-          default_options = WebDriver.const_get("#{self.class.name&.split('::')&.[](2)}::Options").new
-          DriverFinder.new(default_options, self).driver_path
-        end
+        @executable_path ||= env_path || find_driver_path
         ServiceManager.new(self).tap(&:start)
       end
 
       def shutdown_supported
         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
+
+      def env_path
+        ENV.fetch(self.class::DRIVER_PATH_ENV_KEY, nil)
+      end
     end # Service
   end # WebDriver
 end # Selenium

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

@@ -113,6 +113,7 @@ module Selenium
       def stop_server
         connect_to_server do |http|
           headers = WebDriver::Remote::Http::Common::DEFAULT_HEADERS.dup
+          WebDriver.logger.debug('Sending shutdown request to server', id: :driver_service)
           http.get('/shutdown', headers)
         end
       end

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

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

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

@@ -50,6 +50,7 @@ module Selenium
       # @param type either :tab or :window
       #
 
+      # steep:ignore:start
       def new_window(type = :window)
         raise ArgumentError, "Valid types are :tab and :window, received: #{type.inspect}" unless %i[window
                                                                                                      tab].include?(type)
@@ -70,6 +71,7 @@ module Selenium
           window(handle)
         end
       end
+      # steep:ignore:end
 
       #
       # switch to the given window handle
@@ -96,12 +98,11 @@ module Selenium
           @bridge.switch_to_window id
 
           begin
-            returned = yield
+            yield
           ensure
             current_handles = @bridge.window_handles
             original = current_handles.first unless current_handles.include? original
             @bridge.switch_to_window original
-            returned
           end
         else
           @bridge.switch_to_window id

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

@@ -65,7 +65,7 @@ module Selenium
         msg = if @message
                 @message.dup
               else
-                +"timed out after #{@timeout} seconds"
+                "timed out after #{@timeout} seconds"
               end
 
         msg << " (#{last_error.message})" if last_error

data/lib/selenium/webdriver/common.rb

@@ -63,10 +63,6 @@ require 'selenium/webdriver/common/action_builder'
 require 'selenium/webdriver/common/virtual_authenticator/credential'
 require 'selenium/webdriver/common/virtual_authenticator/virtual_authenticator_options'
 require 'selenium/webdriver/common/virtual_authenticator/virtual_authenticator'
-require 'selenium/webdriver/common/html5/shared_web_storage'
-require 'selenium/webdriver/common/html5/local_storage'
-require 'selenium/webdriver/common/html5/session_storage'
-require 'selenium/webdriver/common/driver_extensions/has_web_storage'
 require 'selenium/webdriver/common/driver_extensions/downloads_files'
 require 'selenium/webdriver/common/driver_extensions/has_session_id'
 require 'selenium/webdriver/common/driver_extensions/has_network_conditions'
@@ -102,3 +98,4 @@ require 'selenium/webdriver/common/child_process'
 require 'selenium/webdriver/common/script'
 require 'selenium/webdriver/common/fedcm/account'
 require 'selenium/webdriver/common/fedcm/dialog'
+require 'selenium/webdriver/common/network'

data/lib/selenium/webdriver/devtools.rb

@@ -28,10 +28,10 @@ module Selenium
       autoload :Request, 'selenium/webdriver/devtools/request'
       autoload :Response, 'selenium/webdriver/devtools/response'
 
-      def initialize(url:)
+      def initialize(url:, target_type:)
         @ws = WebSocketConnection.new(url: url)
         @session_id = nil
-        start_session
+        start_session(target_type: target_type)
       end
 
       def close
@@ -81,10 +81,12 @@ module Selenium
 
       private
 
-      def start_session
+      def start_session(target_type:)
         targets = target.get_targets.dig('result', 'targetInfos')
-        page_target = targets.find { |target| target['type'] == 'page' }
-        session = target.attach_to_target(target_id: page_target['targetId'], flatten: true)
+        found_target = targets.find { |target| target['type'] == target_type }
+        raise Error::WebDriverError, "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')
       end
 

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

@@ -24,7 +24,7 @@ module Selenium
         DEFAULT_PORT = 9515
         EXECUTABLE = 'msedgedriver'
         SHUTDOWN_SUPPORTED = true
-
+        DRIVER_PATH_ENV_KEY = 'SE_EDGEDRIVER'
         def log
           return @log unless @log.is_a? String