selenium-webdriver 4.4.0 → 4.8.0

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

@@ -32,6 +32,19 @@ module Selenium
           Status.new(status['ready'], status['message'])
         end
 
+        def subscribe(events, browsing_contexts = nil)
+          events_list = Array(events)
+          browsing_contexts_list = browsing_contexts.nil? ? nil : Array(browsing_contexts)
+
+          @bidi.send_cmd('session.subscribe', events: events_list, contexts: browsing_contexts_list)
+        end
+
+        def unsubscribe(events, browsing_contexts = nil)
+          events_list = Array(events)
+          browsing_contexts_list = browsing_contexts.nil? ? nil : Array(browsing_contexts)
+
+          @bidi.send_cmd('session.unsubscribe', events: events_list, contexts: browsing_contexts_list)
+        end
       end # Session
     end # BiDi
   end # WebDriver

data/lib/selenium/webdriver/bidi.rb

@@ -21,6 +21,8 @@ module Selenium
   module WebDriver
     class BiDi
       autoload :Session, 'selenium/webdriver/bidi/session'
+      autoload :LogInspector, 'selenium/webdriver/bidi/log_inspector'
+      autoload :BrowsingContext, 'selenium/webdriver/bidi/browsing_context'
 
       def initialize(url:)
         @ws = WebSocketConnection.new(url: url)
@@ -49,7 +51,6 @@ module Selenium
       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

@@ -17,31 +17,24 @@
 # specific language governing permissions and limitations
 # under the License.
 
+require 'selenium/webdriver/chromium/driver'
+
 module Selenium
   module WebDriver
     module Chrome
-
       #
       # Driver implementation for Chrome.
       # @api private
       #
 
-      class Driver < WebDriver::Driver
-        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
+      class Driver < Chromium::Driver
+        def initialize(capabilities: nil, options: nil, service: nil, url: nil, **opts)
+          raise ArgumentError, "Can't initialize #{self.class} with :url" if url
+
+          caps = process_options(options, capabilities)
+          url = service_url(service || Service.chrome)
+          super(caps: caps, url: url, **opts)
+        end
 
         def browser
           :chrome
@@ -49,21 +42,19 @@ module Selenium
 
         private
 
-        def devtools_url
-          uri = URI(devtools_address)
-          response = Net::HTTP.get(uri.hostname, '/json/version', uri.port)
-
-          JSON.parse(response)['webSocketDebuggerUrl']
-        end
-
-        def devtools_version
-          Integer(capabilities.browser_version.split('.').first)
-        end
-
         def devtools_address
           "http://#{capabilities['goog:chromeOptions']['debuggerAddress']}"
         end
 
+        def process_options(options, capabilities)
+          if options && !options.is_a?(Options)
+            raise ArgumentError, ":options must be an instance of #{Options}"
+          elsif options.nil? && capabilities.nil?
+            options = Options.new
+          end
+
+          super(options, capabilities)
+        end
       end # Driver
     end # Chrome
   end # WebDriver

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

@@ -17,93 +17,26 @@
 # specific language governing permissions and limitations
 # under the License.
 
+require 'selenium/webdriver/chromium/features'
+
 module Selenium
   module WebDriver
     module Chrome
       module Features
+        include WebDriver::Chromium::Features
 
         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']
+          send_command: [:post, 'session/:session_id/goog/cdp/execute']
         }.freeze
 
         def commands(command)
-          CHROME_COMMANDS[command] || self.class::COMMANDS[command]
-        end
-
-        def launch_app(id)
-          execute :launch_app, {}, {id: id}
-        end
-
-        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)
-        end
-
-        def log(type)
-          data = execute :get_log, {}, {type: type.to_s}
-
-          Array(data).map do |l|
-            LogEntry.new l.fetch('level', 'UNKNOWN'), l.fetch('timestamp'), l.fetch('message')
-          rescue KeyError
-            next
-          end
+          CHROME_COMMANDS[command] || CHROMIUM_COMMANDS[command] || self.class::COMMANDS[command]
         end
       end # Bridge
     end # Chrome

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

@@ -17,258 +17,24 @@
 # specific language governing permissions and limitations
 # under the License.
 
+require 'selenium/webdriver/chromium/options'
+
 module Selenium
   module WebDriver
     module Chrome
-      class Options < WebDriver::Options
-        attr_accessor :profile, :logging_prefs
-
+      class Options < Chromium::Options
         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, 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] 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
