selenium-webdriver 2.45.0 → 3.142.7

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

@@ -1,119 +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 Chrome
-
-      # @api private
-      class Bridge < Remote::Bridge
-
-        def initialize(opts = {})
-          http_client = opts.delete(:http_client)
-
-          if opts.has_key?(:url)
-            url = opts.delete(:url)
-          else
-            @service = Service.default_service(*extract_service_args(opts))
-            @service.start
-
-            url = @service.uri
-          end
-
-          caps = create_capabilities(opts)
-
-          remote_opts = {
-            :url                  => url,
-            :desired_capabilities => caps
-          }
-
-          remote_opts.merge!(:http_client => http_client) if http_client
-
-          super(remote_opts)
+      module Bridge
+
+        COMMANDS = {
+          get_network_conditions: [:get, 'session/:session_id/chromium/network_conditions'],
+          set_network_conditions: [:post, 'session/:session_id/chromium/network_conditions'],
+          send_command: [:post, 'session/:session_id/goog/cdp/execute'],
+          get_available_log_types: [:get, 'session/:session_id/se/log/types'],
+          get_log: [:post, 'session/:session_id/se/log']
+        }.freeze
+
+        def commands(command)
+          COMMANDS[command] || super
         end
 
-        def browser
-          :chrome
+        def network_conditions
+          execute :get_network_conditions
         end
 
-        def driver_extensions
-          [
-            DriverExtensions::TakesScreenshot,
-            DriverExtensions::HasInputDevices
-          ]
+        def send_command(command_params)
+          execute :send_command, {}, command_params
         end
 
-        def capabilities
-          @capabilities ||= Remote::Capabilities.chrome
+        def network_conditions=(conditions)
+          execute :set_network_conditions, {}, {network_conditions: conditions}
         end
 
-        def quit
-          super
-        ensure
-          @service.stop if @service
+        def available_log_types
+          types = execute :get_available_log_types
+          Array(types).map(&:to_sym)
         end
 
-        private
+        def log(type)
+          data = execute :get_log, {}, {type: type.to_s}
 
-        def create_capabilities(opts)
-          caps                        = opts.delete(:desired_capabilities) { Remote::Capabilities.chrome }
-          args                        = opts.delete(:args) || opts.delete(:switches)
-          native_events               = opts.delete(:native_events)
-          verbose                     = opts.delete(:verbose)
-          profile                     = opts.delete(:profile)
-          detach                      = opts.delete(:detach)
-          proxy                       = opts.delete(:proxy)
-          no_website_testing_defaults = opts.delete(:no_website_testing_defaults)
-          prefs                       = opts.delete(:prefs)
-
-          unless opts.empty?
-            raise ArgumentError, "unknown option#{'s' if opts.size != 1}: #{opts.inspect}"
-          end
-
-          chrome_options = caps['chromeOptions'] || {}
-
-          if args
-            unless args.kind_of? Array
-              raise ArgumentError, ":args must be an Array of Strings"
+          Array(data).map do |l|
+            begin
+              LogEntry.new l.fetch('level', 'UNKNOWN'), l.fetch('timestamp'), l.fetch('message')
+            rescue KeyError
+              next
             end
-
-            chrome_options['args'] = args.map { |e| e.to_s }
           end
-
-          if profile
-            data = profile.as_json
-
-            chrome_options.merge! 'profile'    => data['zip'],
-                                  'extensions' => data['extensions']
-          end
-
-
-          chrome_options['binary']                   = Chrome.path if Chrome.path
-          chrome_options['nativeEvents']             = true if native_events
-          chrome_options['verbose']                  = true if verbose
-          chrome_options['detach']                   = detach.nil? || !!detach
-          chrome_options['noWebsiteTestingDefaults'] = true if no_website_testing_defaults
-          chrome_options['prefs']                    = prefs if prefs
-
-          caps['chromeOptions'] = chrome_options
-          caps['proxy'] = proxy if proxy
-
-          # legacy options - for chromedriver < 17.0.963.0
-          caps["chrome.switches"] = chrome_options['args'] if chrome_options.member?('args')
-          %w[binary detach extensions nativeEvents noWebsiteTestingDefaults prefs profile verbose].each do |key|
-            caps["chrome.#{key}"] = chrome_options[key] if chrome_options.member?(key)
-          end
-
-          caps
         end
-
-        def extract_service_args(opts)
-          args = []
-
-          if opts.has_key?(:service_log_path)
-            args << "--log-path=#{opts.delete(:service_log_path)}"
-          end
-
-          args
-        end
-
       end # Bridge
     end # Chrome
   end # WebDriver

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

