selenium-webdriver 4.1.0 → 4.4.0

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

@@ -0,0 +1,156 @@
+# 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 'websocket'
+
+module Selenium
+  module WebDriver
+    class WebSocketConnection
+      RESPONSE_WAIT_TIMEOUT = 30
+      RESPONSE_WAIT_INTERVAL = 0.1
+
+      MAX_LOG_MESSAGE_SIZE = 9999
+
+      def initialize(url:)
+        @callback_threads = ThreadGroup.new
+
+        @session_id = nil
+        @url = url
+
+        process_handshake
+        @socket_thread = attach_socket_listener
+      end
+
+      def close
+        @callback_threads.list.each(&:exit)
+        @socket_thread.exit
+        socket.close
+      end
+
+      def callbacks
+        @callbacks ||= Hash.new { |callbacks, event| callbacks[event] = [] }
+      end
+
+      def send_cmd(**payload)
+        id = next_id
+        data = payload.merge(id: id)
+        WebDriver.logger.debug "WebSocket -> #{data}"[...MAX_LOG_MESSAGE_SIZE]
+        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) }
+      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)
+      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 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["id"]] = message
+        WebDriver.logger.debug "WebSocket <- #{message}"[...MAX_LOG_MESSAGE_SIZE]
+
+        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 ||= 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
+
+      def ws
+        @ws ||= WebSocket::Handshake::Client.new(url: @url)
+      end
+
+      def next_id
+        @id ||= 0
+        @id += 1
+      end
+
+    end # BiDi
+  end # WebDriver
+end # Selenium

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

@@ -36,8 +36,8 @@ module Selenium
 
       def size=(dimension)
         unless dimension.respond_to?(:width) && dimension.respond_to?(:height)
-          raise ArgumentError, "expected #{dimension.inspect}:#{dimension.class}" \
-                               ' to respond to #width and #height'
+          raise ArgumentError, "expected #{dimension.inspect}:#{dimension.class} " \
+                               'to respond to #width and #height'
         end
 
         @bridge.resize_window dimension.width, dimension.height
@@ -61,8 +61,8 @@ module Selenium
 
       def position=(point)
         unless point.respond_to?(:x) && point.respond_to?(:y)
-          raise ArgumentError, "expected #{point.inspect}:#{point.class}" \
-                               ' to respond to #x and #y'
+          raise ArgumentError, "expected #{point.inspect}:#{point.class} " \
+                               'to respond to #x and #y'
         end
 
         @bridge.reposition_window point.x, point.y
@@ -86,8 +86,8 @@ module Selenium
 
       def rect=(rectangle)
         unless %w[x y width height].all? { |val| rectangle.respond_to? val }
