selenium-webdriver 4.0.0.alpha5 → 4.0.0.beta3

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

@@ -27,12 +27,11 @@ module Selenium
       class Profile
         include ProfileHelper
 
-        attr_reader :directory
-
         def initialize(model = nil)
           @model = verify_model(model)
           @extensions = []
           @encoded_extensions = []
+          @directory = nil
         end
 
         def add_extension(path)
@@ -45,10 +44,14 @@ module Selenium
           @encoded_extensions << encoded
         end
 
+        def directory
+          @directory || layout_on_disk
+        end
+
         #
         # Set a preference in the profile.
         #
-        # See https://src.chromium.org/svn/trunk/src/chrome/common/pref_names.cc
+        # See https://src.chromium.org/viewvc/chrome/trunk/src/chrome/common/pref_names.cc
         #
 
         def []=(key, value)

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

@@ -32,14 +32,16 @@ module Selenium
 
         private
 
-        # Note: This processing is deprecated
+        # NOTE: This processing is deprecated
         def extract_service_args(driver_opts)
           driver_args = super
           driver_opts = driver_opts.dup
           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

@@ -23,6 +23,7 @@ require 'selenium/webdriver/common/proxy'
 require 'selenium/webdriver/common/log_entry'
 require 'selenium/webdriver/common/file_reaper'
 require 'selenium/webdriver/common/service'
+require 'selenium/webdriver/common/service_manager'
 require 'selenium/webdriver/common/socket_lock'
 require 'selenium/webdriver/common/socket_poller'
 require 'selenium/webdriver/common/port_prober'
@@ -49,8 +50,6 @@ require 'selenium/webdriver/common/action_builder'
 require 'selenium/webdriver/common/html5/shared_web_storage'
 require 'selenium/webdriver/common/html5/local_storage'
 require 'selenium/webdriver/common/html5/session_storage'
-require 'selenium/webdriver/common/driver_extensions/takes_screenshot'
-require 'selenium/webdriver/common/driver_extensions/rotatable'
 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'
@@ -58,13 +57,19 @@ 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'
 require 'selenium/webdriver/common/driver_extensions/uploads_files'
 require 'selenium/webdriver/common/driver_extensions/has_addons'
 require 'selenium/webdriver/common/driver_extensions/has_devtools'
+require 'selenium/webdriver/common/driver_extensions/has_authentication'
+require 'selenium/webdriver/common/driver_extensions/has_logs'
+require 'selenium/webdriver/common/driver_extensions/has_log_events'
 require 'selenium/webdriver/common/keys'
 require 'selenium/webdriver/common/profile_helper'
 require 'selenium/webdriver/common/options'
+require 'selenium/webdriver/common/takes_screenshot'
 require 'selenium/webdriver/common/driver'
 require 'selenium/webdriver/common/element'

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

@@ -30,6 +30,7 @@ module Selenium
 
     class Driver
       include SearchContext
+      include TakesScreenshot
 
       class << self
         #
@@ -43,21 +44,17 @@ module Selenium
         def for(browser, opts = {})
           case browser
           when :chrome
-            Chrome::Driver.new(opts)
+            Chrome::Driver.new(**opts)
           when :internet_explorer, :ie
-            IE::Driver.new(opts)
+            IE::Driver.new(**opts)
           when :safari
-            Safari::Driver.new(opts)
+            Safari::Driver.new(**opts)
           when :firefox, :ff
-            Firefox::Driver.new(opts)
+            Firefox::Driver.new(**opts)
           when :edge
-            Edge::Driver.new(opts)
-          when :edge_chrome
-            EdgeChrome::Driver.new(opts)
-          when :edge_html
-            EdgeHtml::Driver.new(opts)
+            Edge::Driver.new(**opts)
           when :remote
-            Remote::Driver.new(opts)
+            Remote::Driver.new(**opts)
           else
             raise ArgumentError, "unknown driver: #{browser.inspect}"
           end
@@ -73,12 +70,24 @@ module Selenium
 
       def initialize(bridge: nil, listener: nil, **opts)
         @service = nil
-        bridge ||= create_bridge(opts)
+        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
+
+      #
+      # information about whether a remote end is in a state in which it can create new sessions,
+      # and may include additional meta information.
+      #
+      # @return [Hash]
+      #
+      def status
+        @bridge.status
       end
 
       #
@@ -296,38 +305,89 @@ module Selenium
 
       def create_bridge(**opts)
         opts[:url] ||= service_url(opts)
+        caps = opts.delete(:capabilities)
+        # NOTE: This is deprecated
+        cap_array = caps.is_a?(Hash) ? [caps] : Array(caps)
+
+        desired_capabilities = opts.delete(:desired_capabilities)
+        if desired_capabilities
+          WebDriver.logger.deprecate(':desired_capabilities as a parameter for driver initialization',
+                                     ':capabilities with an Array value of capabilities/options if necessary',
+                                     id: :desired_capabilities)
+          desired_capabilities = Remote::Capabilities.new(desired_capabilities) if desired_capabilities.is_a?(Hash)
+          cap_array << desired_capabilities
+        end
 
