selenium-webdriver 4.0.0.beta1 → 4.0.0.beta2

data/lib/selenium/webdriver/chrome.rb

@@ -22,7 +22,7 @@ require 'net/http'
 module Selenium
   module WebDriver
     module Chrome
-      autoload :Bridge, 'selenium/webdriver/chrome/bridge'
+      autoload :Features, 'selenium/webdriver/chrome/features'
       autoload :Driver, 'selenium/webdriver/chrome/driver'
       autoload :Profile, 'selenium/webdriver/chrome/profile'
       autoload :Options, 'selenium/webdriver/chrome/options'

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

@@ -27,37 +27,31 @@ module Selenium
       #
 
       class Driver < WebDriver::Driver
-        include DriverExtensions::HasNetworkConditions
-        include DriverExtensions::HasWebStorage
-        include DriverExtensions::HasLocation
-        include DriverExtensions::DownloadsFiles
-        include DriverExtensions::HasDevTools
-        include DriverExtensions::HasAuthentication
-        include DriverExtensions::HasLogs
-        include DriverExtensions::HasLogEvents
-        include DriverExtensions::PrintsPage
+        EXTENSIONS = [DriverExtensions::HasNetworkConditions,
+                      DriverExtensions::HasNetworkInterception,
+                      DriverExtensions::HasWebStorage,
+                      DriverExtensions::HasLocation,
+                      DriverExtensions::DownloadsFiles,
+                      DriverExtensions::HasDevTools,
+                      DriverExtensions::HasAuthentication,
+                      DriverExtensions::HasLogs,
+                      DriverExtensions::HasLogEvents,
+                      DriverExtensions::PrintsPage].freeze
 
         def browser
           :chrome
         end
 
-        def bridge_class
-          Bridge
-        end
-
         def execute_cdp(cmd, **params)
           @bridge.send_command(cmd: cmd, params: params)
         end
 
         private
 
-        def devtools_version
-          Integer(capabilities.browser_version.split('.').first)
+        def devtools_address
+          "http://#{capabilities['goog:chromeOptions']['debuggerAddress']}"
         end
 
-        def debugger_address
-          capabilities['goog:chromeOptions']['debuggerAddress']
-        end
       end # Driver
     end # Chrome
   end # WebDriver

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

@@ -39,7 +39,9 @@ module Selenium
           driver_args << "--log-path=#{driver_opts.delete(:log_path)}" if driver_opts.key?(:log_path)
           driver_args << "--url-base=#{driver_opts.delete(:url_base)}" if driver_opts.key?(:url_base)
           driver_args << "--port-server=#{driver_opts.delete(:port_server)}" if driver_opts.key?(:port_server)
-          driver_args << "--whitelisted-ips=#{driver_opts.delete(:whitelisted_ips)}" if driver_opts.key?(:whitelisted_ips)
+          if driver_opts.key?(:whitelisted_ips)
+            driver_args << "--whitelisted-ips=#{driver_opts.delete(:whitelisted_ips)}"
+          end
           driver_args << "--verbose" if driver_opts.key?(:verbose)
           driver_args << "--silent" if driver_opts.key?(:silent)
           driver_args

data/lib/selenium/webdriver/common.rb

@@ -57,6 +57,7 @@ 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'
 require 'selenium/webdriver/common/driver_extensions/has_permissions'
 require 'selenium/webdriver/common/driver_extensions/has_debugger'
 require 'selenium/webdriver/common/driver_extensions/prints_page'

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

@@ -71,11 +71,13 @@ module Selenium
       def initialize(bridge: nil, listener: nil, **opts)
         @service = nil
         bridge ||= create_bridge(**opts)
+        add_extensions(bridge.browser)
         @bridge = listener ? Support::EventFiringBridge.new(bridge, listener) : bridge
       end
 
       def inspect
-        format '#<%<class>s:0x%<hash>x browser=%<browser>s>', class: self.class, hash: hash * 2, browser: bridge.browser.inspect
+        format '#<%<class>s:0x%<hash>x browser=%<browser>s>', class: self.class, hash: hash * 2,
+                                                              browser: bridge.browser.inspect
       end
 
       #
@@ -329,7 +331,7 @@ module Selenium
         bridge_opts = {http_client: opts.delete(:http_client), url: opts.delete(:url)}
         raise ArgumentError, "Unable to create a driver with parameters: #{opts}" unless opts.empty?
 
-        bridge = (respond_to?(:bridge_class) ? bridge_class : Remote::Bridge).new(**bridge_opts)
+        bridge = Remote::Bridge.new(**bridge_opts)
 
         bridge.create_session(capabilities)
         bridge
@@ -340,8 +342,9 @@ module Selenium
           if cap.is_a? Symbol
             cap = Remote::Capabilities.send(cap)
           elsif cap.is_a? Hash