-          raise ArgumentError, "expected #{rectangle.inspect}:#{rectangle.class}" \
-                               ' to respond to #x, #y, #width, and #height'
+          raise ArgumentError, "expected #{rectangle.inspect}:#{rectangle.class} " \
+                               'to respond to #x, #y, #width, and #height'
         end
 
         @bridge.set_window_rect(x: rectangle.x,

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

@@ -41,7 +41,7 @@ module Selenium
               to      = File.join(destination, entry.name)
               dirname = File.dirname(to)
 
-              FileUtils.mkdir_p dirname unless File.exist? dirname
+              FileUtils.mkdir_p dirname
               zip.extract(entry, to)
             end
           end

data/lib/selenium/webdriver/common.rb

@@ -38,15 +38,28 @@ require 'selenium/webdriver/common/logger'
 require 'selenium/webdriver/common/logs'
 require 'selenium/webdriver/common/manager'
 require 'selenium/webdriver/common/search_context'
+require 'selenium/webdriver/common/interactions/interaction'
+require 'selenium/webdriver/common/interactions/interactions'
+require 'selenium/webdriver/common/interactions/pointer_event_properties'
+require 'selenium/webdriver/common/interactions/pointer_cancel'
+require 'selenium/webdriver/common/interactions/pointer_move'
+require 'selenium/webdriver/common/interactions/pointer_press'
+require 'selenium/webdriver/common/interactions/typing_interaction'
+require 'selenium/webdriver/common/interactions/pause'
 require 'selenium/webdriver/common/interactions/key_actions'
 require 'selenium/webdriver/common/interactions/pointer_actions'
-require 'selenium/webdriver/common/interactions/interactions'
 require 'selenium/webdriver/common/interactions/input_device'
-require 'selenium/webdriver/common/interactions/interaction'
 require 'selenium/webdriver/common/interactions/none_input'
 require 'selenium/webdriver/common/interactions/key_input'
 require 'selenium/webdriver/common/interactions/pointer_input'
+require 'selenium/webdriver/common/interactions/scroll'
+require 'selenium/webdriver/common/interactions/wheel_input'
+require 'selenium/webdriver/common/interactions/scroll_origin'
+require 'selenium/webdriver/common/interactions/wheel_actions'
 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'
@@ -54,7 +67,6 @@ require 'selenium/webdriver/common/driver_extensions/has_web_storage'
 require 'selenium/webdriver/common/driver_extensions/downloads_files'
 require 'selenium/webdriver/common/driver_extensions/has_location'
 require 'selenium/webdriver/common/driver_extensions/has_session_id'
-require 'selenium/webdriver/common/driver_extensions/has_remote_status'
 require 'selenium/webdriver/common/driver_extensions/has_network_conditions'
 require 'selenium/webdriver/common/driver_extensions/has_network_connection'
 require 'selenium/webdriver/common/driver_extensions/has_network_interception'
@@ -66,6 +78,7 @@ 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_authentication'
 require 'selenium/webdriver/common/driver_extensions/has_logs'
@@ -81,3 +94,4 @@ require 'selenium/webdriver/common/takes_screenshot'
 require 'selenium/webdriver/common/driver'
 require 'selenium/webdriver/common/element'
 require 'selenium/webdriver/common/shadow_root'
+require 'selenium/webdriver/common/websocket_connection'

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

@@ -0,0 +1,176 @@
+# 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| # rubocop:disable Performance/RedundantBlockCall
+            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_method :continue_response, :continue_request
+
+        def mutate_request(request)
+          devtools.fetch.continue_request(
+            request_id: request.id,
+            url: request.url,
+            method: request.method,
+            post_data: 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/request.rb

@@ -35,7 +35,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

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

@@ -35,7 +35,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
           )

data/lib/selenium/webdriver/devtools.rb

@@ -20,52 +20,32 @@
 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
@@ -91,32 +71,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,66 +78,6 @@ 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

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

@@ -30,6 +30,7 @@ module Selenium
           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']

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

@@ -30,6 +30,7 @@ module Selenium
         EXTENSIONS = [DriverExtensions::HasAddons,
                       DriverExtensions::FullPageScreenshot,
                       DriverExtensions::HasContext,
+                      DriverExtensions::HasBiDi,
                       DriverExtensions::HasDevTools,
                       DriverExtensions::HasLogEvents,
                       DriverExtensions::HasNetworkInterception,

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

@@ -35,12 +35,9 @@ module Selenium
         end
 
         def install_addon(path, temporary)
-          if @file_detector
-            local_file = @file_detector.call(path)
-            path = upload(local_file) if local_file
-          end
+          addon = File.open(path, 'rb') { |crx_file| Base64.strict_encode64 crx_file.read }
 
-          payload = {path: path}
+          payload = {addon: addon}
           payload[:temporary] = temporary unless temporary.nil?
           execute :install_addon, {}, payload
         end

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

@@ -25,11 +25,12 @@ module Selenium
 
         KEY = 'moz:firefoxOptions'
 
-        # see: https://firefox-source-docs.mozilla.org/testing/geckodriver/Capabilities.html
+        # see: https://developer.mozilla.org/en-US/docs/Web/WebDriver/Capabilities/firefoxOptions
         CAPABILITIES = {binary: 'binary',
                         args: 'args',
                         log: 'log',
                         prefs: 'prefs',
+                        env: 'env',
                         android_package: 'androidPackage',
                         android_activity: 'androidActivity',
                         android_device_serial: 'androidDeviceSerial',
@@ -62,6 +63,7 @@ module Selenium
 
           @options[:args] ||= []
           @options[:prefs] ||= {}
+          @options[:env] ||= {}
           @options[:log] ||= {level: log_level} if log_level
 
           process_profile(@options.delete(:profile))

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

@@ -96,7 +96,7 @@ module Selenium
             raise TypeError, "expected one of #{VALID_PREFERENCE_TYPES.inspect}, got #{value.inspect}:#{value.class}"
           end
 
-          if value.is_a?(String) && stringified?(value)
+          if value.is_a?(String) && Util.stringified?(value)
             raise ArgumentError, "preference values must be plain strings: #{key.inspect} => #{value.inspect}"
           end
 
@@ -221,10 +221,6 @@ module Selenium
             end
           end
         end
-
-        def stringified?(str)
-          /^".*"$/.match?(str)
-        end
       end # Profile
     end # Firefox
   end # WebDriver