selenium-webdriver 3.142.7 → 4.16.0

data/lib/selenium/webdriver/common/logger.rb

@@ -38,15 +38,31 @@ module Selenium
 
       def_delegators :@logger,
                      :close,
-                     :debug, :debug?,
-                     :info, :info?,
-                     :warn, :warn?,
-                     :error, :error?,
+                     :debug?,
+                     :info?,
+                     :warn?,
+                     :error?,
                      :fatal, :fatal?,
-                     :level, :level=
+                     :level
 
-      def initialize
-        @logger = create_logger($stdout)
+      #
+      # @param [String] progname Allow child projects to use Selenium's Logger pattern
+      #
+      def initialize(progname = 'Selenium', default_level: nil, ignored: nil, allowed: nil)
+        default_level ||= $DEBUG || ENV.key?('DEBUG') ? :debug : :warn
+
+        @logger = create_logger(progname, level: default_level)
+        @ignored = Array(ignored)
+        @allowed = Array(allowed)
+        @first_warning = false
+      end
+
+      def level=(level)
+        if level == :info && @logger.level == :info
+          info(':info is now the default log level, to see additional logging, set log level to :debug')
+        end
+
+        @logger.level = level
       end
 
       #
@@ -73,29 +89,101 @@ module Selenium
         @logger.instance_variable_get(:@logdev).dev
       end
 
+      #
+      # Will not log the provided ID.
+      #
+      # @param [Array, Symbol] ids
+      #
+      def ignore(*ids)
+        @ignored += Array(ids).flatten
+      end
+
+      #
+      # Will only log the provided ID.
+      #
+      # @param [Array, Symbol] ids
+      #
+      def allow(*ids)
+        @allowed += Array(ids).flatten
+      end
+
+      #
+      # Used to supply information of interest for debugging a problem
+      # Overrides default #debug to skip ignored messages by provided id
+      #
+      # @param [String] message
+      # @param [Symbol, Array<Symbol>] id
+      # @yield see #deprecate
+      #
+      def debug(message, id: [], &block)
+        discard_or_log(:debug, message, id, &block)
+      end
+
+      #
+      # Used to supply information of general interest
+      #
+      # @param [String] message
+      # @param [Symbol, Array<Symbol>] id
+      # @yield see #deprecate
+      #
+      def info(message, id: [], &block)
+        discard_or_log(:info, message, id, &block)
+      end
+
+      #
+      # Used to supply information that suggests an error occurred
+      #
+      # @param [String] message
+      # @param [Symbol, Array<Symbol>] id
+      # @yield see #deprecate
+      #
+      def error(message, id: [], &block)
+        discard_or_log(:error, message, id, &block)
+      end
+
+      #
+      # Used to supply information that suggests action be taken by user
+      #
+      # @param [String] message
+      # @param [Symbol, Array<Symbol>] id
+      # @yield see #deprecate
+      #
+      def warn(message, id: [], &block)
+        discard_or_log(:warn, message, id, &block)
+      end
+
       #
       # Marks code as deprecated with/without replacement.
       #
       # @param [String] old
       # @param [String, nil] new
+      # @param [Symbol, Array<Symbol>] id
+      # @param [String] reference
+      # @yield appends additional message to end of provided template
       #
-      def deprecate(old, new = nil)
+      def deprecate(old, new = nil, id: [], reference: '', &block)
+        id = Array(id)
+        return if @ignored.include?(:deprecations)
+
+        id << :deprecations if @allowed.include?(:deprecations)
+
         message = +"[DEPRECATION] #{old} is deprecated"
         message << if new
                      ". Use #{new} instead."
                    else
-                     ' and will be removed in the next releases.'
+                     ' and will be removed in a future release.'
                    end
+        message << " See explanation for this deprecation: #{reference}." unless reference.empty?
 
-        warn message
+        discard_or_log(:warn, message, id, &block)
       end
 
       private
 
-      def create_logger(output)
-        logger = ::Logger.new(output)
-        logger.progname = 'Selenium'
-        logger.level = default_level
+      def create_logger(name, level:)
+        logger = ::Logger.new($stdout)
+        logger.progname = name
+        logger.level = level
         logger.formatter = proc do |severity, time, progname, msg|
           "#{time.strftime('%F %T')} #{severity} #{progname} #{msg}\n"
         end
@@ -103,12 +191,24 @@ module Selenium
         logger
       end
 
