selenium-webdriver 4.0.0.alpha3 → 4.0.0.beta1

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

@@ -21,14 +21,14 @@ module Selenium
   module WebDriver
     module Chrome
       class Options < WebDriver::Options
-        attr_accessor :profile
+        attr_accessor :profile, :logging_prefs
 
         KEY = 'goog:chromeOptions'
+        BROWSER = 'chrome'
 
         # see: http://chromedriver.chromium.org/capabilities
         CAPABILITIES = {args: 'args',
                         binary: 'binary',
-                        extensions: 'extensions',
                         local_state: 'localState',
                         prefs: 'prefs',
                         detach: 'detach',
@@ -39,15 +39,8 @@ module Selenium
                         perf_logging_prefs: 'perfLoggingPrefs',
                         window_types: 'windowTypes'}.freeze
 
-        CAPABILITIES.each_key do |key|
-          define_method key do
-            @options[key]
-          end
-
-          define_method "#{key}=" do |value|
-            @options[key] = value
-          end
-        end
+        # NOTE: special handling of 'extensions' to validate when set instead of when used
+        attr_reader :extensions
 
         # Create a new Options instance.
         #
@@ -73,12 +66,24 @@ module Selenium
         # @option opts [Array<String>] :window_types A list of window types to appear in the list of window handles
         #
 
-        def initialize(profile: nil, encoded_extensions: nil, **opts)
-          super(opts)
+        def initialize(profile: nil, **opts)
+          super(**opts)
 
           @profile = profile
-          @options[:encoded_extensions] = encoded_extensions if encoded_extensions
-          @options[:extensions]&.each(&method(:validate_extension))
+
+          @options = {args: [],
+                      prefs: {},
+                      emulation: {},
+                      extensions: [],
+                      local_state: {},
+                      exclude_switches: [],
+                      perf_logging_prefs: {},
+                      window_types: []}.merge(@options)
+
+          @logging_prefs = options.delete(:logging_prefs) || {}
+          @encoded_extensions = @options.delete(:encoded_extensions) || []
+          @extensions = []
+          (@options.delete(:extensions)).each(&method(:validate_extension))
         end
 
         #
@@ -93,8 +98,21 @@ module Selenium
 
         def add_extension(path)
           validate_extension(path)
-          @options[:extensions] ||= []
-          @options[:extensions] << path
+        end
+
+        #
+        # Add an extension by local path.
+        #
+        # @example
+        #   extensions = ['/path/to/extension.crx', '/path/to/other.crx']
+        #   options = Selenium::WebDriver::Chrome::Options.new
+        #   options.extensions = extensions
+        #
+        # @param [Array<String>] :extensions A list of paths to (.crx) Chrome extensions to install on startup
+        #
+
+        def extensions=(extensions)
+          extensions.each(&method(:validate_extension))
         end
 
         #
@@ -108,10 +126,8 @@ module Selenium
         #
 
         def add_encoded_extension(encoded)
-          @options[:encoded_extensions] ||= []
-          @options[:encoded_extensions] << encoded
+          @encoded_extensions << encoded
         end
-        alias_method :encoded_extension=, :add_encoded_extension
 
         #
         # Add a command-line argument to use when starting Chrome.
@@ -124,7 +140,6 @@ module Selenium
         #
 
         def add_argument(arg)
-          @options[:args] ||= []
           @options[:args] << arg
         end
 
@@ -140,7 +155,6 @@ module Selenium
         #
 
         def add_preference(name, value)
-          @options[:prefs] ||= {}
           @options[:prefs][name] = value
         end
 
@@ -169,7 +183,7 @@ module Selenium
         #   options = Selenium::WebDriver::Chrome::Options.new
         #   options.add_emulation(device_metrics: {width: 400, height: 800, pixelRatio: 1, touch: true})
         #
-        # @param [Hash] opts the pre-defined options for adding mobilie emulation values
+        # @param [Hash] opts the pre-defined options for adding mobile emulation values
         # @option opts [String] :device_name A valid device name from the Chrome DevTools Emulation panel
         # @option opts [Hash] :device_metrics Hash containing width, height, pixelRatio, touch
         # @option opts [String] :user_agent Full user agent
@@ -179,30 +193,27 @@ module Selenium
           @options[:emulation] = opts
         end
 
-        #
-        # @api private
-        #
+        private
 
-        def as_json(*)
-          options = super
+        def enable_logging(browser_options)
+          browser_options['goog:loggingPrefs'] = @logging_prefs
+        end
+
+        def process_browser_options(browser_options)
+          enable_logging(browser_options) unless @logging_prefs.empty?
 
+          options = browser_options[self.class::KEY]
+          options['binary'] ||= binary_path if binary_path
           if @profile
             options['args'] ||= []
-            options['args'] << "--user-data-dir=#{@profile[:directory]}"
+            options['args'] << "--user-data-dir=#{@profile.directory}"
           end
 
-          options['binary'] ||= binary_path if binary_path
-          extensions = options['extensions'] || []
-          encoded_extensions = options.delete(:encoded_extensions) || []
-
-          options['extensions'] = extensions.map(&method(:encode_extension)) + encoded_extensions
-          options.delete('extensions') if options['extensions'].empty?
+          return if (@encoded_extensions + @extensions).empty?
 
-          {KEY => generate_as_json(options)}
+          options['extensions'] = @encoded_extensions + @extensions.map(&method(:encode_extension))
         end
 
-        private
-
         def binary_path
           Chrome.path
         end
@@ -214,6 +225,12 @@ module Selenium
         def validate_extension(path)
           raise Error::WebDriverError, "could not find extension at #{path.inspect}" unless File.file?(path)
           raise Error::WebDriverError, "file was not an extension #{path.inspect}" unless File.extname(path) == '.crx'
+
+          @extensions << path
+        end
+
+        def camelize?(key)
+          !['prefs'].include?(key)
         end
       end # Options
     end # Chrome

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

@@ -48,7 +48,7 @@ module Selenium
         #
         # 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

@@ -20,10 +20,6 @@
 module Selenium
   module WebDriver
     module Chrome
-      #
-      # @api private
-      #
-
       class Service < WebDriver::Service
         DEFAULT_PORT = 9515
         EXECUTABLE = 'chromedriver'
@@ -36,7 +32,7 @@ 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

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'
@@ -60,10 +59,16 @@ 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_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
@@ -71,16 +68,26 @@ module Selenium
       # @api private
       #
 
-      def initialize(bridge, listener: nil)
+      def initialize(bridge: nil, listener: nil, **opts)
         @service = nil
-        @bridge = bridge
-        @bridge = Support::EventFiringBridge.new(bridge, listener) if listener
+        bridge ||= create_bridge(**opts)
+        @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
       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
+
       #
       # @return [Navigation]
       # @see Navigation
@@ -276,7 +283,7 @@ module Selenium
       end
 
       def browser
-        bridge.browser
+        bridge&.browser
       end
 
       def capabilities
@@ -294,20 +301,76 @@ module Selenium
 
       attr_reader :bridge
 
+      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
+
+        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
+
+        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?
+
+        bridge = (respond_to?(:bridge_class) ? bridge_class : Remote::Bridge).new(**bridge_opts)
+
+        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
+            WebDriver.logger.deprecate("passing a Hash value to :capabilities",
+                                       'Capabilities instance initialized with the Hash, or build values with Options class',
+                                       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')
+          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
     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