selenium-webdriver 3.142.6 → 4.1.0

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,24 +104,19 @@ module Selenium
         @timeouts ||= Timeouts.new(@bridge)
       end
 
-      #
-      # @api beta This API may be changed or removed in a future release.
-      #
-
       def logs
+        WebDriver.logger.deprecate('Manager#logs', 'Chrome::Driver#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)
+        WebDriver.logger.deprecate('Manager#new_window', 'TargetLocator#new_window', id: :new_window) do
+          'e.g., `driver.switch_to.new_window(:tab)`'
+        end
         case type
         when :tab, :window
           result = @bridge.new_window(type)
@@ -129,10 +131,6 @@ module Selenium
         end
       end
 
-      #
-      # @api beta This API may be changed or removed in a future release.
-      #
-
       def window
         @window ||= Window.new(@bridge)
       end
@@ -169,6 +167,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

@@ -0,0 +1,184 @@
+# 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 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
+
+      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_method :internet_explorer, :ie
+
+        def edge(**opts)
+          Edge::Options.new(**opts)
+        end
+        alias_method :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(options: nil, **opts)
+        self.class.set_capabilities
+
+        @options = if options
+                     WebDriver.logger.deprecate(":options as keyword for initializing #{self.class}",
+                                                "custom values directly in #new constructor",
+                                                id: :options_options)
+                     opts.merge(options)
+                   else
+                     opts
+                   end
+        @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)
+        @options[name.keys.first] = name.values.first if value.nil? && name.is_a?(Hash)
+        @options[name] = value
+      end
+
+      def ==(other)
+        return false unless other.is_a? self.class
+
+        as_json == other.as_json
+      end
+
+      alias_method :eql?, :==
+
+      #
+      # @api private
+      #
+
+      def as_json(*)
+        options = @options.dup
+
+        w3c_options = process_w3c_options(options)
+
+        self.class::CAPABILITIES.each do |capability_alias, capability_name|
+          capability_value = options.delete(capability_alias)
+          options[capability_name] = capability_value if !capability_value.nil? && !options.key?(capability_name)
+        end
+        browser_options = defined?(self.class::KEY) ? {self.class::KEY => options} : options
+
+        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) }
+        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
+
+      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,6 +57,8 @@ module Selenium
           :jenkins
         elsif ENV['APPVEYOR']
           :appveyor
+        elsif ENV['GITHUB_ACTIONS']
+          :github
         end
       end
 
@@ -95,7 +97,10 @@ module Selenium
       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?

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})")
+          # 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

@@ -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,

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,7 +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
+        bridge.find_element_by by, what, ref
       rescue Selenium::WebDriver::Error::TimeoutError
         # Implicit Wait times out in Edge
         raise Selenium::WebDriver::Error::NoSuchElementError
@@ -77,7 +78,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
+        bridge.find_elements_by by, what, ref
       rescue Selenium::WebDriver::Error::TimeoutError
         # Implicit Wait times out in Edge
         []
@@ -92,7 +93,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

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

@@ -21,40 +21,18 @@ module Selenium
   module WebDriver
     #
     # Base class implementing default behavior of service object,
-    # responsible for starting and stopping driver implementations.
+    # responsible for storing a service manager configuration.
     #
 
     class Service
-      START_TIMEOUT = 20
-      SOCKET_LOCK_TIMEOUT = 45
-      STOP_TIMEOUT = 20
-
-      @default_port = nil
-      @driver_path = nil
-      @executable = nil
-      @missing_text = nil
-
       class << self
-        attr_reader :default_port, :driver_path, :executable, :missing_text, :shutdown_supported
+        attr_reader :driver_path
 
         def chrome(**opts)
           Chrome::Service.new(**opts)
         end
 
         def firefox(**opts)
-          binary_path = Firefox::Binary.path
-          args = opts.delete(:args)
-          case args
-          when Hash
-            args[:binary] ||= binary_path
-            opts[:args] = args
-          when Array
-            opts[:args] = ["--binary=#{binary_path}"]
-            opts[:args] += args
-          else
-            opts[:args] = ["--binary=#{binary_path}"]
-          end
-
           Firefox::Service.new(**opts)
         end
 
@@ -66,6 +44,7 @@ module Selenium
         def edge(**opts)
           Edge::Service.new(**opts)
         end
+        alias_method :microsoftedge, :edge
 
         def safari(**opts)
           Safari::Service.new(**opts)
