selenium-webdriver 4.1.0 → 4.2.0

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

@@ -99,7 +99,7 @@ module Selenium
       end
 
       def socket_writable?(sock)
-        IO.select(nil, [sock], nil, CONNECT_TIMEOUT)
+        sock.wait_writable(CONNECT_TIMEOUT)
       end
 
       def conn_completed?(sock)

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

@@ -0,0 +1,149 @@
+# 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
+
+      def initialize(url:)
+        @callback_threads = ThreadGroup.new
+
+        @messages = []
+        @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)
+        data = JSON.generate(data)
+        WebDriver.logger.debug "WebSocket -> #{data}"
+
+        out_frame = WebSocket::Frame::Outgoing::Client.new(version: ws.version, data: data, type: 'text')
+        socket.write(out_frame.to_s)
+
+        wait.until { @messages.find { |m| m['id'] == id } }
+      end
+
+      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 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 "WebSocket <- #{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 ||= 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.rb

@@ -38,14 +38,24 @@ 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/html5/shared_web_storage'
 require 'selenium/webdriver/common/html5/local_storage'
@@ -66,6 +76,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 +92,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/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,9 +20,6 @@
 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'
@@ -31,41 +28,23 @@ module Selenium
       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 +70,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 +77,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

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

@@ -0,0 +1,46 @@
+# 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
+    module Firefox
+      # @api private
+      module Util
+        module_function
+
+        def app_data_path
+          case Platform.os
+          when :windows
+            "#{ENV.fetch('APPDATA')}\\Mozilla\\Firefox"
+          when :macosx
+            "#{Platform.home}/Library/Application Support/Firefox"
+          when :unix, :linux
+            "#{Platform.home}/.mozilla/firefox"
+          else
+            raise "Unknown os: #{Platform.os}"
+          end
+        end
+
+        def stringified?(str)
+          str =~ /^".*"$/
+        end
+      end # Util
+    end # Firefox
+  end # WebDriver
+end # Selenium

data/lib/selenium/webdriver/firefox.rb

@@ -24,6 +24,7 @@ require 'rexml/document'
 module Selenium
   module WebDriver
     module Firefox
+      autoload :Util, 'selenium/webdriver/firefox/util'
       autoload :Extension, 'selenium/webdriver/firefox/extension'
       autoload :ProfilesIni, 'selenium/webdriver/firefox/profiles_ini'
       autoload :Profile, 'selenium/webdriver/firefox/profile'

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

@@ -30,8 +30,8 @@ module Selenium
 
         #
         # 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 [String, URI] url url for the remote server
+        # @param [Object] http_client an HTTP client instance that implements the same protocol as Http::Default
         # @api private
         #
 
@@ -118,7 +118,7 @@ module Selenium
         end
 
         def alert=(keys)