-
-        #
-        # 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)
-          validate_extension(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 { |ext| validate_extension(ext) }
-        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)
-          @options[:args] << arg
-        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)
-          @options[: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 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
-        #   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 [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(**opts)
-          @options[:emulation] = opts
-        end
-
-        #
-        # 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
-
         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
-
-          check_w3c(options[:w3c]) if options.key?(:w3c)
-
-          if @profile
-            options['args'] ||= []
-            options['args'] << "--user-data-dir=#{@profile.directory}"
-          end
-
-          return if (@encoded_extensions + @extensions).empty?
-
-          options['extensions'] = @encoded_extensions + @extensions.map { |ext| encode_extension(ext) }
-        end
-
-        def check_w3c(w3c)
-          if w3c
-            WebDriver.logger.warn("Setting 'w3c: true' is redundant and will no longer be allowed", id: :w3c)
-            return
-          end
-
-          raise Error::InvalidArgumentError,
-                "Setting 'w3c: false' is not allowed.\n" \
-                "Please update to W3C Syntax: https://www.selenium.dev/blog/2022/legacy-protocol-support/"
-        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
   end # WebDriver

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

@@ -17,6 +17,8 @@
 # specific language governing permissions and limitations
 # under the License.
 
+require 'selenium/webdriver/chromium/profile'
+
 module Selenium
   module WebDriver
     module Chrome
@@ -24,89 +26,7 @@ module Selenium
       # @private
       #
 
-      class Profile
-        include ProfileHelper
-
-        def initialize(model = nil)
-          @model = verify_model(model)
-          @extensions = []
-          @encoded_extensions = []
-          @directory = nil
-        end
-
-        def add_extension(path)
-          raise Error::WebDriverError, "could not find extension at #{path.inspect}" unless File.file?(path)
-
-          @extensions << path
-        end
-
-        def add_encoded_extension(encoded)
-          @encoded_extensions << encoded
-        end
-
-        def directory
-          @directory || layout_on_disk
-        end
-
-        #
-        # Set a preference in the profile.
-        #
-        # See https://src.chromium.org/viewvc/chrome/trunk/src/chrome/common/pref_names.cc
-        #
-
-        def []=(key, 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) { |a, e| a.fetch(e) }
-        end
-
-        def layout_on_disk
-          @directory = @model ? create_tmp_copy(@model) : Dir.mktmpdir('webdriver-chrome-profile')
-          FileReaper << @directory
-
-          write_prefs_to @directory
-
-          @directory
-        end
-
-        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)
-
-          opts = {'directory' => directory || layout_on_disk}
-          opts['extensions'] = extensions if extensions.any?
-          opts
-        end
-
-        private
-
-        def write_prefs_to(dir)
-          prefs_file = prefs_file_for(dir)
-
-          FileUtils.mkdir_p File.dirname(prefs_file)
-          File.open(prefs_file, 'w') { |file| file << JSON.generate(prefs) }
-        end
-
-        def prefs
-          @prefs ||= read_model_prefs
-        end
-
-        def read_model_prefs
-          return {} unless @model
-
-          JSON.parse File.read(prefs_file_for(@model))
-        end
-
-        def prefs_file_for(dir)
-          File.join dir, 'Default', 'Preferences'
-        end
+      class Profile < Chromium::Profile
       end # Profile
     end # Chrome
   end # WebDriver

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

@@ -17,35 +17,20 @@
 # specific language governing permissions and limitations
 # under the License.
 
+require 'selenium/webdriver/chromium/service'
+
 module Selenium
   module WebDriver
     module Chrome
-      class Service < WebDriver::Service
+      class Service < Chromium::Service
         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.
+          More info at https://www.selenium.dev/documentation/webdriver/getting_started/install_drivers/?language=ruby.
         ERROR
         SHUTDOWN_SUPPORTED = true
-
-        private
-
-        # 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)
-          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
-        end
       end # Service
     end # Chrome
   end # WebDriver

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

@@ -0,0 +1,61 @@
+# 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 Chromium
+      #
+      # Driver implementation for Chrome.
+      # @api private
+      #
+
+      class Driver < WebDriver::Driver
+        EXTENSIONS = [DriverExtensions::HasCDP,
+                      DriverExtensions::HasBiDi,
+                      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
+
+        protected
+
+        def devtools_url
+          uri = URI(devtools_address)
+          response = Net::HTTP.get(uri.hostname, '/json/version', uri.port)
+
+          JSON.parse(response)['webSocketDebuggerUrl']
+        end
+
+        def devtools_version
+          Integer(capabilities.browser_version.split('.').first)
+        end
+      end # Driver
+    end # Chromium
+  end # WebDriver
+end # Selenium