selenium-webdriver 4.1.0 → 4.23.0

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

@@ -0,0 +1,173 @@
+# 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 DevTools
+      #
+      # Wraps the network request/response interception, providing
+      # thread-safety guarantees and handling special cases such as browser
+      # canceling requests midst interception.
+      #
+      # You should not be using this class directly, use Driver#intercept instead.
+      # @api private
+      #
+
+      class NetworkInterceptor
+        # CDP fails to get body on certain responses (301) and raises:
+        # "Can only get response body on requests captured after headers received."
+        CANNOT_GET_BODY_ON_REDIRECT_ERROR_CODE = '-32000'
+
+        # CDP fails to operate with intercepted requests.
+        # Typical reason is browser cancelling intercepted requests/responses.
+        INVALID_INTERCEPTION_ID_ERROR_CODE = '-32602'
+
+        def initialize(devtools)
+          @devtools = devtools
+          @lock = Mutex.new
+        end
+
+        def intercept(&block)
+          devtools.network.on(:loading_failed) { |params| track_cancelled_request(params) }
+          devtools.fetch.on(:request_paused) { |params| request_paused(params, &block) }
+
+          devtools.network.set_cache_disabled(cache_disabled: true)
+          devtools.network.enable
+          devtools.fetch.enable(patterns: [{requestStage: 'Request'}, {requestStage: 'Response'}])
+        end
+
+        private
+
+        attr_accessor :devtools, :lock
+
+        # We should be thread-safe to use the hash without synchronization
+        # because its keys are interception job identifiers and they should be
+        # unique within a devtools session.
+        def pending_response_requests
+          @pending_response_requests ||= {}
+        end
+
+        # Ensure usage of cancelled_requests is thread-safe via synchronization!
+        def cancelled_requests
+          @cancelled_requests ||= []
+        end
+
+        def track_cancelled_request(data)
+          return unless data['canceled']
+
+          lock.synchronize { cancelled_requests << data['requestId'] }
+        end
+
+        def request_paused(data, &block)
+          id = data['requestId']
+          network_id = data['networkId']
+
+          with_cancellable_request(network_id) do
+            if response?(data)
+              block = pending_response_requests.delete(id)
+              intercept_response(id, data, &block)
+            else
+              intercept_request(id, data, &block)
+            end
+          end
+        end
+
+        # The presence of any of these fields indicate we're at the response stage.
+        # @see https://chromedevtools.github.io/devtools-protocol/tot/Fetch/#event-requestPaused
+        def response?(params)
+          params.key?('responseStatusCode') || params.key?('responseErrorReason')
+        end
+
+        def intercept_request(id, params, &block)
+          original = DevTools::Request.from(id, params)
+          mutable = DevTools::Request.from(id, params)
+
+          block.call(mutable) do |&continue|
+            pending_response_requests[id] = continue
+
+            if original == mutable
+              continue_request(original.id)
+            else
+              mutate_request(mutable)
+            end
+          end
+        end
+
+        def intercept_response(id, params)
+          return continue_response(id) unless block_given?
+
+          body = fetch_response_body(id)
+          original = DevTools::Response.from(id, body, params)
+          mutable = DevTools::Response.from(id, body, params)
+          yield mutable
+
+          if original == mutable
+            continue_response(id)
+          else
+            mutate_response(mutable)
+          end
+        end
+
+        def continue_request(id)
+          devtools.fetch.continue_request(request_id: id)
+        end
+        alias continue_response continue_request
+
+        def mutate_request(request)
+          devtools.fetch.continue_request(
+            request_id: request.id,
+            url: request.url,
+            method: request.method,
+            post_data: (Base64.strict_encode64(request.post_data) if request.post_data),
+            headers: request.headers.map do |k, v|
+              {name: k, value: v}
+            end
+          )
+        end
+
+        def mutate_response(response)
+          devtools.fetch.fulfill_request(
+            request_id: response.id,
+            body: (Base64.strict_encode64(response.body) if response.body),
+            response_code: response.code,
+            response_headers: response.headers.map do |k, v|
+              {name: k, value: v}
+            end
+          )
+        end
+
+        def fetch_response_body(id)
+          devtools.fetch.get_response_body(request_id: id).dig('result', 'body')
+        rescue Error::WebDriverError => e
+          raise unless e.message.start_with?(CANNOT_GET_BODY_ON_REDIRECT_ERROR_CODE)
+        end
+
+        def with_cancellable_request(network_id)
+          yield
+        rescue Error::WebDriverError => e
+          raise if e.message.start_with?(INVALID_INTERCEPTION_ID_ERROR_CODE) && !cancelled?(network_id)
+        end
+
+        def cancelled?(network_id)
+          lock.synchronize { !!cancelled_requests.delete(network_id) }
+        end
+      end # NetworkInterceptor
+    end # DevTools
+  end # WebDriver
+end # Selenium

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