-      def default_level
-        if $DEBUG || ENV.key?('DEBUG')
-          :debug
-        else
-          :warn
+      def discard_or_log(level, message, id)
+        id = Array(id)
+        return if (@ignored & id).any?
+        return if @allowed.any? && (@allowed & id).none?
+
+        return if ::Logger::Severity.const_get(level.upcase) < @logger.level
+
+        unless @first_warning
+          @first_warning = true
+          info("Details on how to use and modify Selenium logger:\n", id: [:logger_info]) do
+            "https://selenium.dev/documentation/webdriver/troubleshooting/logging\n"
+          end
         end
+
+        msg = id.empty? ? message : "[#{id.map(&:inspect).join(', ')}] #{message} "
+        msg += " #{yield}" if block_given?
+
+        @logger.send(level) { msg }
       end
     end # Logger
   end # WebDriver

data/lib/selenium/webdriver/common/manager.rb

@@ -36,6 +36,7 @@ module Selenium
       # @option opts [String] :value A value
       # @option opts [String] :path ('/') A path
       # @option opts [String] :secure (false) A boolean
+      # @option opts [String] :same_site (Strict or Lax) currently supported only in chrome 80+ versions
       # @option opts [Time,DateTime,Numeric,nil] :expires (nil) Expiry date, either as a Time, DateTime, or seconds since epoch.
       #
       # @raise [ArgumentError] if :name or :value is not specified
@@ -45,9 +46,15 @@ module Selenium
         raise ArgumentError, 'name is required' unless opts[:name]
         raise ArgumentError, 'value is required' unless opts[:value]
 
-        opts[:path] ||= '/'
+        # NOTE: This is required because of https://bugs.chromium.org/p/chromedriver/issues/detail?id=3732
         opts[:secure] ||= false
 
+        same_site = opts.delete(:same_site)
+        opts[:sameSite] = same_site if same_site
+
+        http_only = opts.delete(:http_only)
+        opts[:httpOnly] = http_only if http_only
+
         obj = opts.delete(:expires)
         opts[:expiry] = seconds_from(obj).to_i if obj
 
@@ -62,7 +69,7 @@ module Selenium
       #
 
       def cookie_named(name)
-        all_cookies.find { |c| c[:name] == name }
+        convert_cookie(@bridge.cookie(name))
       end
 
       #
@@ -97,42 +104,6 @@ module Selenium
         @timeouts ||= Timeouts.new(@bridge)
       end
 
-      #
-      # @api beta This API may be changed or removed in a future release.
-      #
-
-      def logs
-        @logs ||= Logs.new(@bridge)
-      end
-
-      #
-      # Create a new top-level browsing context
-      # https://w3c.github.io/webdriver/#new-window
-      # @param type [Symbol] Supports two values: :tab and :window.
-      #  Use :tab if you'd like the new window to share an OS-level window
-      #  with the current browsing context.
-      #  Use :window otherwise
-      # @return [String] The value of the window handle
-      #
-      def new_window(type = :tab)
-        case type
-        when :tab, :window
-          result = @bridge.new_window(type)
-          unless result.key?('handle')
-            raise UnknownError, "the driver did not return a handle. " \
-                                "The returned result: #{result.inspect}"
-          end
-          result['handle']
-        else
-          raise ArgumentError, "invalid argument for type. Got: '#{type.inspect}'. " \
-                               "Try :tab or :window"
-        end
-      end
-
-      #
-      # @api beta This API may be changed or removed in a future release.
-      #
-
       def window
         @window ||= Window.new(@bridge)
       end
@@ -169,6 +140,8 @@ module Selenium
           path: cookie['path'],
           domain: cookie['domain'] && strip_port(cookie['domain']),
           expires: cookie['expiry'] && datetime_at(cookie['expiry']),
+          same_site: cookie['sameSite'],
+          http_only: cookie['httpOnly'],
           secure: cookie['secure']
         }
       end

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

@@ -19,35 +19,166 @@
 
 module Selenium
   module WebDriver
