selenium-webdriver 4.0.0.rc1 → 4.0.1

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

@@ -0,0 +1,77 @@
+# 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 DriverExtensions
+      module HasCasting
+
+        #
+        # What devices ("sinks") are available to be cast to.
+        #
+        # @return [Array] list of sinks available for casting with id and name values
+        #
+
+        def cast_sinks
+          @bridge.cast_sinks
+        end
+
+        #
+        # Sets a specific sink, using its name, as a Cast session receiver target.
+        #
+        # @param [String] name the sink to use as the target
+        #
+
+        def cast_sink_to_use=(name)
+          @bridge.cast_sink_to_use = name
+        end
+
+        #
+        # Starts a tab mirroring session on a specific receiver target.
+        #
+        # @param [String] name the sink to use as the target
+        #
+
+        def start_cast_tab_mirroring(name)
+          @bridge.start_cast_tab_mirroring(name)
+        end
+
+        #
+        # Gets error messages when there is any issue in a Cast session.
+        #
+        # @return [String] the error message
+        #
+
+        def cast_issue_message
+          @bridge.cast_issue_message
+        end
+
+        #
+        # Stops the existing Cast session on a specific receiver target.
+        #
+        # @param [String] name the sink to stop the Cast session
+        #
+
+        def stop_casting(name)
+          @bridge.stop_casting(name)
+        end
+      end # HasCasting
+    end # DriverExtensions
+  end # WebDriver
+end # Selenium

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

@@ -0,0 +1,45 @@
+# 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 DriverExtensions
+      module HasContext
+
+        #
+        # Sets the context that Selenium commands are running in using
+        #         a `with` statement. The state of the context on the server is
+        #         saved before entering the block, and restored upon exiting it.
+        #
+        # @param [String] name which permission to set
+        # @param [String] value what to set the permission to
+        #
+
+        def context=(value)
+          @bridge.context = value
+        end
+
+        def context
+          @bridge.context
+        end
+
+      end # HasContext
+    end # DriverExtensions
+  end # WebDriver
+end # Selenium

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

@@ -0,0 +1,38 @@
+# 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 DriverExtensions
+      module HasLaunching
+
+        #
+        # Launches Chromium app specified by id.
+        #
+        # @param [String] id
+        #
+
+        def launch_app(id)
+          @bridge.launch_app(id)
+        end
+
+      end # HasLaunching
+    end # DriverExtensions
+  end # WebDriver
+end # Selenium

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

@@ -38,13 +38,30 @@ module Selenium
         # @param [Hash] conditions
         # @option conditions [Integer] :latency
         # @option conditions [Integer] :throughput
+        # @option conditions [Integer] :upload_throughput
+        # @option conditions [Integer] :download_throughput
         # @option conditions [Boolean] :offline
         #
 
         def network_conditions=(conditions)
+          conditions[:latency] ||= 0
+          unless conditions.key?(:throughput)
+            conditions[:download_throughput] ||= -1
+            conditions[:upload_throughput] ||= -1
+          end
+          conditions[:offline] = false unless conditions.key?(:offline)
+
           @bridge.network_conditions = conditions
         end
 
+        #
+        # Resets Chromium network emulation settings.
+        #
+
+        def delete_network_conditions
+          @bridge.delete_network_conditions
+        end
+
       end # HasNetworkConditions
     end # DriverExtensions
   end # WebDriver

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/profile_helper.rb

@@ -73,16 +73,10 @@ module Selenium
         def from_json(json)
           data = decoded(json)
 
-          # can't use Tempfile here since it doesn't support File::BINARY mode on 1.8
-          # can't use Dir.mktmpdir(&blk) because of http://jira.codehaus.org/browse/JRUBY-4082
-          tmp_dir = Dir.mktmpdir
-          begin
-            zip_path = File.join(tmp_dir, "webdriver-profile-duplicate-#{json.hash}.zip")
+          Tempfile.create do |zip_path|
             File.open(zip_path, 'wb') { |zip_file| zip_file << Base64.decode64(data) }
 
             new Zipper.unzip(zip_path)
-          ensure
-            FileUtils.rm_rf tmp_dir
           end
         end
       end # ClassMethods

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

@@ -65,26 +65,37 @@ module Selenium
         arr << Errno::EALREADY if Platform.wsl?
       }.freeze
 