-          execute :send_alert_text, {}, {value: keys.split(//), text: keys}
+          execute :send_alert_text, {}, {value: keys.chars, text: keys}
         end
 
         def alert_text
@@ -146,9 +146,7 @@ module Selenium
         end
 
         def page_source
-          execute_script('var source = document.documentElement.outerHTML;' \
-                            'if (!source) { source = new XMLSerializer().serializeToString(document); }' \
-                            'return source;')
+          execute :get_page_source
         end
 
         #
@@ -369,11 +367,8 @@ module Selenium
         # actions
         #
 
-        def action(async = false)
-          ActionBuilder.new self,
-                            Interactions.pointer(:mouse, name: 'mouse'),
-                            Interactions.key('keyboard'),
-                            async
+        def action(deprecated_async = nil, async: false, devices: [], duration: 250)
+          ActionBuilder.new self, nil, nil, deprecated_async, async: async, devices: devices, duration: duration
         end
         alias_method :actions, :action
 
@@ -412,8 +407,8 @@ module Selenium
           end
 
           # Keep .split(//) for backward compatibility for now
-          text = keys.join('')
-          execute :element_send_keys, {id: element}, {value: text.split(//), text: text}
+          text = keys.join
+          execute :element_send_keys, {id: element}, {value: text.chars, text: text}
         end
 
         def upload(local_file)
@@ -430,10 +425,19 @@ module Selenium
         end
 
         def submit_element(element)
-          form = find_element_by('xpath', "./ancestor-or-self::form", [:element, element])
-          execute_script("var e = arguments[0].ownerDocument.createEvent('Event');" \
-                            "e.initEvent('submit', true, true);" \
-                            'if (arguments[0].dispatchEvent(e)) { arguments[0].submit() }', form.as_json)
+          script = "var form = arguments[0];\n" \
+                   "while (form.nodeName != \"FORM\" && form.parentNode) {\n" \
+                   "  form = form.parentNode;\n" \
+                   "}\n" \
+                   "if (!form) { throw Error('Unable to find containing form element'); }\n" \
+                   "if (!form.ownerDocument) { throw Error('Unable to find owning document'); }\n" \
+                   "var e = form.ownerDocument.createEvent('Event');\n" \
+                   "e.initEvent('submit', true, true);\n" \
+                   "if (form.dispatchEvent(e)) { HTMLFormElement.prototype.submit.call(form) }\n"
+
+          execute_script(script, Element::ELEMENT_KEY => element)
+        rescue Error::JavascriptError
+          raise Error::UnsupportedOperationError, "To submit an element, it must be nested inside a form element"
         end
 
         #
@@ -639,8 +643,6 @@ module Selenium
           when 'name'
             how = 'css selector'
             what = "*[name='#{escape_css(what.to_s)}']"
-          when 'tag name'
-            how = 'css selector'
           end
 
           if what.is_a?(Hash)

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

@@ -60,10 +60,6 @@ module Selenium
           fullscreen_window: [:post, 'session/:session_id/window/fullscreen'],
           minimize_window: [:post, 'session/:session_id/window/minimize'],
           maximize_window: [:post, 'session/:session_id/window/maximize'],
-          set_window_size: [:post, 'session/:session_id/window/size'],
-          get_window_size: [:get, 'session/:session_id/window/size'],
-          set_window_position: [:post, 'session/:session_id/window/position'],
-          get_window_position: [:get, 'session/:session_id/window/position'],
           set_window_rect: [:post, 'session/:session_id/window/rect'],
           get_window_rect: [:get, 'session/:session_id/window/rect'],
           switch_to_frame: [:post, 'session/:session_id/frame'],
@@ -130,7 +126,6 @@ module Selenium
           #
 
           element_click: [:post, 'session/:session_id/element/:id/click'],
-          element_tap: [:post, 'session/:session_id/element/:id/tap'],
           element_clear: [:post, 'session/:session_id/element/:id/clear'],
           element_send_keys: [:post, 'session/:session_id/element/:id/value'],
 

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

@@ -75,9 +75,10 @@ module Selenium
             begin
               request = new_request_for(verb, url, headers, payload)
               response = response_for(request)
-            rescue Errno::ECONNABORTED, Errno::ECONNRESET, Errno::EADDRINUSE
-              # a retry is sometimes needed on Windows XP where we may quickly
-              # run out of ephemeral ports
+            rescue Errno::ECONNABORTED, Errno::ECONNRESET, Errno::EADDRINUSE, Errno::EADDRNOTAVAIL
+              # a retry is sometimes needed:
+              #   on Windows XP where we may quickly run out of ephemeral ports
+              #   when the port becomes temporarily unavailable
               #
               # A more robust solution is bumping the MaxUserPort setting
               # as described here:
@@ -85,13 +86,6 @@ module Selenium
               # http://msdn.microsoft.com/en-us/library/aa560610%28v=bts.20%29.aspx
               raise if retries >= MAX_RETRIES
 
-              retries += 1
-              sleep 2
-              retry
-            rescue Errno::EADDRNOTAVAIL => e
-              # a retry is sometimes needed when the port becomes temporarily unavailable
-              raise if retries >= MAX_RETRIES
-
               retries += 1
               sleep 2
               retry
@@ -142,8 +136,8 @@ module Selenium
 
           def proxy
             @proxy ||= begin
-              proxy = ENV['http_proxy'] || ENV['HTTP_PROXY']
-              no_proxy = ENV['no_proxy'] || ENV['NO_PROXY']
+              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://')

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

@@ -74,7 +74,7 @@ module Selenium
         end
 
         def backtrace_from_remote(server_trace)
-          server_trace.map { |frame|
+          server_trace.filter_map do |frame|
             next unless frame.is_a?(Hash)
 
             file = frame['fileName']
@@ -87,7 +87,7 @@ module Selenium
             meth = 'unknown' if meth.nil? || meth.empty?
 
             "[remote server] #{file}:#{line}:in `#{meth}'"
-          }.compact
+          end
         end
 
         def process_error