options.rb in selenium-webdriver-4.0.0.beta1

- old
+ new

@@ -19,39 +19,31 @@
 
 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',
                         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
+        # NOTE: special handling of 'extensions' to validate when set instead of when used
+        attr_reader :extensions
 
-          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)
@@ -72,16 +64,28 @@
         # @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(profile: nil, encoded_extensions: nil, **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
 
         #
         # Add an extension by local path.
         #
@@ -92,29 +96,40 @@
         # @param [String] path The local path to the .crx file
         #
 
         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
+
+        #
         # Add an extension by Base64-encoded string.
         #
         # @example
         #   options = Selenium::WebDriver::Chrome::Options.new
         #   options.add_encoded_extension(encoded_string)
         #
         # @param [String] encoded The Base64-encoded string of the .crx file
         #
 
         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.
         #
         # @example Start Chrome maximized
@@ -123,11 +138,10 @@
         #
         # @param [String] arg The command-line argument to add
         #
 
         def add_argument(arg)
-          @options[:args] ||= []
           @options[:args] << arg
         end
 
         #
         # Add a preference that is only applied to the user profile in use.
@@ -139,11 +153,10 @@
         # @param [String] name Key of the preference
         # @param [Boolean, String, Integer] value Value of the preference
         #
 
         def add_preference(name, value)
-          @options[:prefs] ||= {}
           @options[:prefs][name] = value
         end
 
         #
         # Run Chrome in headless mode.
@@ -180,23 +193,27 @@
           @options[:emulation] = opts
         end
 
         private
 
+        def enable_logging(browser_options)
+          browser_options['goog:loggingPrefs'] = @logging_prefs
+        end
+
         def process_browser_options(browser_options)
-          options = browser_options[KEY]
+          enable_logging(browser_options) unless @logging_prefs.empty?
+
+          options = browser_options[self.class::KEY]
           options['binary'] ||= binary_path if binary_path
-          (options['args'] || []) << "--user-data-dir=#{@profile.directory}" if @profile
-          merge_extensions(options)
-        end
+          if @profile
+            options['args'] ||= []
+            options['args'] << "--user-data-dir=#{@profile.directory}"
+          end
 
-        def merge_extensions(browser_options)
-          extensions = browser_options['extensions'] || []
-          encoded_extensions = browser_options.delete(:encoded_extensions) || []
+          return if (@encoded_extensions + @extensions).empty?
 
-          browser_options['extensions'] = extensions.map(&method(:encode_extension)) + encoded_extensions
-          browser_options.delete('extensions') if browser_options['extensions'].empty?
+          options['extensions'] = @encoded_extensions + @extensions.map(&method(:encode_extension))
         end
 
         def binary_path
           Chrome.path
         end
@@ -206,20 +223,15 @@
         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'
+
+          @extensions << path
         end
 
-        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
+        def camelize?(key)
+          !['prefs'].include?(key)
         end
       end # Options
     end # Chrome
   end # WebDriver
 end # Selenium