@@ -21,7 +21,6 @@ module Selenium
   module WebDriver
     class DevTools
       class PinnedScript
-
         attr_accessor :key, :devtools_identifier, :script
 
         def initialize(script)
@@ -52,7 +51,6 @@ module Selenium
         def remove
           "__webdriver_#{key} = undefined"
         end
-
       end # PinnedScript
     end # DevTools
   end # WebDriver

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

@@ -21,7 +21,6 @@ module Selenium
   module WebDriver
     class DevTools
       class Request
-
         attr_accessor :url, :method, :headers, :post_data
         attr_reader :id
 
@@ -35,7 +34,7 @@ module Selenium
             id: id,
             url: params.dig('request', 'url'),
             method: params.dig('request', 'method'),
-            headers: params.dig('request', 'headers'),
+            headers: params.dig('request', 'headers').dup,
             post_data: params.dig('request', 'postData')
           )
         end
@@ -60,7 +59,6 @@ module Selenium
         def inspect
           %(#<#{self.class.name} @id="#{id}" @method="#{method}" @url="#{url}")
         end
-
       end # Request
     end # DevTools
   end # WebDriver

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

@@ -21,7 +21,6 @@ module Selenium
   module WebDriver
     class DevTools
       class Response
-
         attr_accessor :code, :body, :headers
         attr_reader :id
 
@@ -35,7 +34,7 @@ module Selenium
             id: id,
             code: params['responseStatusCode'],
             body: (Base64.strict_decode64(encoded_body) if encoded_body),
-            headers: params['responseHeaders'].each_with_object({}) do |header, hash|
+            headers: params.fetch('responseHeaders', []).each_with_object({}) do |header, hash|
               hash[header['name']] = header['value']
             end
           )