@@ -0,0 +1,127 @@
+# 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 Chrome
+
+      #
+      # Driver implementation for Chrome.
+      # @api private
+      #
+
+      class Driver < WebDriver::Driver
+        include DriverExtensions::HasNetworkConditions
+        include DriverExtensions::HasTouchScreen
+        include DriverExtensions::HasWebStorage
+        include DriverExtensions::HasLocation
+        include DriverExtensions::TakesScreenshot
+        include DriverExtensions::DownloadsFiles
+
+        def initialize(opts = {})
+          opts[:desired_capabilities] = create_capabilities(opts)
+
+          opts[:url] ||= service_url(opts)
+
+          listener = opts.delete(:listener)
+          @bridge = Remote::Bridge.handshake(**opts)
+          @bridge.extend Bridge
+
+          super(@bridge, listener: listener)
+        end
+
+        def browser
+          :chrome
+        end
+
+        def quit
+          super
+        ensure
+          @service&.stop
+        end
+
+        def execute_cdp(cmd, **params)
+          @bridge.send_command(cmd: cmd, params: params)
+        end
+
+        private
+
+        def create_capabilities(opts)
+          caps = opts.delete(:desired_capabilities) { Remote::Capabilities.chrome }
+          options = opts.delete(:options) { Options.new }
+
+          args = opts.delete(:args) || opts.delete(:switches)
+          if args
+            WebDriver.logger.deprecate ':args or :switches', 'Selenium::WebDriver::Chrome::Options#add_argument'
+            raise ArgumentError, ':args must be an Array of Strings' unless args.is_a? Array
+
+            args.each { |arg| options.add_argument(arg.to_s) }
+          end
+
+          profile = opts.delete(:profile)
+          if profile
+            WebDriver.logger.deprecate 'Selenium::WebDriver::Chrome::Driver#new with `:profile` parameter',
+                                       'Selenium::WebDriver::Chrome::Options#profile or Options#add_option'
+
+            profile = profile.as_json
+
+            if options.args.none?(&/user-data-dir/.method(:match?))
+              options.add_argument("--user-data-dir=#{profile['directory']}")
+            end
+
+            if profile['extensions']
+              WebDriver.logger.deprecate 'Selenium::WebDriver::Chrome::Profile#extensions',
+                                         'Selenium::WebDriver::Chrome::Options#add_extension'
+              profile['extensions'].each do |extension|
+                options.add_encoded_extension(extension)
+              end
+            end
+          end
+
+          if opts.key?(:detach)
+            WebDriver.logger.deprecate 'Selenium::WebDriver::Chrome::Driver#new with `:detach` parameter',
+                                       'Selenium::WebDriver::Chrome::Options#new or Options#add_option'
+            options.add_option(:detach, opts.delete(:detach))
+          end
+
+          prefs = opts.delete(:prefs)
+          if prefs
+            WebDriver.logger.deprecate ':prefs', 'Selenium::WebDriver::Chrome::Options#add_preference'
+            prefs.each do |key, value|
+              options.add_preference(key, value)
+            end
+          end
+
+          options = options.as_json
+          caps.merge!(options) unless options[Options::KEY].empty?
+
+          if opts.key?(:proxy) || opts.key?('proxy')
+            WebDriver.logger.deprecate 'Selenium::WebDriver::Chrome::Driver#new with `:proxy` parameter',
+                                       'Selenium::WebDriver::Chrome::Capabilities#proxy='
+
+            caps[:proxy] = opts.delete(:proxy) if opts.key?(:proxy)
+            caps[:proxy] ||= opts.delete('proxy') if opts.key?('proxy')
+          end
+
+          caps
+        end
+      end # Driver
+    end # Chrome
+  end # WebDriver
+end # Selenium

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