-    module Common
-      class Options
-        private
-
-        def generate_as_json(value)
-          if value.respond_to?(:as_json)
-            value.as_json
-          elsif value.is_a?(Hash)
-            value.each_with_object({}) { |(key, val), hash| hash[convert_json_key(key)] = generate_as_json(val) }
-          elsif value.is_a?(Array)
-            value.map(&method(:generate_as_json))
-          elsif value.is_a?(Symbol)
-            value.to_s
-          else
-            value
+    class Options
+      W3C_OPTIONS = %i[browser_name browser_version platform_name accept_insecure_certs page_load_strategy proxy
+                       set_window_rect timeouts unhandled_prompt_behavior strict_file_interactability
+                       web_socket_url].freeze
+
+      GRID_OPTIONS = %i[enable_downloads].freeze
+
+      class << self
+        attr_reader :driver_path
+
+        def chrome(**opts)
+          Chrome::Options.new(**opts)
+        end
+
+        def firefox(**opts)
+          Firefox::Options.new(**opts)
+        end
+
+        def ie(**opts)
+          IE::Options.new(**opts)
+        end
+        alias internet_explorer ie
+
+        def edge(**opts)
+          Edge::Options.new(**opts)
+        end
+        alias microsoftedge edge
+
+        def safari(**opts)
+          Safari::Options.new(**opts)
+        end
+
+        def set_capabilities
+          (W3C_OPTIONS + self::CAPABILITIES.keys).each do |key|
+            next if method_defined? key
+
+            define_method key do
+              @options[key]
+            end
+
+            define_method "#{key}=" do |value|
+              @options[key] = value
+            end
           end
         end
+      end
+
+      attr_accessor :options
+
+      def initialize(**opts)
+        self.class.set_capabilities
+
+        @options = opts
+        @options[:browser_name] = self.class::BROWSER
+      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 = nil)
+        name, value = name.first if value.nil? && name.is_a?(Hash)
+        @options[name] = value
+      end
 
-        def convert_json_key(key)
-          key = camel_case(key) if key.is_a?(Symbol)
-          return key if key.is_a?(String)
+      def ==(other)
+        return false unless other.is_a? self.class
 
-          raise TypeError, "expected String or Symbol, got #{key.inspect}:#{key.class}"
+        as_json == other.as_json
+      end
+
+      alias eql? ==
+
+      #
+      # @api private
+      #
+
+      def as_json(*)
+        options = @options.dup
+
+        downloads = options.delete(:enable_downloads)
+        options['se:downloadsEnabled'] = downloads unless downloads.nil?
+        w3c_options = process_w3c_options(options)
+
+        browser_options = self.class::CAPABILITIES.each_with_object({}) do |(capability_alias, capability_name), hash|
+          capability_value = options.delete(capability_alias)
+          hash[capability_name] = capability_value unless capability_value.nil?
         end
 
-        def camel_case(str)
-          str.to_s.gsub(/_([a-z])/) { Regexp.last_match(1).upcase }
+        raise Error::WebDriverError, "These options are not w3c compliant: #{options}" unless options.empty?
+
+        browser_options = {self.class::KEY => browser_options} if defined?(self.class::KEY)
+
+        process_browser_options(browser_options)
+        generate_as_json(w3c_options.merge(browser_options))
+      end
+
+      private
+
+      def w3c?(key)
+        W3C_OPTIONS.include?(key) || key.to_s.include?(':')
+      end
+
+      def process_w3c_options(options)
+        w3c_options = options.select { |key, val| w3c?(key) && !val.nil? }
+        w3c_options[:unhandled_prompt_behavior] &&= w3c_options[:unhandled_prompt_behavior]&.to_s&.tr('_', ' ')
+        options.delete_if { |key, _val| w3c?(key) }
+        w3c_options
+      end
+
+      def process_browser_options(_browser_options)
+        nil
+      end
+
+      def camelize?(_key)
+        true
+      end
+
+      def generate_as_json(value, camelize_keys: true)
+        if value.is_a?(Hash)
+          process_json_hash(value, camelize_keys)
+        elsif value.respond_to?(:as_json)
+          value.as_json
+        elsif value.is_a?(Array)
+          value.map { |val| generate_as_json(val, camelize_keys: camelize_keys) }
+        elsif value.is_a?(Symbol)
+          value.to_s
+        else
+          value
         end
-      end # Options
-    end # Common
+      end
+
+      def process_json_hash(value, camelize_keys)
+        value.each_with_object({}) do |(key, val), hash|
+          next if val.respond_to?(:empty?) && val.empty?
+
+          camelize = camelize_keys ? camelize?(key) : false
+          key = convert_json_key(key, camelize: camelize)
+          hash[key] = generate_as_json(val, camelize_keys: camelize)
+        end
+      end
+
+      def convert_json_key(key, camelize: true)
+        key = key.to_s if key.is_a?(Symbol)
+        key = camel_case(key) if camelize
+        return key if key.is_a?(String)
+
+        raise TypeError, "expected String or Symbol, got #{key.inspect}:#{key.class}"
+      end
+
+      def camel_case(str)
+        str.gsub(/_([a-z])/) { Regexp.last_match(1).upcase }
+      end
+    end # Options
   end # WebDriver
 end # Selenium

