selenium-webdriver 4.0.0.alpha2 → 4.0.0.alpha7

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

@@ -20,19 +20,44 @@
 module Selenium
   module WebDriver
     module Chrome
-      class Options
-        attr_reader :args, :prefs, :options, :emulation, :extensions, :encoded_extensions
-        attr_accessor :binary
+      class Options < WebDriver::Options
+        attr_accessor :profile
 
         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',
+                        debugger_address: 'debuggerAddress',
+                        exclude_switches: 'excludeSwitches',
+                        minidump_path: 'minidumpPath',
+                        emulation: 'mobileEmulation',
+                        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
 
-        #
         # Create a new Options instance.
         #
         # @example
         #   options = Selenium::WebDriver::Chrome::Options.new(args: ['start-maximized', 'user-data-dir=/tmp/temp_profile'])
         #   driver = Selenium::WebDriver.for(:chrome, options: options)
         #
+        # @param [Profile] :profile An instance of a Chrome::Profile Class
+        # @param [Array] :encoded_extensions List of extensions that do not need to be Base64 encoded
         # @param [Hash] opts the pre-defined options to create the Chrome::Options with
         # @option opts [Array<String>] :args List of command-line arguments to use when starting Chrome
         # @option opts [String] :binary Path to the Chrome executable to use
@@ -40,16 +65,21 @@ module Selenium
         # @option opts [Array<String>] :extensions A list of paths to (.crx) Chrome extensions to install on startup
         # @option opts [Hash] :options A hash for raw options
         # @option opts [Hash] :emulation A hash for raw emulation options
+        # @option opts [Hash] :local_state A hash for the Local State file in the user data folder
+        # @option opts [Boolean] :detach whether browser is closed when the driver is sent the quit command
+        # @option opts [String] :debugger_address address of a Chrome debugger server to connect to
+        # @option opts [Array<String>] :exclude_switches command line switches to exclude
+        # @option opts [String] :minidump_path Directory to store Chrome minidumps (linux only)
+        # @option opts [Hash] :perf_logging_prefs A hash for performance logging preferences
+        # @option opts [Array<String>] :window_types A list of window types to appear in the list of window handles
         #
 
-        def initialize(**opts)
-          @args = Set.new(opts.delete(:args) || [])
-          @binary = opts.delete(:binary) || Chrome.path
-          @prefs = opts.delete(:prefs) || {}
-          @extensions = opts.delete(:extensions) || []
-          @options = opts.delete(:options) || {}
-          @emulation = opts.delete(:emulation) || {}
-          @encoded_extensions = []
+        def initialize(profile: nil, encoded_extensions: nil, **opts)
+          super(**opts)
+
+          @profile = profile
+          @options[:encoded_extensions] = encoded_extensions if encoded_extensions
+          @options[:extensions]&.each(&method(:validate_extension))
         end
 
         #
@@ -63,10 +93,9 @@ module Selenium
         #
 
         def add_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
+          validate_extension(path)
+          @options[:extensions] ||= []
+          @options[:extensions] << path
         end
 
         #
@@ -80,8 +109,10 @@ module Selenium
         #
 
         def add_encoded_extension(encoded)
-          @encoded_extensions << encoded
+          @options[:encoded_extensions] ||= []
+          @options[:encoded_extensions] << encoded
         end
+        alias_method :encoded_extension=, :add_encoded_extension
 
         #
         # Add a command-line argument to use when starting Chrome.
@@ -94,22 +125,8 @@ module Selenium
         #
 
         def add_argument(arg)
-          @args << arg
-        end
-
-        #
-        # Add a new option not yet handled by bindings.
-        #
-        # @example Leave Chrome open when chromedriver is killed
-        #   options = Selenium::WebDriver::Chrome::Options.new
-        #   options.add_option(:detach, true)
-        #
-        # @param [String, Symbol] name Name of the option
-        # @param [Boolean, String, Integer] value Value of the option
-        #
-
-        def add_option(name, value)
-          @options[name] = value
+          @options[:args] ||= []
+          @options[:args] << arg
         end
 
         #
@@ -124,7 +141,8 @@ module Selenium
         #
 
         def add_preference(name, value)
-          prefs[name] = value
+          @options[:prefs] ||= {}
+          @options[:prefs][name] = value
         end
 
         #
@@ -140,7 +158,9 @@ module Selenium
         end
 
         #
-        # Add an emulation device name
+        # Add emulation device information
+        #
+        # see: http://chromedriver.chromium.org/mobile-emulation
         #
         # @example Start Chrome in mobile emulation mode by device name
         #   options = Selenium::WebDriver::Chrome::Options.new