@@ -0,0 +1,190 @@
+# 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 Chrome
+      class Options < WebDriver::Common::Options
+        attr_reader :args, :prefs, :options, :emulation, :extensions, :encoded_extensions
+        attr_accessor :binary, :profile, :detach
+
+        KEY = 'goog:chromeOptions'
+
+        #
+        # 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 [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
+        # @option opts [Hash] :prefs A hash with each entry consisting of the name of the preference and its value
+        # @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
+        #
+
+        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) || {}
+          @detach = opts.delete(:detach)
+          @profile = opts.delete(:profile)
+          @encoded_extensions = []
+        end
+
+        #
+        # Add an extension by local path.
+        #
+        # @example
+        #   options = Selenium::WebDriver::Chrome::Options.new
+        #   options.add_extension('/path/to/extension.crx')
+        #
+        # @param [String] path The local path to the .crx file
+        #
+
+        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
+        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)
+          @encoded_extensions << encoded
+        end
+
+        #
+        # Add a command-line argument to use when starting Chrome.
+        #
+        # @example Start Chrome maximized
+        #   options = Selenium::WebDriver::Chrome::Options.new
+        #   options.add_argument('start-maximized')
+        #
+        # @param [String] arg The command-line argument to add
+        #
+
+        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
+        end
+
+        #
+        # Add a preference that is only applied to the user profile in use.
+        #
+        # @example Set the default homepage
+        #   options = Selenium::WebDriver::Chrome::Options.new
+        #   options.add_preference('homepage', 'http://www.seleniumhq.com/')
+        #
+        # @param [String] name Key of the preference
+        # @param [Boolean, String, Integer] value Value of the preference
+        #
+
+        def add_preference(name, value)
+          prefs[name] = value
+        end
+
+        #
+        # Run Chrome in headless mode.
+        #
+        # @example Enable headless mode
+        #   options = Selenium::WebDriver::Chrome::Options.new
+        #   options.headless!
+        #
+
+        def headless!
+          add_argument '--headless'
+        end
+
+        #
+        # Add an emulation device name
+        #
+        # @example Start Chrome in mobile emulation mode by device name
+        #   options = Selenium::WebDriver::Chrome::Options.new
+        #   options.add_emulation(device_name: 'iPhone 6')
+        #
+        # @example Start Chrome in mobile emulation mode by device metrics
+        #   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
+        #
+
+        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
+        end
+
+        #
+        # @api 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)
+          add_argument("--user-data-dir=#{@profile[:directory]}") if @profile
+
+          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?
+          opts[:detach] = @detach if !@detach.nil? && @detach != false
+
+          {KEY => generate_as_json(opts)}
+        end
+      end # Options
+    end # Chrome
+  end # WebDriver
+end # Selenium

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

@@ -1,7 +1,25 @@
+# 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 Chrome
-
       #
       # @private
       #
@@ -9,16 +27,16 @@ module Selenium
       class Profile
         include ProfileHelper
 
+        attr_reader :directory
+
         def initialize(model = nil)
-          @model      = verify_model(model)
+          @model = verify_model(model)
           @extensions = []
           @encoded_extensions = []
         end
 
         def add_extension(path)
-          unless File.file?(path)
-            raise Error::WebDriverError, "could not find extension at #{path.inspect}"
-          end
+          raise Error::WebDriverError, "could not find extension at #{path.inspect}" unless File.file?(path)
 
           @extensions << path
         end
@@ -30,36 +48,38 @@ module Selenium
         #
         # Set a preference in the profile.
         #
-        # See http://codesearch.google.com/codesearch#OAMlx_jo-ck/src/chrome/common/pref_names.cc&exact_package=chromium
+        # See https://src.chromium.org/svn/trunk/src/chrome/common/pref_names.cc
         #
 
         def []=(key, value)
-          parts = key.split(".")
-          parts[0..-2].inject(prefs) { |pr, k| pr[k] ||= {} }[parts.last] = value
+          parts = key.split('.')
+          parts[0..-2].inject(prefs) { |a, e| a[e] ||= {} }[parts.last] = value
         end
 
         def [](key)
-          parts = key.split(".")
-          parts.inject(prefs) { |pr, k| pr.fetch(k) }
+          parts = key.split('.')
+          parts.inject(prefs) { |a, e| a.fetch(e) }
         end
 
         def layout_on_disk
-          dir = @model ? create_tmp_copy(@model) : Dir.mktmpdir("webdriver-chrome-profile")
-          FileReaper << dir
+          @directory = @model ? create_tmp_copy(@model) : Dir.mktmpdir('webdriver-chrome-profile')
+          FileReaper << @directory
 
-          write_prefs_to dir
+          write_prefs_to @directory
 
-          dir
+          @directory
         end
 
-        def as_json(opts = nil)
+        def as_json(*)
           extensions = @extensions.map do |crx_path|
-            File.open(crx_path, "rb") { |crx_file| Base64.strict_encode64 crx_file.read }
+            File.open(crx_path, 'rb') { |crx_file| Base64.strict_encode64 crx_file.read }
           end
 
           extensions.concat(@encoded_extensions)
 
-          super.merge('extensions' => extensions)
+          opts = {'directory' => directory || layout_on_disk}
+          opts['extensions'] = extensions if extensions.any?
+          opts
         end
 
         private
@@ -68,7 +88,7 @@ module Selenium
           prefs_file = prefs_file_for(dir)
 
           FileUtils.mkdir_p File.dirname(prefs_file)
-          File.open(prefs_file, "w") { |file| file << WebDriver.json_dump(prefs)  }
+          File.open(prefs_file, 'w') { |file| file << JSON.generate(prefs) }
         end
 
         def prefs
@@ -77,14 +97,14 @@ module Selenium
 
         def read_model_prefs
           return {} unless @model
-          WebDriver.json_load File.read(prefs_file_for(@model))
+
+          JSON.parse File.read(prefs_file_for(@model))
         end
 
         def prefs_file_for(dir)
           File.join dir, 'Default', 'Preferences'
         end
       end # Profile
-
     end # Chrome
   end # WebDriver
 end # Selenium