data/lib/selenium/webdriver/common/platform.rb

@@ -57,25 +57,19 @@ module Selenium
           :jenkins
         elsif ENV['APPVEYOR']
           :appveyor
+        elsif ENV['GITHUB_ACTIONS']
+          :github
         end
       end
 
-      def bitsize
-        @bitsize ||= if defined?(FFI::Platform::ADDRESS_SIZE)
-                       FFI::Platform::ADDRESS_SIZE
-                     elsif defined?(FFI)
-                       FFI.type_size(:pointer) == 4 ? 32 : 64
-                     elsif jruby?
-                       Integer(ENV_JAVA['sun.arch.data.model'])
-                     else
-                       1.size == 4 ? 32 : 64
-                     end
-      end
-
       def jruby?
         engine == :jruby
       end
 
+      def truffleruby?
+        engine == :truffleruby
+      end
+
       def ruby_version
         RUBY_VERSION
       end
@@ -92,15 +86,21 @@ module Selenium
         os == :linux
       end
 
+      def unix?
+        os == :unix
+      end
+
       def wsl?
         return false unless linux?
 
-        File.read('/proc/version').include?('Microsoft')
+        File.read('/proc/version').downcase.include?('microsoft')
+      rescue Errno::EACCES
+        # the file cannot be accessed on Linux on DeX
+        false
       end
 
       def cygwin?
-        RUBY_PLATFORM =~ /cygwin/
-        !Regexp.last_match.nil?
+        RUBY_PLATFORM.include?('cygwin')
       end
 
       def null_device
@@ -150,43 +150,6 @@ module Selenium
         at_exit { yield if Process.pid == pid }
       end
 
-      def find_binary(*binary_names)
-        paths = ENV['PATH'].split(File::PATH_SEPARATOR)
-
-        if windows?
-          binary_names.map! { |n| "#{n}.exe" }
-          binary_names.dup.each { |n| binary_names << n.gsub('exe', 'bat') }
-        end
-
-        binary_names.each do |binary_name|
-          paths.each do |path|
-            full_path = File.join(path, binary_name)
-            full_path = unix_path(full_path) if windows?
-            exe = Dir.glob(full_path).find { |f| File.executable?(f) }
-            return exe if exe
-          end
-        end
-
-        nil
-      end
-
-      def find_in_program_files(*binary_names)
-        paths = [
-          ENV['PROGRAMFILES'] || '\\Program Files',
-          ENV['ProgramFiles(x86)'] || '\\Program Files (x86)',
-          ENV['ProgramW6432'] || '\\Program Files'
-        ]
-
-        paths.each do |root|
-          binary_names.each do |name|
-            exe = File.join(root, name)
-            return exe if File.executable?(exe)
-          end
-        end
-
-        nil
-      end
-
       def localhost
         info = Socket.getaddrinfo 'localhost', 80, Socket::AF_INET, Socket::SOCK_STREAM
 

data/lib/selenium/webdriver/common/port_prober.rb

@@ -32,12 +32,10 @@ module Selenium
 
       def self.free?(port)
         Platform.interfaces.each do |host|
-          begin
-            TCPServer.new(host, port).close
-          rescue *IGNORED_ERRORS => ex
-            WebDriver.logger.debug("port prober could not bind to #{host}:#{port} (#{ex.message})")
-            # ignored - some machines appear unable to bind to some of their interfaces
-          end
+          TCPServer.new(host, port).close
+        rescue *IGNORED_ERRORS => e
+          WebDriver.logger.debug("port prober could not bind to #{host}:#{port} (#{e.message})", id: :driver_service)
+          # ignored - some machines appear unable to bind to some of their interfaces
         end
 
         true

data/lib/selenium/webdriver/common/profile_helper.rb

@@ -31,8 +31,16 @@ module Selenium
         base.extend ClassMethods
       end
 
+      def self.decoded(json)
+        JSON.parse(json).fetch('zip')
+      end
+
+      def encoded
+        Zipper.zip(layout_on_disk)
+      end
+
       def as_json(*)