@@ -78,7 +57,7 @@ module Selenium
       end
 
       attr_accessor :host
-      attr_reader :executable_path
+      attr_reader :executable_path, :port, :extra_args
 
       #
       # End users should use a class method for the desired driver, rather than using this directly.
@@ -88,7 +67,7 @@ module Selenium
 
       def initialize(path: nil, port: nil, args: nil)
         path ||= self.class.driver_path
-        port ||= self.class.default_port
+        port ||= self.class::DEFAULT_PORT
         args ||= []
 
         @executable_path = binary_path(path)
@@ -100,120 +79,33 @@ module Selenium
         raise Error::WebDriverError, "invalid port: #{@port}" if @port < 1
       end
 
-      def start
-        raise "already started: #{uri.inspect} #{@executable_path.inspect}" if process_running?
-
-        Platform.exit_hook(&method(:stop)) # make sure we don't leave the server running
-
-        socket_lock.locked do
-          find_free_port
-          start_process
-          connect_until_stable
-        end
+      def launch
+        sm = ServiceManager.new(self)
+        sm.start
+        sm
       end
 
-      def stop
-        return unless self.class.shutdown_supported
-
-        stop_server
-        @process.poll_for_exit STOP_TIMEOUT
-      rescue ChildProcess::TimeoutError
-        nil # noop
-      ensure
-        stop_process
+      def shutdown_supported
+        self.class::SHUTDOWN_SUPPORTED
       end
 
-      def uri
-        @uri ||= URI.parse("http://#{@host}:#{@port}")
+      protected
+
+      def extract_service_args(driver_opts)
+        driver_opts.key?(:args) ? driver_opts.delete(:args) : []
       end
 
       private
 
       def binary_path(path = nil)
         path = path.call if path.is_a?(Proc)
-        path ||= Platform.find_binary(self.class.executable)
+        path ||= Platform.find_binary(self.class::EXECUTABLE)
 
-        raise Error::WebDriverError, self.class.missing_text unless path
+        raise Error::WebDriverError, self.class::MISSING_TEXT unless path
 
         Platform.assert_executable path
         path
       end
-
-      def build_process(*command)
-        WebDriver.logger.debug("Executing Process #{command}")
-        @process = ChildProcess.build(*command)
-        if WebDriver.logger.debug?
-          @process.io.stdout = @process.io.stderr = WebDriver.logger.io
-        elsif Platform.jruby?
-          # Apparently we need to read the output of drivers on JRuby.
-          @process.io.stdout = @process.io.stderr = File.new(Platform.null_device, 'w')
-        end
-
-        @process
-      end
-
-      def connect_to_server
-        Net::HTTP.start(@host, @port) do |http|
-          http.open_timeout = STOP_TIMEOUT / 2
-          http.read_timeout = STOP_TIMEOUT / 2
-
-          yield http
-        end
-      end
-
-      def find_free_port
-        @port = PortProber.above(@port)
-      end
-
-      def start_process
-        @process = build_process(@executable_path, "--port=#{@port}", *@extra_args)
-        # Note: this is a bug only in Windows 7
-        @process.leader = true unless Platform.windows?
-        @process.start
-      end
-
-      def stop_process
-        return if process_exited?
-
-        @process.stop STOP_TIMEOUT
-        @process.io.stdout.close if Platform.jruby? && !WebDriver.logger.debug?
-      end
-
-      def stop_server
-        return if process_exited?
-
-        connect_to_server { |http| http.get('/shutdown') }
-      end
-
-      def process_running?
-        defined?(@process) && @process&.alive?
-      end
-
-      def process_exited?
-        @process.nil? || @process.exited?
-      end
-
-      def connect_until_stable
-        socket_poller = SocketPoller.new @host, @port, START_TIMEOUT
-        return if socket_poller.connected?
-
-        raise Error::WebDriverError, cannot_connect_error_text
-      end
-
-      def cannot_connect_error_text
-        "unable to connect to #{self.class.executable} #{@host}:#{@port}"
-      end
-
-      def socket_lock
-        @socket_lock ||= SocketLock.new(@port - 1, SOCKET_LOCK_TIMEOUT)
-      end
-
-      protected
-
-      def extract_service_args(driver_opts)
-        driver_opts.key?(:args) ? driver_opts.delete(:args) : []
-      end
-
     end # Service
   end # WebDriver
 end # Selenium