-        desired_capabilities = opts.delete(:desired_capabilities) || Remote::Capabilities.send(browser || :new)
         options = opts.delete(:options)
+        if options
+          WebDriver.logger.deprecate(':options as a parameter for driver initialization',
+                                     ':capabilities with an Array of value capabilities/options if necessary',
+                                     id: :browser_options)
+          cap_array << options
+        end
 
-        bridge = Remote::Bridge.new(http_client: opts.delete(:http_client), url: opts.delete(:url))
+        capabilities = generate_capabilities(cap_array)
+
+        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?
 
-        namespacing = self.class.to_s.split('::')
+        bridge = Remote::Bridge.new(**bridge_opts)
 
-        if Object.const_defined?("#{namespacing[0..-2].join('::')}::Bridge") && !namespacing.include?('Remote')
-          bridge.extend Object.const_get("#{namespacing[0, namespacing.length - 1].join('::')}::Bridge")
-        end
-
-        bridge.create_session(desired_capabilities, options)
+        bridge.create_session(capabilities)
         bridge
       end
 
+      def generate_capabilities(cap_array)
+        cap_array.map { |cap|
+          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",
+                                       new_message,
+                                       id: :capabilities_hash)
+            cap = Remote::Capabilities.new(cap)
+          elsif !cap.respond_to? :as_json
+            msg = ":capabilities parameter only accepts objects responding to #as_json which #{cap.class} does not"
+            raise ArgumentError, msg
+          end
+          cap&.as_json
+        }.inject(:merge) || Remote::Capabilities.send(browser || :new)
+      end
+
       def service_url(opts)
-        @service = opts.delete(:service)
+        service_config = opts.delete(:service)
         %i[driver_opts driver_path port].each do |key|
           next unless opts.key? key
 
           WebDriver.logger.deprecate(":#{key}", ':service with an instance of Selenium::WebDriver::Service',
                                      id: "service_#{key}".to_sym)
         end
-        @service ||= Service.send(browser,
-                                  args: opts.delete(:driver_opts),
-                                  path: opts.delete(:driver_path),
-                                  port: opts.delete(:port))
-        @service.start
+        service_config ||= Service.send(browser,
+                                        args: opts.delete(:driver_opts),
+                                        path: opts.delete(:driver_path),
+                                        port: opts.delete(:port))
+        @service = service_config.launch
         @service.uri
       end
+
+      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_authentication.rb

