selenium-webdriver 4.0.0.rc1 → 4.0.0.rc2

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

@@ -28,39 +28,108 @@ module Selenium
         # a stubbed response instead.
         #
         # @example Log requests and pass through
-        #   driver.intercept do |request|
+        #   driver.intercept do |request, &continue|
         #     puts "#{request.method} #{request.url}"
-        #     request.continue
+        #     continue.call(request)
         #   end
         #
-        # @example Stub response for image requests
-        #   driver.intercept do |request|
+        # @example Stub requests for images
+        #   driver.intercept do |request, &continue|
         #     if request.url.match?(/\.png$/)
-        #       request.respond(body: File.read('myfile.png'))
-        #     else
-        #       request.continue
+        #       request.url = 'https://upload.wikimedia.org/wikipedia/commons/d/d5/Selenium_Logo.png'
         #     end
+        #     continue.call(request)
         #   end
         #
-        # @param [#call] block which is called when request is interecepted
-        # @yieldparam [DevTools::Request]
+        # @example Log responses and pass through
+        #   driver.intercept do |request, &continue|
+        #     continue.call(request) do |response|
+        #       puts "#{response.code} #{response.body}"
+        #     end
+        #   end
+        #
+        # @example Mutate specific response
+        #   driver.intercept do |request, &continue|
+        #     continue.call(request) do |response|
+        #       response.body << 'Added by Selenium!' if request.url.include?('/myurl')
+        #     end
+        #   end
+        #
+        # @param [Proc] block which is called when request is intercepted
+        # @yieldparam [DevTools::Request] request
+        # @yieldparam [Proc] continue block which proceeds with the request and optionally yields response
         #
 
-        def intercept
+        def intercept(&block)
           devtools.network.set_cache_disabled(cache_disabled: true)
           devtools.fetch.on(:request_paused) do |params|