-        {"zip" => Zipper.zip(layout_on_disk)}
+        {'zip' => encoded}
       end
 
       def to_json(*)
@@ -63,18 +71,12 @@ module Selenium
 
       module ClassMethods
         def from_json(json)
-          data = JSON.parse(json).fetch('zip')
+          data = decoded(json)
 
-          # can't use Tempfile here since it doesn't support File::BINARY mode on 1.8
-          # can't use Dir.mktmpdir(&blk) because of http://jira.codehaus.org/browse/JRUBY-4082
-          tmp_dir = Dir.mktmpdir
-          begin
-            zip_path = File.join(tmp_dir, "webdriver-profile-duplicate-#{json.hash}.zip")
+          Tempfile.create do |zip_path|
             File.open(zip_path, 'wb') { |zip_file| zip_file << Base64.decode64(data) }
 
             new Zipper.unzip(zip_path)
-          ensure
-            FileUtils.rm_rf tmp_dir
           end
         end
       end # ClassMethods

data/lib/selenium/webdriver/common/proxy.rb

@@ -74,7 +74,7 @@ module Selenium
       def ==(other)
         other.is_a?(self.class) && as_json == other.as_json
       end
-      alias_method :eql?, :==
+      alias eql? ==
 
       def ftp=(value)
         self.type = :manual
@@ -127,7 +127,10 @@ module Selenium
       end
 
       def type=(type)
-        raise ArgumentError, "invalid proxy type: #{type.inspect}, expected one of #{TYPES.keys.inspect}" unless TYPES.key? type
+        unless TYPES.key? type
+          raise ArgumentError,
+                "invalid proxy type: #{type.inspect}, expected one of #{TYPES.keys.inspect}"
+        end
 
         if defined?(@type) && type != @type
           raise ArgumentError, "incompatible proxy type #{type.inspect} (already set to #{@type.inspect})"
@@ -138,10 +141,10 @@ module Selenium
 
       def as_json(*)
         json_result = {
-          'proxyType' => TYPES[type],
+          'proxyType' => TYPES[type].downcase,
           'ftpProxy' => ftp,
           'httpProxy' => http,
-          'noProxy' => no_proxy,
+          'noProxy' => no_proxy.is_a?(String) ? no_proxy.split(', ') : no_proxy,
           'proxyAutoconfigUrl' => pac,
           'sslProxy' => ssl,
           'autodetect' => auto_detect,
@@ -149,7 +152,7 @@ module Selenium
           'socksUsername' => socks_username,
           'socksPassword' => socks_password,
           'socksVersion' => socks_version
-        }.delete_if { |_k, v| v.nil? }
+        }.compact
 
         json_result if json_result.length > 1
       end

data/lib/selenium/webdriver/common/search_context.rb

@@ -30,6 +30,7 @@ module Selenium
         link_text: 'link text',
         name: 'name',
         partial_link_text: 'partial link text',
+        relative: 'relative',
         tag_name: 'tag name',
         xpath: 'xpath'
       }.freeze
@@ -59,10 +60,7 @@ module Selenium
         by = FINDERS[how.to_sym]
         raise ArgumentError, "cannot find element by #{how.inspect}" unless by
 
-        bridge.find_element_by by, what.to_s, ref
-      rescue Selenium::WebDriver::Error::TimeoutError
-        # Implicit Wait times out in Edge
-        raise Selenium::WebDriver::Error::NoSuchElementError
+        bridge.find_element_by by, what, ref
       end
 
       #
@@ -77,10 +75,7 @@ module Selenium
         by = FINDERS[how.to_sym]
         raise ArgumentError, "cannot find elements by #{how.inspect}" unless by
 
-        bridge.find_elements_by by, what.to_s, ref
-      rescue Selenium::WebDriver::Error::TimeoutError
-        # Implicit Wait times out in Edge
-        []
+        bridge.find_elements_by by, what, ref
       end
 
       private
@@ -92,7 +87,10 @@ module Selenium
         when 1
           arg = args.first
 
-          raise ArgumentError, "expected #{arg.inspect}:#{arg.class} to respond to #shift" unless arg.respond_to?(:shift)
+          unless arg.respond_to?(:shift)
+            raise ArgumentError,
+                  "expected #{arg.inspect}:#{arg.class} to respond to #shift"
+          end
 
           # this will be a single-entry hash, so use #shift over #first or #[]
           arr = arg.dup.shift