+            new_message = 'Capabilities instance initialized with the Hash, or build values with Options class'
             WebDriver.logger.deprecate("passing a Hash value to :capabilities",
-                                       'Capabilities instance initialized with the Hash, or build values with Options class',
+                                       new_message,
                                        id: :capabilities_hash)
             cap = Remote::Capabilities.new(cap)
           elsif !cap.respond_to? :as_json
@@ -371,6 +374,20 @@ module Selenium
       def screenshot
         bridge.screenshot
       end
+
+      def add_extensions(browser)
+        extensions = case browser
+                     when :chrome, :msedge
+                       Chrome::Driver::EXTENSIONS
+                     when :firefox
+                       Firefox::Driver::EXTENSIONS
+                     when :safari, :safari_technology_preview
+                       Safari::Driver::EXTENSIONS
+                     else
+                       []
+                     end
+        extensions.each { |extension| extend extension }
+      end
     end # Driver
   end # WebDriver
 end # Selenium

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

@@ -29,7 +29,29 @@ module Selenium
         #
 
         def devtools
-          @devtools ||= DevTools.new(url: debugger_address, version: devtools_version)
+          @devtools ||= begin
+            require 'selenium/devtools'
+            Selenium::DevTools.version ||= devtools_version
+            Selenium::DevTools.load_version
+            Selenium::WebDriver::DevTools.new(url: devtools_url)
+          end
+        end
+
+        private
+
+        def devtools_version
+          return Firefox::DEVTOOLS_VERSION if browser == :firefox
+
+          Integer(capabilities.browser_version.split('.').first)
+        end
+
+        def devtools_url
+          return devtools_address if devtools_address.include?('/session/')
+
+          uri = URI(devtools_address)
+          response = Net::HTTP.get(uri.hostname, '/json/version', uri.port)
+
+          JSON.parse(response)['webSocketDebuggerUrl']
         end
 
       end # HasDevTools

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

@@ -23,11 +23,13 @@ module Selenium
     module DriverExtensions
       module HasNetworkConnection
         def network_connection_type
-          raise Error::UnsupportedOperationError, 'The W3C standard does not currently support getting network connection'
+          raise Error::UnsupportedOperationError,
+                'The W3C standard does not currently support getting network connection'
         end
 
         def network_connection_type=(*)
-          raise Error::UnsupportedOperationError, 'The W3C standard does not currently support setting network connection'
+          raise Error::UnsupportedOperationError,
+                'The W3C standard does not currently support setting network connection'
         end
       end # HasNetworkConnection
     end # DriverExtensions

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

@@ -0,0 +1,67 @@
+# 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 HasNetworkInterception
+
+        #
+        # Intercepts requests coming from browser allowing
+        # to either pass them through like proxy or provide
+        # a stubbed response instead.
+        #
+        # @example Log requests and pass through
+        #   driver.intercept do |request|
+        #     puts "#{request.method} #{request.url}"
+        #     request.continue
+        #   end
+        #
+        # @example Stub response for image requests
+        #   driver.intercept do |request|
+        #     if request.url.match?(/\.png$/)
+        #       request.respond(body: File.read('myfile.png'))
+        #     else
+        #       request.continue
+        #     end
+        #   end
+        #
+        # @param [#call] block which is called when request is interecepted
+        # @yieldparam [DevTools::Request]
+        #
+
+        def intercept
+          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')
+            )
+            yield request
+          end
+          devtools.fetch.enable
+        end
+
+      end # HasNetworkInterception
+    end # DriverExtensions
+  end # WebDriver
+end # Selenium

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

@@ -92,13 +92,18 @@ module Selenium
       end
 
       #
-      # Get the value of a the given attribute of the element. Will return the current value, even if
-      # this has been modified after the page has been loaded. More exactly, this method will return
-      # the value of the given attribute, unless that attribute is not present, in which case the
-      # value of the property with the same name is returned. If neither value is set, nil is
-      # returned. The "style" attribute is converted as best can be to a text representation with a
-      # trailing semi-colon. The following are deemed to be "boolean" attributes, and will
-      # return either "true" or "false":
+      # This method attempts to provide the most likely desired current value for the attribute
+      # of the element, even when that desired value is actually a JavaScript property.
+      # It is implemented with a custom JavaScript atom. To obtain the exact value of the attribute or property,
+      # use #dom_attribute or #property methods respectively.
+      #
+      # More exactly, this method will return the value of the property with the given name,
+      # if it exists. If it does not, then the value of the attribute with the given name is returned.
+      # If neither exists, null is returned.
+      #
+      # The "style" attribute is converted as best can be to a text representation with a trailing semi-colon.
+      #
+      # The following are deemed to be "boolean" attributes, and will return either "true" or "false":
       #
       # async, autofocus, autoplay, checked, compact, complete, controls, declare, defaultchecked,
       # defaultselected, defer, disabled, draggable, ended, formnovalidate, hidden, indeterminate,