-            request = DevTools::Request.new(
-              devtools: devtools,
-              id: params['requestId'],
-              url: params.dig('request', 'url'),
-              method: params.dig('request', 'method'),
-              headers: params.dig('request', 'headers')
+            id = params['requestId']
+            if params.key?('responseStatusCode') || params.key?('responseErrorReason')
+              intercept_response(id, params, &pending_response_requests.delete(id))
+            else
+              intercept_request(id, params, &block)
+            end
+          end
+          devtools.fetch.enable(patterns: [{requestStage: 'Request'}, {requestStage: 'Response'}])
+        end
+
+        private
+
+        def pending_response_requests
+          @pending_response_requests ||= {}
+        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
+              devtools.fetch.continue_request(request_id: id)
+            else
+              devtools.fetch.continue_request(
+                request_id: id,
+                url: mutable.url,
+                method: mutable.method,
+                post_data: mutable.post_data,
+                headers: mutable.headers.map do |k, v|
+                  {name: k, value: v}
+                end
+              )
+            end
+          end
+        end
+
+        def intercept_response(id, params)
+          return devtools.fetch.continue_request(request_id: 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
+            devtools.fetch.continue_request(request_id: id)
+          else
+            devtools.fetch.fulfill_request(
+              request_id: id,
+              body: (Base64.strict_encode64(mutable.body) if mutable.body),
+              response_code: mutable.code,
+              response_headers: mutable.headers.map do |k, v|
+                {name: k, value: v}
+              end
             )
-            yield request
           end
-          devtools.fetch.enable
         end
 
+        def fetch_response_body(id)
+          devtools.fetch.get_response_body(request_id: id).dig('result', 'body')
+        rescue Error::WebDriverError
+          # CDP fails to get body on certain responses (301) and raises:
+          # Can only get response body on requests captured after headers received.
+        end
       end # HasNetworkInterception
     end # DriverExtensions
   end # WebDriver

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

@@ -23,26 +23,26 @@ module Selenium
       module HasPermissions
 
         #
-        # Returns permissions.
+        # Set one permission.
         #
-        # @return [Hash]
+        # @param [String] name which permission to set
+        # @param [String] value what to set the permission to
         #
 
-        def permissions
-          @bridge.permissions
+        def add_permission(name, value)
+          @bridge.set_permission(name, value)
         end
 
         #
-        # Sets permissions.
+        # Set multiple permissions.
         #
-        # @example
-        #   driver.permissions = {'getUserMedia' => true}
-        #
-        # @param [Hash<Symbol, Boolean>] permissions
+        # @param [Hash] opt key/value pairs to set permissions
         #
 
-        def permissions=(permissions)
-          @bridge.permissions = permissions
+        def add_permissions(opt)
+          opt.each do |key, value|
+            @bridge.set_permission(key, value)
+          end
         end
 
       end # HasPermissions

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

@@ -34,7 +34,7 @@ module Selenium
 
         def save_print_page(path, **options)
           File.open(path, 'wb') do |file|
-            content = Base64.decode64 print_page(options)
+            content = Base64.decode64 print_page(**options)
             file << content
           end
         end

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

@@ -30,14 +30,14 @@ module Selenium
 
       def as_json(*)
         {
-          'level' => level,
           'timestamp' => timestamp,
+          'level' => level,
           'message' => message
         }
       end
 
       def to_s
-        "#{level} #{time}: #{message}"
+        "#{time} #{level}: #{message}"
       end
 
       def time

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

@@ -104,25 +104,19 @@ module Selenium
         @timeouts ||= Timeouts.new(@bridge)
       end
 
-      #
-      # @api beta This API may be changed or removed in a future release.
-      #
-
       def logs
         WebDriver.logger.deprecate('Manager#logs', 'Chrome::Driver#logs')
         @logs ||= Logs.new(@bridge)
       end
 
       #
-      # Create a new top-level browsing context
-      # https://w3c.github.io/webdriver/#new-window
       # @param type [Symbol] Supports two values: :tab and :window.
-      #  Use :tab if you'd like the new window to share an OS-level window
-      #  with the current browsing context.
-      #  Use :window otherwise
       # @return [String] The value of the window handle
       #
       def new_window(type = :tab)
+        WebDriver.logger.deprecate('Manager#new_window', 'TargetLocator#new_window', id: :new_window) do
+          'e.g., `driver.switch_to.new_window(:tab)`'
+        end
         case type
         when :tab, :window
           result = @bridge.new_window(type)
@@ -137,10 +131,6 @@ module Selenium
         end
       end
 
-      #
-      # @api beta This API may be changed or removed in a future release.
-      #
-
       def window
         @window ||= Window.new(@bridge)
       end

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

@@ -21,7 +21,8 @@ module Selenium
   module WebDriver
     class Options
       W3C_OPTIONS = %i[browser_name browser_version platform_name accept_insecure_certs page_load_strategy proxy
-                       set_window_rect timeouts unhandled_prompt_behavior strict_file_interactability].freeze
+                       set_window_rect timeouts unhandled_prompt_behavior strict_file_interactability
+                       web_socket_url].freeze
 
       class << self
         attr_reader :driver_path
@@ -90,7 +91,8 @@ module Selenium
       # @param [Boolean, String, Integer] value Value of the option
       #
 
-      def add_option(name, value)
+      def add_option(name, value = nil)
+        @options[name.keys.first] = name.values.first if value.nil? && name.is_a?(Hash)
         @options[name] = value
       end
 
@@ -123,10 +125,14 @@ module Selenium
 
       private
 
+      def w3c?(key)
+        W3C_OPTIONS.include?(key) || key.to_s.include?(':')
+      end
+
       def process_w3c_options(options)
-        w3c_options = options.select { |key, _val| W3C_OPTIONS.include?(key) }
+        w3c_options = options.select { |key, _val| w3c?(key) }
         w3c_options[:unhandled_prompt_behavior] &&= w3c_options[:unhandled_prompt_behavior]&.to_s&.tr('_', ' ')
-        options.delete_if { |key, _val| W3C_OPTIONS.include?(key) }
+        options.delete_if { |key, _val| w3c?(key) }
         w3c_options
       end
 
@@ -173,6 +179,8 @@ module Selenium
       def camel_case(str)
         str.gsub(/_([a-z])/) { Regexp.last_match(1).upcase }
       end
-    end # Options
+    end
+
+    # Options
   end # WebDriver
 end # Selenium

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

@@ -44,6 +44,34 @@ module Selenium
         @bridge.switch_to_parent_frame
       end
 
+      #
+      # Switch to a new top-level browsing context
+      #
+      # @param type either :tab or :window
+      #
+
+      def new_window(type = :window)
+        unless %i[window tab].include?(type)
+          raise ArgumentError, "Valid types are :tab and :window, received: #{type.inspect}"
+        end
+
+        handle = @bridge.new_window(type)['handle']
+
+        if block_given?
+          execute_and_close = proc do
+            yield(self)
+            begin
+              @bridge.close
+            rescue Error::NoSuchWindowError
+              # window already closed
+            end
+          end
+          window(handle, &execute_and_close)
+        else
+          window(handle)
+        end
+      end
+
       #
       # switch to the given window handle
       #

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

@@ -19,10 +19,6 @@
 
 module Selenium
   module WebDriver
-    #
-    # @api beta This API may be changed or removed in a future release.
-    #
-
     class Window
       #
       # @api private

data/lib/selenium/webdriver/common.rb

@@ -58,8 +58,10 @@ 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'
+require 'selenium/webdriver/common/driver_extensions/has_apple_permissions'
 require 'selenium/webdriver/common/driver_extensions/has_permissions'
 require 'selenium/webdriver/common/driver_extensions/has_debugger'
+require 'selenium/webdriver/common/driver_extensions/has_context'
 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'
@@ -70,6 +72,8 @@ require 'selenium/webdriver/common/driver_extensions/has_logs'
 require 'selenium/webdriver/common/driver_extensions/has_log_events'
 require 'selenium/webdriver/common/driver_extensions/has_pinned_scripts'
 require 'selenium/webdriver/common/driver_extensions/has_cdp'
+require 'selenium/webdriver/common/driver_extensions/has_casting'
+require 'selenium/webdriver/common/driver_extensions/has_launching'
 require 'selenium/webdriver/common/keys'
 require 'selenium/webdriver/common/profile_helper'
 require 'selenium/webdriver/common/options'

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

@@ -22,33 +22,43 @@ module Selenium
     class DevTools
       class Request
 
-        attr_reader :url, :method, :headers
+        attr_accessor :url, :method, :headers, :post_data
+        attr_reader :id
 
-        def initialize(devtools:, id:, url:, method:, headers:)
-          @devtools = devtools
+        #
+        # Creates request from DevTools message.
+        # @api private
+        #
+
+        def self.from(id, params)
+          new(
+            id: id,
+            url: params.dig('request', 'url'),
+            method: params.dig('request', 'method'),
+            headers: params.dig('request', 'headers'),
+            post_data: params.dig('request', 'postData')
+          )
+        end
+
+        def initialize(id:, url:, method:, headers:, post_data:)
           @id = id
           @url = url
           @method = method
           @headers = headers
+          @post_data = post_data
         end
 
-        def continue
-          @devtools.fetch.continue_request(request_id: @id)
-        end
-
-        def respond(code: 200, headers: {}, body: '')
-          @devtools.fetch.fulfill_request(
-            request_id: @id,
-            body: Base64.strict_encode64(body),
-            response_code: code,
-            response_headers: headers.map do |k, v|
-              {name: k, value: v}
-            end
-          )
+        def ==(other)
+          self.class == other.class &&
+            id == other.id &&
+            url == other.url &&
+            method == other.method &&
+            headers == other.headers &&
+            post_data == other.post_data
         end
 
         def inspect
-          %(#<#{self.class.name} @method="#{method}" @url="#{url}")
+          %(#<#{self.class.name} @id="#{id}" @method="#{method}" @url="#{url}")
         end
 
       end # Request

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

@@ -0,0 +1,66 @@
+# 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
+      class Response
+
+        attr_accessor :code, :body, :headers
+        attr_reader :id
+
+        #
+        # Creates response from DevTools message.
+        # @api private
+        #
+
+        def self.from(id, encoded_body, params)
+          new(
+            id: id,
+            code: params['responseStatusCode'],
+            body: (Base64.strict_decode64(encoded_body) if encoded_body),
+            headers: params['responseHeaders'].each_with_object({}) do |header, hash|
+              hash[header['name']] = header['value']
+            end
+          )
+        end
+
+        def initialize(id:, code:, body:, headers:)
+          @id = id
+          @code = code
+          @body = body
+          @headers = headers
+        end
+
+        def ==(other)
+          self.class == other.class &&
+            id == other.id &&
+            code == other.code &&
+            body == other.body &&
+            headers == other.headers
+        end
+
+        def inspect
+          %(#<#{self.class.name} @id="#{id}" @code="#{code}")
+        end
+
+      end # Response
+    end # DevTools
+  end # WebDriver
+end # Selenium

data/lib/selenium/webdriver/devtools.rb

@@ -20,22 +20,34 @@
 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 :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 = []
         @session_id = nil
         @url = url
 
         process_handshake
-        attach_socket_listener
+        @socket_thread = attach_socket_listener
         start_session
       end
 
+      def close
+        @callback_threads.list.each(&:exit)
+        @socket_thread.exit
+        socket.close
+      end
+
       def callbacks
         @callbacks ||= Hash.new { |callbacks, event| callbacks[event] = [] }
       end
@@ -85,27 +97,24 @@ module Selenium
       end
 
       def attach_socket_listener
-        socket_listener = Thread.new do
+        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)
-              # Firefox will periodically fail on unparsable empty frame
-              break if frame.to_s.empty?
-
-              message = JSON.parse(frame.to_s)
-              @messages << message
-              WebDriver.logger.debug "DevTools <- #{message}"
+              message = process_frame(frame)
               next unless message['method']
 
+              params = message['params']
               callbacks[message['method']].each do |callback|
-                params = message['params'] # take in current thread!
-                Thread.new { callback.call(params) }
+                @callback_threads.add(callback_thread(params, &callback))
               end
             end
           end
         end
-        socket_listener.abort_on_exception = true
       end
 
       def start_session
@@ -119,8 +128,36 @@ module Selenium
         @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: 10, interval: 0.1)
+        @wait ||= Wait.new(timeout: RESPONSE_WAIT_TIMEOUT, interval: RESPONSE_WAIT_INTERVAL)
       end
 
       def socket

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

@@ -27,6 +27,11 @@ module Selenium
         include WebDriver::Chrome::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'],
+          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
 

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

@@ -29,6 +29,7 @@ module Selenium
       class Driver < WebDriver::Driver
         EXTENSIONS = [DriverExtensions::HasAddons,
                       DriverExtensions::FullPageScreenshot,
+                      DriverExtensions::HasContext,
                       DriverExtensions::HasDevTools,
                       DriverExtensions::HasLogEvents,
                       DriverExtensions::HasNetworkInterception,
@@ -42,6 +43,10 @@ module Selenium
         private
 
         def devtools_url
+          if capabilities['moz:debuggerAddress'].nil?
+            raise(Error::WebDriverError, "DevTools is not supported by this version of Firefox; use v85 or higher")
+          end
+
           uri = URI("http://#{capabilities['moz:debuggerAddress']}")
           response = Net::HTTP.get(uri.hostname, '/json/version', uri.port)
 

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

@@ -23,6 +23,8 @@ module Selenium
       module Features
 
         FIREFOX_COMMANDS = {
+          get_context: [:get, 'session/:session_id/moz/context'],
+          set_context: [:post, 'session/:session_id/moz/context'],
           install_addon: [:post, 'session/:session_id/moz/addon/install'],
           uninstall_addon: [:post, 'session/:session_id/moz/addon/uninstall'],
           full_page_screenshot: [:get, 'session/:session_id/moz/screenshot/full']
@@ -33,6 +35,11 @@ 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
+
           payload = {path: path}
           payload[:temporary] = temporary unless temporary.nil?
           execute :install_addon, {}, payload
@@ -46,6 +53,13 @@ module Selenium
           execute :full_page_screenshot
         end
 
+        def context=(context)
+          execute :set_context, {}, {context: context}
+        end
+
+        def context
+          execute :get_context
+        end
       end # Bridge
     end # Firefox
   end # WebDriver