-      def listening?
-        addr     = Socket.getaddrinfo(@host, @port, Socket::AF_INET, Socket::SOCK_STREAM)
-        sock     = Socket.new(Socket::AF_INET, Socket::SOCK_STREAM, 0)
-        sockaddr = Socket.pack_sockaddr_in(@port, addr[0][3])
-
-        begin
-          sock.connect_nonblock sockaddr
-        rescue Errno::EINPROGRESS
-          retry if socket_writable?(sock) && conn_completed?(sock)
-          raise Errno::ECONNREFUSED
-        rescue *CONNECTED_ERRORS
-          # yay!
+      if Platform.jruby?
+        # we use a plain TCPSocket here since JRuby has issues closing socket
+        # see https://github.com/jruby/jruby/issues/5709
+        def listening?
+          TCPSocket.new(@host, @port).close
+          true
+        rescue *NOT_CONNECTED_ERRORS
+          false
+        end
+      else
+        def listening?
+          addr     = Socket.getaddrinfo(@host, @port, Socket::AF_INET, Socket::SOCK_STREAM)
+          sock     = Socket.new(Socket::AF_INET, Socket::SOCK_STREAM, 0)
+          sockaddr = Socket.pack_sockaddr_in(@port, addr[0][3])
+
+          begin
+            sock.connect_nonblock sockaddr
+          rescue Errno::EINPROGRESS
+            retry if socket_writable?(sock) && conn_completed?(sock)
+            raise Errno::ECONNREFUSED
+          rescue *CONNECTED_ERRORS
+            # yay!
+          end
+
+          sock.close
+          true
+        rescue *NOT_CONNECTED_ERRORS
+          sock&.close
+          WebDriver.logger.debug("polling for socket on #{[@host, @port].inspect}")
+          false
         end
-
-        sock.close
-        true
-      rescue *NOT_CONNECTED_ERRORS
-        sock&.close
-        WebDriver.logger.debug("polling for socket on #{[@host, @port].inspect}")
-        false
       end
 
       def socket_writable?(sock)

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/timeouts.rb

@@ -24,22 +24,49 @@ module Selenium
         @bridge = bridge
       end
 
+      #
+      # Gets the amount of time the driver should wait when searching for elements.
+      #
+
+      def implicit_wait
+        Float(@bridge.timeouts['implicit']) / 1000
+      end
+
       #
       # Set the amount of time the driver should wait when searching for elements.
       #
 
       def implicit_wait=(seconds)
-        @bridge.implicit_wait_timeout = Integer(seconds * 1000)
+        @bridge.timeouts = {'implicit' => Integer(seconds * 1000)}
       end
 
+      #
+      # Gets the amount of time to wait for an asynchronous script to finish
+      # execution before throwing an error.
+      #
+
+      def script
+        Float(@bridge.timeouts['script']) / 1000
+      end
+      alias_method :script_timeout, :script
+
       #
       # Sets the amount of time to wait for an asynchronous script to finish
       # execution before throwing an error. If the timeout is negative, then the
       # script will be allowed to run indefinitely.
       #
 
-      def script_timeout=(seconds)
-        @bridge.script_timeout = Integer(seconds * 1000)
+      def script=(seconds)
+        @bridge.timeouts = {'script' => Integer(seconds * 1000)}
+      end
+      alias_method :script_timeout=, :script=
+
+      #
+      # Gets the amount of time to wait for a page load to complete before throwing an error.
+      #
+
+      def page_load
+        Float(@bridge.timeouts['pageLoad']) / 1000
       end
 
       #
@@ -48,7 +75,7 @@ module Selenium
       #
 
       def page_load=(seconds)
-        @bridge.timeout 'page load', Integer(seconds * 1000)
+        @bridge.timeouts = {'pageLoad' => Integer(seconds * 1000)}
       end
     end # Timeouts
   end # WebDriver

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/zipper.rb

@@ -72,16 +72,8 @@ module Selenium
         private
 
         def with_tmp_zip(&blk)
-          # can't use Tempfile here since it doesn't support File::BINARY mode on 1.8
-          # can't use Dir.mktmpdir(&blk) because of http://jira.codehaus.org/browse/JRUBY-4082
-          tmp_dir = Dir.mktmpdir
-          zip_path = File.join(tmp_dir, 'webdriver-zip')
-
-          begin
+          Tempfile.create do |zip_path|
             Zip::File.open(zip_path, Zip::File::CREATE, &blk)
-          ensure
-            FileUtils.rm_rf tmp_dir
-            FileUtils.rm_rf zip_path
           end
         end