@@ -106,22 +111,46 @@ module Selenium
       # nowrap, open, paused, pubdate, readonly, required, reversed, scoped, seamless, seeking,
       # selected, spellcheck, truespeed, willvalidate
       #
-      # Finally, the following commonly mis-capitalized attribute/property names are evaluated as
-      # expected:
+      # Finally, the following commonly mis-capitalized attribute/property names are evaluated as expected:
       #
-      # class, readonly
+      # When the value of "class" is requested, the "className" property is returned.
+      # When the value of "readonly" is requested, the "readOnly" property is returned.
       #
       # @param [String] name attribute name
       # @return [String, nil] attribute value
       #
+      # @see #dom_attribute
+      # @see #property
+      #
 
       def attribute(name)
         bridge.element_attribute self, name
       end
 
       #
-      # Get the value of a the given property with the same name of the element. If the value is not
-      # set, nil is returned.
+      # Gets the value of a declared HTML attribute of this element.
+      #
+      # As opposed to the #attribute method, this method
+      # only returns attributes declared in the element's HTML markup.
+      #
+      # If the attribute is not set, nil is returned.
+      #
+      # @param [String] name attribute name
+      # @return [String, nil] attribute value
+      #
+      # @see #attribute
+      # @see #property
+      #
+
+      def dom_attribute(name)
+        bridge.element_dom_attribute self, name
+      end
+
+      #
+      # Gets the value of a JavaScript property of this element
+      # This will return the current value,
+      # even if this has been modified after the page has been loaded.
+      # If the value is not set, nil is returned.
       #
       # @param [String] name property name
       # @return [String, nil] property value

data/lib/selenium/webdriver/common/interactions/interaction.rb

@@ -26,7 +26,10 @@ module Selenium
         attr_reader :source
 
         def initialize(source)
-          raise TypeError, "#{source.type} is not a valid input type" unless Interactions::SOURCE_TYPES.include? source.type
+          unless Interactions::SOURCE_TYPES.include? source.type
+            raise TypeError,
+                  "#{source.type} is not a valid input type"
+          end
 
           @source = source
         end

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

@@ -108,10 +108,11 @@ module Selenium
       #
       # @param [String] old
       # @param [String, nil] new
-      # @param [Symbol, Array<Sybmol>] id
+      # @param [Symbol, Array<Symbol>] id
+      # @param [String] reference
       # @yield appends additional message to end of provided template
       #
-      def deprecate(old, new = nil, id: [], &block)
+      def deprecate(old, new = nil, id: [], reference: '', &block)
         id = Array(id)
         return if @ignored.include?(:deprecations) || (@ignored & id).any?
 
@@ -123,6 +124,8 @@ module Selenium
                    else
                      ' and will be removed in a future release.'
                    end
+        message << " See explanation for this deprecation: #{reference}." unless reference.empty?
+
         warn message, &block
       end
 

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

@@ -23,16 +23,42 @@ module Selenium
       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
 
-      def self.set_capabilities
-        (W3C_OPTIONS + self::CAPABILITIES.keys).each do |key|
-          next if method_defined? key
+      class << self
+        attr_reader :driver_path
 
-          define_method key do
-            @options[key]
-          end
+        def chrome(**opts)
+          Chrome::Options.new(**opts)
+        end
+
+        def firefox(**opts)
+          Firefox::Options.new(**opts)
+        end
+
+        def ie(**opts)
+          IE::Options.new(**opts)
+        end
+        alias_method :internet_explorer, :ie
+
+        def edge(**opts)
+          Edge::Options.new(**opts)
+        end
+        alias_method :microsoftedge, :edge
 
-          define_method "#{key}=" do |value|
-            @options[key] = value
+        def safari(**opts)
+          Safari::Options.new(**opts)
+        end
+
+        def set_capabilities
+          (W3C_OPTIONS + self::CAPABILITIES.keys).each do |key|
+            next if method_defined? key
+
+            define_method key do
+              @options[key]
+            end
+
+            define_method "#{key}=" do |value|
+              @options[key] = value
+            end
           end
         end
       end
@@ -68,6 +94,14 @@ module Selenium
         @options[name] = value
       end
 
+      def ==(other)
+        return false unless other.is_a? self.class
+
+        as_json == other.as_json
+      end
+
+      alias_method :eql?, :==
+
       #
       # @api private
       #

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

@@ -127,7 +127,10 @@ module Selenium
       end
 
       def type=(type)
-        raise ArgumentError, "invalid proxy type: #{type.inspect}, expected one of #{TYPES.keys.inspect}" unless TYPES.key? type
+        unless TYPES.key? type
+          raise ArgumentError,
+                "invalid proxy type: #{type.inspect}, expected one of #{TYPES.keys.inspect}"
+        end
 
         if defined?(@type) && type != @type
           raise ArgumentError, "incompatible proxy type #{type.inspect} (already set to #{@type.inspect})"