@@ -0,0 +1,89 @@
+# 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 HasAuthentication
+
+        #
+        # Registers basic authentication handler which is automatically
+        # used whenever browser gets an authentication required response.
+        # This currently relies on DevTools so is only supported in
+        # Chromium browsers.
+        #
+        # @example Authenticate any request
+        #   driver.register(username: 'admin', password: '123456')
+        #
+        # @example Authenticate based on URL
+        #   driver.register(username: 'admin1', password: '123456', uri: /mysite1\.com/)
+        #   driver.register(username: 'admin2', password: '123456', uri: /mysite2\.com/)
+        #
+        # @param [String] username
+        # @param [String] password
+        # @param [Regexp] uri to associate the credentials with
+        #
+
+        def register(username:, password:, uri: //)
+          auth_handlers << {username: username, password: password, uri: uri}
+
+          devtools.network.set_cache_disabled(cache_disabled: true)
+          devtools.fetch.on(:auth_required) do |params|
+            authenticate(params['requestId'], params.dig('request', 'url'))
+          end
+          devtools.fetch.on(:request_paused) do |params|
+            devtools.fetch.continue_request(request_id: params['requestId'])
+          end
+          devtools.fetch.enable(handle_auth_requests: true)
+        end
+
+        private
+
+        def auth_handlers
+          @auth_handlers ||= []
+        end
+
+        def authenticate(request_id, url)
+          credentials = auth_handlers.find do |handler|
+            url.match?(handler[:uri])
+          end
+
+          if credentials
+            devtools.fetch.continue_with_auth(
+              request_id: request_id,
+              auth_challenge_response: {
+                response: 'ProvideCredentials',
+                username: credentials[:username],
+                password: credentials[:password]
+              }
+            )
+          else
+            devtools.fetch.continue_with_auth(
+              request_id: request_id,
+              auth_challenge_response: {
+                response: 'CancelAuth'
+              }
+            )
+          end
+        end
+
+      end # HasAuthentication
+    end # DriverExtensions
+  end # WebDriver
+end # Selenium

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

@@ -29,7 +29,12 @@ module Selenium
         #
 
         def devtools
-          @devtools ||= DevTools.new(capabilities['goog:chromeOptions']['debuggerAddress'])
+          @devtools ||= begin
+            require 'selenium/devtools'
+            Selenium::DevTools.version ||= devtools_version
+            Selenium::DevTools.load_version
+            Selenium::WebDriver::DevTools.new(url: devtools_url)
+          end
         end
 
       end # HasDevTools

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

@@ -17,23 +17,20 @@
 # specific language governing permissions and limitations
 # under the License.
 
+# TODO: Deprecated; Delete after 4.0 release
 module Selenium
   module WebDriver
     module DriverExtensions
       module HasLocation
         def location
-          @bridge.location
+          raise Error::UnsupportedOperationError, 'The W3C standard does not currently support getting location'
         end
 
-        def location=(loc)
-          raise TypeError, "expected #{Location}, got #{loc.inspect}:#{loc.class}" unless loc.is_a?(Location)
-
-          @bridge.set_location loc.latitude, loc.longitude, loc.altitude
+        def location=(*)
+          raise Error::UnsupportedOperationError, 'The W3C standard does not currently support setting location'
         end
+        alias_method :set_location, :location
 
-        def set_location(lat, lon, alt)
-          self.location = Location.new(Float(lat), Float(lon), Float(alt))
-        end
       end # HasLocation
     end # DriverExtensions
   end # WebDriver

data/lib/selenium/webdriver/common/driver_extensions/has_log_events.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.
+
+module Selenium
+  module WebDriver
+    module DriverExtensions
+      module HasLogEvents
+        include Atoms
+
+        KINDS = %i[console exception mutation].freeze
+
+        #
+        # Registers listener to be called whenever browser receives
+        # a new Console API message such as console.log() or an unhandled
+        # exception.
+        #
+        # This currently relies on DevTools so is only supported in
+        # Chromium browsers.
+        #
+        # @example Collect console messages
+        #   logs = []
+        #   driver.on_log_event(:console) do |event|
+        #     logs.push(event)
+        #   end
+        #
+        # @example Collect JavaScript exceptions
+        #   exceptions = []
+        #   driver.on_log_event(:exception) do |event|
+        #     exceptions.push(event)
+        #   end
+        #
+        # @example Collect DOM mutations
+        #   mutations = []
+        #   driver.on_log_event(:mutation) do |event|
+        #     mutations.push(event)
+        #   end
+        #
+        # @param [Symbol] kind :console, :exception or :mutation
+        # @param [#call] block which is called when event happens
+        # @yieldparam [DevTools::ConsoleEvent, DevTools::ExceptionEvent, DevTools::MutationEvent]
+        #
+
+        def on_log_event(kind, &block)
+          raise Error::WebDriverError, "Don't know how to handle #{kind} events" unless KINDS.include?(kind)
+
+          enabled = log_listeners[kind].any?
+          log_listeners[kind] << block
+          return if enabled
+
+          devtools.runtime.enable
+          __send__("log_#{kind}_events")
+        end
+
+        private
+
+        def log_listeners
+          @log_listeners ||= Hash.new { |listeners, kind| listeners[kind] = [] }
+        end
+
+        def log_console_events
+          devtools.runtime.on(:console_api_called) do |params|
+            event = DevTools::ConsoleEvent.new(
+              type: params['type'],
+              timestamp: params['timestamp'],
+              args: params['args']
+            )
+
+            log_listeners[:console].each do |listener|
+              listener.call(event)
+            end
+          end
+        end
+
+        def log_exception_events
+          devtools.runtime.on(:exception_thrown) do |params|
+            description = if params.dig('exceptionDetails', 'exception')
+                            params.dig('exceptionDetails', 'exception', 'description')
+                          else
+                            params.dig('exceptionDetails', 'text')
+                          end
+
+            event = DevTools::ExceptionEvent.new(
+              description: description,
+              timestamp: params['timestamp'],
+              stacktrace: params.dig('exceptionDetails', 'stackTrace', 'callFrames')
+            )
+
+            log_listeners[:exception].each do |listener|
+              listener.call(event)
+            end
+          end
+        end
+
+        def log_mutation_events
+          devtools.page.enable
+
+          devtools.runtime.add_binding(name: '__webdriver_attribute')
+          execute_script(mutation_listener)
+          script = devtools.page.add_script_to_evaluate_on_new_document(source: mutation_listener)
+          pinned_scripts[mutation_listener] = script['identifier']
+
+          devtools.runtime.on(:binding_called, &method(:log_mutation_event))
+        end
+
+        def log_mutation_event(params)
+          payload = JSON.parse(params['payload'])
+          elements = find_elements(css: "*[data-__webdriver_id='#{payload['target']}']")
+          return if elements.empty?
+
+          event = DevTools::MutationEvent.new(
+            element: elements.first,
+            attribute_name: payload['name'],
+            current_value: payload['value'],
+            old_value: payload['oldValue']
+          )
+
+          log_listeners[:mutation].each do |log_listener|
+            log_listener.call(event)
+          end
+        end
+
+        def mutation_listener
+          @mutation_listener ||= read_atom(:mutationListener)
+        end
+
+        def pinned_scripts
+          @pinned_scripts ||= {}
+        end
+
+      end # HasLogEvents
+    end # DriverExtensions
+  end # WebDriver
+end # Selenium