selenium-webdriver 3.142.7 → 4.3.0

data/lib/selenium/webdriver/bidi/session.rb

@@ -0,0 +1,38 @@
+# 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
+    class BiDi
+      class Session
+        Status = Struct.new(:ready, :message)
+
+        def initialize(bidi)
+          @bidi = bidi
+        end
+
+        def status
+          status = @bidi.send_cmd('session.status')
+          Status.new(status['ready'], status['message'])
+        end
+
+      end # Session
+    end # BiDi
+  end # WebDriver
+end # Selenium

data/lib/selenium/webdriver/bidi.rb

@@ -0,0 +1,55 @@
+# 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
+    class BiDi
+      autoload :Session, 'selenium/webdriver/bidi/session'
+
+      def initialize(url:)
+        @ws = WebSocketConnection.new(url: url)
+      end
+
+      def close
+        @ws.close
+      end
+
+      def callbacks
+        @ws.callbacks
+      end
+
+      def session
+        Session.new(self)
+      end
+
+      def send_cmd(method, **params)
+        data = {method: method, params: params.compact}
+        message = @ws.send_cmd(**data)
+        raise Error::WebDriverError, error_message(message) if message['error']
+
+        message['result']
+      end
+
+      def error_message(message)
+        "#{message['error']}: #{message['message']}\n#{message['stacktrace']}"
+      end
+
+    end # BiDi
+  end # WebDriver
+end # Selenium

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

@@ -27,100 +27,43 @@ module Selenium
       #
 
       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
+        EXTENSIONS = [DriverExtensions::HasCDP,
+                      DriverExtensions::HasCasting,
+                      DriverExtensions::HasNetworkConditions,
+                      DriverExtensions::HasNetworkInterception,
+                      DriverExtensions::HasWebStorage,
+                      DriverExtensions::HasLaunching,
+                      DriverExtensions::HasLocation,
+                      DriverExtensions::HasPermissions,
+                      DriverExtensions::DownloadsFiles,
+                      DriverExtensions::HasDevTools,
+                      DriverExtensions::HasAuthentication,
+                      DriverExtensions::HasLogs,
+                      DriverExtensions::HasLogEvents,
+                      DriverExtensions::HasPinnedScripts,
+                      DriverExtensions::PrintsPage].freeze
 
         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
+        def devtools_url
+          uri = URI(devtools_address)
+          response = Net::HTTP.get(uri.hostname, '/json/version', uri.port)
 
-          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='
+          JSON.parse(response)['webSocketDebuggerUrl']
+        end
 
-            caps[:proxy] = opts.delete(:proxy) if opts.key?(:proxy)
-            caps[:proxy] ||= opts.delete('proxy') if opts.key?('proxy')
-          end
+        def devtools_version
+          Integer(capabilities.browser_version.split('.').first)
+        end
 
-          caps
+        def devtools_address
+          "http://#{capabilities['goog:chromeOptions']['debuggerAddress']}"
         end
+
       end # Driver
     end # Chrome
   end # WebDriver

data/lib/selenium/webdriver/chrome/{bridge.rb → features.rb}

@@ -20,32 +20,77 @@
 module Selenium
   module WebDriver
     module Chrome
-      module Bridge
+      module Features
 