@@ -59,7 +58,6 @@ module Selenium
         def inspect
           %(#<#{self.class.name} @id="#{id}" @code="#{code}")
         end
-
       end # Response
     end # DevTools
   end # WebDriver

data/lib/selenium/webdriver/devtools.rb

@@ -20,59 +20,49 @@
 module Selenium
   module WebDriver
     class DevTools
-      RESPONSE_WAIT_TIMEOUT = 30
-      RESPONSE_WAIT_INTERVAL = 0.1
-
       autoload :ConsoleEvent, 'selenium/webdriver/devtools/console_event'
       autoload :ExceptionEvent, 'selenium/webdriver/devtools/exception_event'
       autoload :MutationEvent, 'selenium/webdriver/devtools/mutation_event'
+      autoload :NetworkInterceptor, 'selenium/webdriver/devtools/network_interceptor'
       autoload :PinnedScript, 'selenium/webdriver/devtools/pinned_script'
       autoload :Request, 'selenium/webdriver/devtools/request'
       autoload :Response, 'selenium/webdriver/devtools/response'
 
       def initialize(url:)
-        @callback_threads = ThreadGroup.new
-
-        @messages = []
+        @ws = WebSocketConnection.new(url: url)
         @session_id = nil
-        @url = url
-
-        process_handshake
-        @socket_thread = attach_socket_listener
         start_session
       end
 
       def close
-        @callback_threads.list.each(&:exit)
-        @socket_thread.exit
-        socket.close
+        @ws.close
       end
 
       def callbacks
-        @callbacks ||= Hash.new { |callbacks, event| callbacks[event] = [] }
+        @ws.callbacks
       end
 
       def send_cmd(method, **params)
-        id = next_id
-        data = {id: id, method: method, params: params.reject { |_, v| v.nil? }}
+        data = {method: method, params: params.compact}
         data[:sessionId] = @session_id if @session_id
-        data = JSON.generate(data)
-        WebDriver.logger.debug "DevTools -> #{data}"
-
-        out_frame = WebSocket::Frame::Outgoing::Client.new(version: ws.version, data: data, type: 'text')
-        socket.write(out_frame.to_s)
-
-        message = wait.until do
-          @messages.find { |m| m['id'] == id }
-        end
-
+        message = @ws.send_cmd(**data)
         raise Error::WebDriverError, error_message(message['error']) if message['error']
 
         message
       end
 
       def method_missing(method, *_args)
-        desired_class = "Selenium::DevTools::V#{Selenium::DevTools.version}::#{method.capitalize}"
+        namespace = "Selenium::DevTools::V#{Selenium::DevTools.version}"
+        methods_to_classes = "#{namespace}::METHODS_TO_CLASSES"
+
+        desired_class = if Object.const_defined?(methods_to_classes)
+                          # selenium-devtools 0.113 and newer
+                          "#{namespace}::#{Object.const_get(methods_to_classes)[method]}"
+                        else
+                          # selenium-devtools 0.112 and older
+                          "#{namespace}::#{method.capitalize}"
+                        end
+
         return unless Object.const_defined?(desired_class)
 
         self.class.class_eval do
@@ -91,32 +81,6 @@ module Selenium
 
       private
 
-      def process_handshake
-        socket.print(ws.to_s)
-        ws << socket.readpartial(1024)
-      end
-
-      def attach_socket_listener
-        Thread.new do
-          Thread.current.abort_on_exception = true
-          Thread.current.report_on_exception = false
-
-          until socket.eof?
-            incoming_frame << socket.readpartial(1024)
-
-            while (frame = incoming_frame.next)
-              message = process_frame(frame)
-              next unless message['method']
-
-              params = message['params']
-              callbacks[message['method']].each do |callback|
-                @callback_threads.add(callback_thread(params, &callback))
-              end
-            end
-          end
-        end
-      end
-
       def start_session
         targets = target.get_targets.dig('result', 'targetInfos')
         page_target = targets.find { |target| target['type'] == 'page' }
@@ -124,70 +88,9 @@ module Selenium
         @session_id = session.dig('result', 'sessionId')
       end
 
-      def incoming_frame
-        @incoming_frame ||= WebSocket::Frame::Incoming::Client.new(version: ws.version)
-      end
-
-      def process_frame(frame)
-        message = frame.to_s
-
-        # Firefox will periodically fail on unparsable empty frame
-        return {} if message.empty?
-
-        message = JSON.parse(message)
-        @messages << message
-        WebDriver.logger.debug "DevTools <- #{message}"
-
-        message
-      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
-
-          yield params
-        end
-      end
-
-      def wait
-        @wait ||= Wait.new(timeout: RESPONSE_WAIT_TIMEOUT, interval: RESPONSE_WAIT_INTERVAL)
-      end
-
-      def socket
-        @socket ||= begin
-          if URI(@url).scheme == 'wss'
-            socket = TCPSocket.new(ws.host, ws.port)
-            socket = OpenSSL::SSL::SSLSocket.new(socket, OpenSSL::SSL::SSLContext.new)
-            socket.sync_close = true
-            socket.connect
-
-            socket
-          else
-            TCPSocket.new(ws.host, ws.port)
-          end
-        end
-      end
-
-      def ws
-        @ws ||= WebSocket::Handshake::Client.new(url: @url)
-      end
-
-      def next_id
-        @id ||= 0
-        @id += 1
-      end
-
       def error_message(error)
         [error['code'], error['message'], error['data']].join(': ')
       end
-
     end # DevTools
   end # WebDriver
 end # Selenium

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

@@ -17,18 +17,24 @@
 # specific language governing permissions and limitations
 # under the License.
 
-require 'selenium/webdriver/chrome/driver'
+require 'selenium/webdriver/chromium/driver'
 
 module Selenium
   module WebDriver
     module Edge
-
       #
       # Driver implementation for Microsoft Edge.
       # @api private
       #
 
-      class Driver < Selenium::WebDriver::Chrome::Driver
+      class Driver < Chromium::Driver
+        include LocalDriver
+
+        def initialize(options: nil, service: nil, url: nil, **opts)
+          caps, url = initialize_local_driver(options, service, url)
+          super(caps: caps, url: url, **opts)
+        end
+
         def browser
           :edge
         end

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

@@ -17,26 +17,30 @@
 # specific language governing permissions and limitations
 # under the License.
 
-require 'selenium/webdriver/chrome/features'
+require 'selenium/webdriver/chromium/features'
 
 module Selenium
   module WebDriver
     module Edge
       module Features
-
-        include WebDriver::Chrome::Features
+        include WebDriver::Chromium::Features
 
         EDGE_COMMANDS = {
           get_cast_sinks: [:get, 'session/:session_id/ms/cast/get_sinks'],
           set_cast_sink_to_use: [:post, 'session/:session_id/ms/cast/set_sink_to_use'],
           start_cast_tab_mirroring: [:post, 'session/:session_id/ms/cast/start_tab_mirroring'],
+          start_cast_desktop_mirroring: [:post, 'session/:session_id/ms/cast/start_desktop_mirroring'],
           get_cast_issue_message: [:get, 'session/:session_id/ms/cast/get_issue_message'],
           stop_casting: [:post, 'session/:session_id/ms/cast/stop_casting'],
           send_command: [:post, 'session/:session_id/ms/cdp/execute']
         }.freeze
 
+        def command_list
+          EDGE_COMMANDS.merge(CHROMIUM_COMMANDS).merge(self.class::COMMANDS)
+        end
+
         def commands(command)
-          EDGE_COMMANDS[command] || Chrome::Features::CHROME_COMMANDS[command] || self.class::COMMANDS[command]
+          command_list[command]
         end
       end # Bridge
     end # Edge

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

@@ -17,23 +17,35 @@
 # specific language governing permissions and limitations
 # under the License.
 
-require 'selenium/webdriver/chrome/options'
+require 'selenium/webdriver/chromium/options'
 
 module Selenium
   module WebDriver
     module Edge
-      class Options < Selenium::WebDriver::Chrome::Options
+      class Options < Chromium::Options
         KEY = 'ms:edgeOptions'
         BROWSER = 'MicrosoftEdge'
 
-        protected
+        #
+        # Changes the browser name enable webview2
+        # see: https://learn.microsoft.com/en-us/microsoft-edge/webview2/how-to/webdriver
+        # Automation of WebView2 apps with Microsoft Edge WebDriver
+        #
+        # @example Enable webview2
+        #   options = Selenium::WebDriver::Edge::Options.new
+        #   options.webview2!
+        #
 
-        def enable_logging(browser_options)
-          browser_options['ms:loggingPrefs'] = @logging_prefs
+        def webview2!
+          @options[:browser_name] = 'webview2'
         end
 
         private
 
+        def enable_logging(browser_options)
+          browser_options['ms:loggingPrefs'] = @logging_prefs
+        end
+
         def binary_path
           Edge.path
         end

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

@@ -17,7 +17,7 @@
 # specific language governing permissions and limitations
 # under the License.
 
-require 'selenium/webdriver/chrome/profile'
+require 'selenium/webdriver/chromium/profile'
 
 module Selenium
   module WebDriver
@@ -26,7 +26,7 @@ module Selenium
       # @private
       #
 
-      class Profile < Selenium::WebDriver::Chrome::Profile
+      class Profile < Chromium::Profile
       end # Profile
     end # Edge
   end # WebDriver

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

@@ -17,19 +17,20 @@
 # specific language governing permissions and limitations
 # under the License.
 
-require 'selenium/webdriver/chrome/service'
-
 module Selenium
   module WebDriver
     module Edge
-      class Service < Selenium::WebDriver::Chrome::Service
+      class Service < WebDriver::Service
         DEFAULT_PORT = 9515
         EXECUTABLE = 'msedgedriver'
-        MISSING_TEXT = <<~ERROR
-          Unable to find msedgedriver. Please download the server from
-          https://developer.microsoft.com/en-us/microsoft-edge/tools/webdriver/ and place it somewhere on your PATH.
-        ERROR
         SHUTDOWN_SUPPORTED = true
+
+        def log
+          return @log unless @log.is_a? String
+
+          @args << "--log-path=#{@log}"
+          @log = nil
+        end
       end # Service
     end # Edge
   end # WebDriver

data/lib/selenium/webdriver/edge.rb

@@ -17,8 +17,6 @@
 # specific language governing permissions and limitations
 # under the License.
 
-require 'net/http'
-
 module Selenium
   module WebDriver
     module Edge

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

@@ -20,7 +20,6 @@
 module Selenium
   module WebDriver
     module Firefox
-
       #
       # Driver implementation for Firefox using GeckoDriver.
       # @api private
@@ -30,12 +29,20 @@ module Selenium
         EXTENSIONS = [DriverExtensions::HasAddons,
                       DriverExtensions::FullPageScreenshot,
                       DriverExtensions::HasContext,
+                      DriverExtensions::HasBiDi,
                       DriverExtensions::HasDevTools,
                       DriverExtensions::HasLogEvents,
                       DriverExtensions::HasNetworkInterception,
                       DriverExtensions::HasWebStorage,
                       DriverExtensions::PrintsPage].freeze
 
+        include LocalDriver
+
+        def initialize(options: nil, service: nil, url: nil, **opts)
+          caps, url = initialize_local_driver(options, service, url)
+          super(caps: caps, url: url, **opts)
+        end
+
         def browser
           :firefox
         end
@@ -44,7 +51,7 @@ module Selenium
 
         def devtools_url
           if capabilities['moz:debuggerAddress'].nil?
-            raise(Error::WebDriverError, "DevTools is not supported by this version of Firefox; use v85 or higher")
+            raise(Error::WebDriverError, 'DevTools is not supported by this version of Firefox; use v85 or higher')
           end
 
           uri = URI("http://#{capabilities['moz:debuggerAddress']}")

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

@@ -21,7 +21,6 @@ module Selenium
   module WebDriver
     module Firefox
       module Features
-
         FIREFOX_COMMANDS = {
           get_context: [:get, 'session/:session_id/moz/context'],
           set_context: [:post, 'session/:session_id/moz/context'],
@@ -30,17 +29,22 @@ module Selenium
           full_page_screenshot: [:get, 'session/:session_id/moz/screenshot/full']
         }.freeze
 
+        def command_list
+          FIREFOX_COMMANDS.merge(self.class::COMMANDS)
+        end
+
         def commands(command)
-          FIREFOX_COMMANDS[command] || self.class::COMMANDS[command]
+          command_list[command]
         end
 
         def install_addon(path, temporary)
-          if @file_detector
-            local_file = @file_detector.call(path)
-            path = upload(local_file) if local_file
-          end
+          addon = if File.directory?(path)
+                    Zipper.zip(path)
+                  else
+                    File.open(path, 'rb') { |crx_file| Base64.strict_encode64 crx_file.read }
+                  end
 
-          payload = {path: path}
+          payload = {addon: addon}
           payload[:temporary] = temporary unless temporary.nil?
           execute :install_addon, {}, payload
         end