@@ -150,35 +170,55 @@ module Selenium
         #   options = Selenium::WebDriver::Chrome::Options.new
         #   options.add_emulation(device_metrics: {width: 400, height: 800, pixelRatio: 1, touch: true})
         #
-        # @param [String] device_name Name of the device or a hash containing width, height, pixelRatio, touch
-        # @param [Hash] device_metrics Hash containing width, height, pixelRatio, touch
-        # @param [String] user_agent Full user agent
+        # @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
         #
 
-        def add_emulation(device_name: nil, device_metrics: nil, user_agent: nil)
-          @emulation[:deviceName] = device_name if device_name
-          @emulation[:deviceMetrics] = device_metrics if device_metrics
-          @emulation[:userAgent] = user_agent if user_agent
+        def add_emulation(**opts)
+          @options[:emulation] = opts
         end
 
-        #
-        # @api private
-        #
+        private
 
-        def as_json(*)
-          extensions = @extensions.map do |crx_path|
-            File.open(crx_path, 'rb') { |crx_file| Base64.strict_encode64 crx_file.read }
-          end
-          extensions.concat(@encoded_extensions)
+        def process_browser_options(browser_options)
+          options = browser_options[KEY]
+          options['binary'] ||= binary_path if binary_path
+          (options['args'] || []) << "--user-data-dir=#{@profile.directory}" if @profile
+          merge_extensions(options)
+        end
+
+        def merge_extensions(browser_options)
+          extensions = browser_options['extensions'] || []
+          encoded_extensions = browser_options.delete(:encoded_extensions) || []
+
+          browser_options['extensions'] = extensions.map(&method(:encode_extension)) + encoded_extensions
+          browser_options.delete('extensions') if browser_options['extensions'].empty?
+        end
 
-          opts = @options
-          opts[:binary] = @binary if @binary
-          opts[:args] = @args.to_a if @args.any?
-          opts[:extensions] = extensions if extensions.any?
-          opts[:mobileEmulation] = @emulation unless @emulation.empty?
-          opts[:prefs] = @prefs unless @prefs.empty?
+        def binary_path
+          Chrome.path
+        end
+
+        def encode_extension(path)
+          File.open(path, 'rb') { |crx_file| Base64.strict_encode64 crx_file.read }
+        end
+
+        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'
+        end
 
-          {KEY => opts}
+        def generate_as_json(value, camelize_keys: true)
+          if value.is_a?(Hash)
+            value.each_with_object({}) do |(key, val), hash|
+              key = convert_json_key(key, camelize: camelize_keys)
+              hash[key] = generate_as_json(val, camelize_keys: key != 'prefs')
+            end
+          else
+            super
+          end
         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)
@@ -77,8 +77,8 @@ module Selenium
 
           extensions.concat(@encoded_extensions)
 
-          opts = {directory: directory || layout_on_disk}
-          opts[:extensions] = extensions if extensions.any?
+          opts = {'directory' => directory || layout_on_disk}
+          opts['extensions'] = extensions if extensions.any?
           opts
         end
 

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'

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,7 +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'
@@ -62,7 +62,12 @@ require 'selenium/webdriver/common/driver_extensions/has_permissions'
 require 'selenium/webdriver/common/driver_extensions/has_debugger'
 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_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,17 +44,21 @@ 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)
+            Edge::Driver.new(**opts)
+          when :edge_chrome
+            EdgeChrome::Driver.new(**opts)
+          when :edge_html
+            EdgeHtml::Driver.new(**opts)
           when :remote
-            Remote::Driver.new(opts)
+            Remote::Driver.new(**opts)
           else
             raise ArgumentError, "unknown driver: #{browser.inspect}"
           end
@@ -67,9 +72,10 @@ module Selenium
       # @api private
       #
 
-      def initialize(bridge, listener: nil)
-        @bridge = bridge
-        @bridge = Support::EventFiringBridge.new(bridge, listener) if listener
+      def initialize(bridge: nil, listener: nil, **opts)
+        @service = nil
+        bridge ||= create_bridge(**opts)
+        @bridge = listener ? Support::EventFiringBridge.new(bridge, listener) : bridge
       end
 
       def inspect
@@ -164,6 +170,8 @@ module Selenium
 
       def quit
         bridge.quit
+      ensure
+        @service&.stop
       end
 
       #
@@ -269,7 +277,7 @@ module Selenium
       end
 
       def browser
-        bridge.browser
+        bridge&.browser
       end
 
       def capabilities
@@ -287,20 +295,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