-        COMMANDS = {
+        CHROME_COMMANDS = {
+          launch_app: [:post, 'session/:session_id/chromium/launch_app'],
+          get_cast_sinks: [:get, 'session/:session_id/goog/cast/get_sinks'],
+          set_cast_sink_to_use: [:post, 'session/:session_id/goog/cast/set_sink_to_use'],
+          start_cast_tab_mirroring: [:post, 'session/:session_id/goog/cast/start_tab_mirroring'],
+          start_cast_desktop_mirroring: [:post, 'session/:session_id/goog/cast/start_desktop_mirroring'],
+          get_cast_issue_message: [:get, 'session/:session_id/goog/cast/get_issue_message'],
+          stop_casting: [:post, 'session/:session_id/goog/cast/stop_casting'],
           get_network_conditions: [:get, 'session/:session_id/chromium/network_conditions'],
           set_network_conditions: [:post, 'session/:session_id/chromium/network_conditions'],
+          delete_network_conditions: [:delete, 'session/:session_id/chromium/network_conditions'],
+          set_permission: [:post, 'session/:session_id/permissions'],
           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
+          CHROME_COMMANDS[command] || self.class::COMMANDS[command]
         end
 
-        def network_conditions
-          execute :get_network_conditions
+        def launch_app(id)
+          execute :launch_app, {}, {id: id}
         end
 
-        def send_command(command_params)
-          execute :send_command, {}, command_params
+        def cast_sinks
+          execute :get_cast_sinks
+        end
+
+        def cast_sink_to_use=(name)
+          execute :set_cast_sink_to_use, {}, {sinkName: name}
+        end
+
+        def cast_issue_message
+          execute :cast_issue_message
+        end
+
+        def start_cast_tab_mirroring(name)
+          execute :start_cast_tab_mirroring, {}, {sinkName: name}
+        end
+
+        def start_cast_desktop_mirroring(name)
+          execute :start_cast_desktop_mirroring, {}, {sinkName: name}
+        end
+
+        def stop_casting(name)
+          execute :stop_casting, {}, {sinkName: name}
+        end
+
+        def set_permission(name, value)
+          execute :set_permission, {}, {descriptor: {name: name}, state: value}
+        end
+
+        def network_conditions
+          execute :get_network_conditions
         end
 
         def network_conditions=(conditions)
           execute :set_network_conditions, {}, {network_conditions: conditions}
         end
 
+        def delete_network_conditions
+          execute :delete_network_conditions
+        end
+
+        def send_command(command_params)
+          execute :send_command, {}, command_params
+        end
+
         def available_log_types
           types = execute :get_available_log_types
           Array(types).map(&:to_sym)
@@ -55,11 +100,9 @@ module Selenium
           data = execute :get_log, {}, {type: type.to_s}
 
           Array(data).map do |l|
-            begin
-              LogEntry.new l.fetch('level', 'UNKNOWN'), l.fetch('timestamp'), l.fetch('message')
-            rescue KeyError
-              next
-            end
+            LogEntry.new l.fetch('level', 'UNKNOWN'), l.fetch('timestamp'), l.fetch('message')
+          rescue KeyError
+            next
           end
         end
       end # Bridge

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

@@ -20,38 +20,74 @@
 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
+      class Options < WebDriver::Options
+        attr_accessor :profile, :logging_prefs
 
         KEY = 'goog:chromeOptions'
+        BROWSER = 'chrome'
+
+        # see: http://chromedriver.chromium.org/capabilities
+        CAPABILITIES = {args: 'args',
+                        binary: 'binary',
+                        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',
+                        android_package: 'androidPackage',
+                        android_activity: 'androidActivity',
+                        android_device_serial: 'androidDeviceSerial',
+                        android_use_running_app: 'androidUseRunningApp'}.freeze
+
+        # NOTE: special handling of 'extensions' to validate when set instead of when used
+        attr_reader :extensions
 
-        #
         # 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)
+        #   driver = Selenium::WebDriver.for(:chrome, capabilities: options)
         #
+        # @param [Profile] profile An instance of a Chrome::Profile Class
         # @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 = []
+        # @option opts [Array] encoded_extensions List of extensions that do not need to be Base64 encoded
+        # @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
+        # @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(profile: nil, **opts)
+          super(**opts)
+
+          @profile = profile
+
+          @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 { |ext| validate_extension(ext) }
         end
 
         #
@@ -65,10 +101,22 @@ 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'
+          validate_extension(path)
+        end
 
-          @extensions << path
+        #
+        # 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 { |ext| validate_extension(ext) }
         end
 
         #
@@ -96,22 +144,7 @@ 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] << arg
         end
 
         #
@@ -126,7 +159,7 @@ module Selenium
         #
 
         def add_preference(name, value)
-          prefs[name] = value
+          @options[:prefs][name] = value
         end
 
         #
@@ -142,7 +175,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
@@ -152,37 +187,73 @@ 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
+        # Enables mobile browser use on Android.
+        #
+        # @see https://chromedriver.chromium.org/getting-started/getting-started---android
         #
+        # @param [String] package The package name of the Chrome or WebView app.
+        # @param [String] serial_number The device serial number on which to launch the Chrome or WebView app.
+        # @param [String] use_running_app When true uses an already-running Chrome or WebView app,
+        #   instead of launching the app with a clear data directory.
+        # @param [String] activity Name of the Activity hosting the WebView (Not available on Chrome Apps).
+        #
+
+        def enable_android(package: 'com.android.chrome', serial_number: nil, use_running_app: nil, activity: nil)
+          @options[:android_package] = package
+          @options[:android_activity] = activity unless activity.nil?
+          @options[:android_device_serial] = serial_number unless serial_number.nil?
+          @options[:android_use_running_app] = use_running_app unless use_running_app.nil?
+        end
 
-        def as_json(*)
-          extensions = @extensions.map do |crx_path|
-            File.open(crx_path, 'rb') { |crx_file| Base64.strict_encode64 crx_file.read }
+        private
+
+        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}"
           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)}
+
+          return if (@encoded_extensions + @extensions).empty?
+
+          options['extensions'] = @encoded_extensions + @extensions.map { |ext| encode_extension(ext) }
+        end
+
+        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'
+
+          @extensions << path
+        end
+
+        def camelize?(key)
+          !%w[localState prefs].include?(key)
         end
       end # Options
     end # Chrome

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

@@ -20,35 +20,28 @@
 module Selenium
   module WebDriver
     module Chrome
-      #
-      # @api private
-      #
-
       class Service < WebDriver::Service
-        @default_port = 9515
-        @executable = 'chromedriver'
-        @missing_text = <<~ERROR
+        DEFAULT_PORT = 9515
+        EXECUTABLE = 'chromedriver'
+        MISSING_TEXT = <<~ERROR
           Unable to find chromedriver. Please download the server from
           https://chromedriver.storage.googleapis.com/index.html and place it somewhere on your PATH.
           More info at https://github.com/SeleniumHQ/selenium/wiki/ChromeDriver.
         ERROR
-        @shutdown_supported = true
-
-        def self.driver_path=(path)
-          Platform.assert_executable path if path.is_a?(String)
-          @driver_path = path
-        end
+        SHUTDOWN_SUPPORTED = true
 
         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