selenium-webdriver 2.53.3 → 3.142.7

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

@@ -1,5 +1,5 @@
-# encoding: utf-8
-#
+# 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
@@ -21,45 +21,58 @@ module Selenium
   module WebDriver
     class Proxy
       TYPES = {
-        :direct      => "DIRECT",     # Direct connection, no proxy (default on Windows).
-        :manual      => "MANUAL",     # Manual proxy settings (e.g., for httpProxy).
-        :pac         => "PAC",        # Proxy autoconfiguration from URL.
-        :auto_detect => "AUTODETECT", # Proxy autodetection (presumably with WPAD).
-        :system      => "SYSTEM"      # Use system settings (default on Linux).
-      }
-
-      attr_reader :type,
-                  :ftp,
-                  :http,
-                  :socks,
-                  :socks_username,
-                  :socks_password,
-                  :no_proxy,
-                  :pac,
-                  :ssl,
-                  :auto_detect
+        direct: 'DIRECT', # Direct connection, no proxy (default on Windows).
+        manual: 'MANUAL', # Manual proxy settings (e.g., for httpProxy).
+        pac: 'PAC', # Proxy autoconfiguration from URL.
+        auto_detect: 'AUTODETECT', # Proxy autodetection (presumably with WPAD).
+        system: 'SYSTEM' # Use system settings (default on Linux).
+      }.freeze
+
+      ALLOWED = {type: 'proxyType',
+                 ftp: 'ftpProxy',
+                 http: 'httpProxy',
+                 no_proxy: 'noProxy',
+                 pac: 'proxyAutoconfigUrl',
+                 ssl: 'sslProxy',
+                 auto_detect: 'autodetect',
+                 socks: 'socksProxy',
+                 socks_username: 'socksUsername',
+                 socks_password: 'socksPassword',
+                 socks_version: 'socksVersion'}.freeze
+
+      ALLOWED.each_key { |t| attr_reader t }
+
+      def self.json_create(data)
+        data['proxyType'] = data['proxyType'].downcase.to_sym
+        return if data['proxyType'] == :unspecified
+
+        proxy = new
+
+        ALLOWED.each do |k, v|
+          proxy.send("#{k}=", data[v]) if data.key?(v)
+        end
+
+        proxy
+      end
 
       def initialize(opts = {})
-        opts = opts.dup
-
-        self.type           = opts.delete(:type) if opts.has_key? :type
-        self.ftp            = opts.delete(:ftp) if opts.has_key? :ftp
-        self.http           = opts.delete(:http) if opts.has_key? :http
-        self.no_proxy       = opts.delete(:no_proxy) if opts.has_key? :no_proxy
-        self.ssl            = opts.delete(:ssl) if opts.has_key? :ssl
-        self.pac            = opts.delete(:pac) if opts.has_key? :pac
-        self.auto_detect    = opts.delete(:auto_detect) if opts.has_key? :auto_detect
-        self.socks          = opts.delete(:socks) if opts.has_key? :socks
-        self.socks_username = opts.delete(:socks_username) if opts.has_key? :socks_username
-        self.socks_password = opts.delete(:socks_password) if opts.has_key? :socks_password
-
-        unless opts.empty?
-          raise ArgumentError, "unknown option#{'s' if opts.size != 1}: #{opts.inspect}"
+        not_allowed = []
+
+        opts.each do |k, v|
+          if ALLOWED.key?(k)
+            send("#{k}=", v)
+          else
+            not_allowed << k
+          end
         end
+
+        return if not_allowed.empty?
+
+        raise ArgumentError, "unknown option#{'s' if not_allowed.size != 1}: #{not_allowed.inspect}"
       end
 
       def ==(other)
-        other.kind_of?(self.class) && as_json == other.as_json
+        other.is_a?(self.class) && as_json == other.as_json
       end
       alias_method :eql?, :==
 
@@ -108,10 +121,13 @@ module Selenium
         @socks_password = value
       end
 
+      def socks_version=(value)
+        self.type = :manual
+        @socks_version = value
+      end
+
       def type=(type)
-        unless TYPES.has_key? type
-          raise ArgumentError, "invalid proxy type: #{type.inspect}, expected one of #{TYPES.keys.inspect}"
-        end
+        raise ArgumentError, "invalid proxy type: #{type.inspect}, expected one of #{TYPES.keys.inspect}" unless TYPES.key? type
 
         if defined?(@type) && type != @type
           raise ArgumentError, "incompatible proxy type #{type.inspect} (already set to #{@type.inspect})"
@@ -120,49 +136,27 @@ module Selenium
         @type = type
       end
 
-      def as_json(opts = nil)
+      def as_json(*)
         json_result = {
-          "proxyType" => TYPES[type]
-        }
-
-        json_result["ftpProxy"]           = ftp if ftp
-        json_result["httpProxy"]          = http if http
-        json_result["noProxy"]            = no_proxy if no_proxy
-        json_result["proxyAutoconfigUrl"] = pac if pac
-        json_result["sslProxy"]           = ssl if ssl
-        json_result["autodetect"]         = auto_detect if auto_detect
-        json_result["socksProxy"]         = socks if socks
-        json_result["socksUsername"]      = socks_username if socks_username
-        json_result["socksPassword"]      = socks_password if socks_password
+          'proxyType' => TYPES[type],
+          'ftpProxy' => ftp,
+          'httpProxy' => http,
+          'noProxy' => no_proxy,
+          'proxyAutoconfigUrl' => pac,
+          'sslProxy' => ssl,
+          'autodetect' => auto_detect,
+          'socksProxy' => socks,
+          'socksUsername' => socks_username,
+          'socksPassword' => socks_password,
+          'socksVersion' => socks_version
+        }.delete_if { |_k, v| v.nil? }
 
         json_result if json_result.length > 1
       end
 
-      def to_json(*args)
+      def to_json(*)
         JSON.generate as_json
       end
-
-      class << self
-        def json_create(data)
-          return if data['proxyType'] == 'UNSPECIFIED'
-
-          proxy = new
-
-          proxy.type           = data['proxyType'].downcase.to_sym if data.has_key? 'proxyType'
-          proxy.ftp            = data['ftpProxy'] if data.has_key? 'ftpProxy'
-          proxy.http           = data['httpProxy'] if data.has_key? 'httpProxy'
-          proxy.no_proxy       = data['noProxy'] if data.has_key? 'noProxy'
-          proxy.pac            = data['proxyAutoconfigUrl'] if data.has_key? 'proxyAutoconfigUrl'
-          proxy.ssl            = data['sslProxy'] if data.has_key? 'sslProxy'
-          proxy.auto_detect    = data['autodetect'] if data.has_key? 'autodetect'
-          proxy.socks          = data['socksProxy'] if data.has_key? 'socksProxy'
-          proxy.socks_username = data['socksUsername'] if data.has_key? 'socksUsername'
-          proxy.socks_password = data['socksPassword'] if data.has_key? 'socksPassword'
-
-          proxy
-        end
-      end # class << self
-
     end # Proxy
   end # WebDriver
 end # Selenium

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

@@ -1,5 +1,5 @@
-# encoding: utf-8
-#
+# 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
@@ -20,46 +20,47 @@
 module Selenium
   module WebDriver
     module SearchContext
-
       # @api private
       FINDERS = {
-        :class             => 'class name',
-        :class_name        => 'class name',
-        :css               => 'css selector',
-        :id                => 'id',
-        :link              => 'link text',
-        :link_text         => 'link text',
-        :name              => 'name',
-        :partial_link_text => 'partial link text',
-        :tag_name          => 'tag name',
-        :xpath             => 'xpath',
-      }
+        class: 'class name',
+        class_name: 'class name',
+        css: 'css selector',
+        id: 'id',
+        link: 'link text',
+        link_text: 'link text',
+        name: 'name',
+        partial_link_text: 'partial link text',
+        tag_name: 'tag name',
+        xpath: 'xpath'
+      }.freeze
 
       #
-      # Find the first element matching the given arguments.
+      # Find the first element matching the given arguments
       #
       # When using Element#find_element with :xpath, be aware that webdriver
       # follows standard conventions: a search prefixed with "//" will search
       # the entire document, not just the children of this current node. Use
       # ".//" to limit your search to the children of the receiving Element.
       #
-      # @param [:class, :class_name, :css, :id, :link_text, :link, :partial_link_text, :name, :tag_name, :xpath] how
-      # @param [String] what
+      # @overload find_element(how, what)
+      #   @param [Symbol, String] how The method to find the element by
+      #   @param [String] what The locator to use
+      # @overload find_element(opts)
+      #   @param [Hash] opts Find options
+      #   @option opts [Symbol] :how Key named after the method to find the element by, containing the locator
       # @return [Element]
       #
       # @raise [Error::NoSuchElementError] if the element doesn't exist
       #
-      #
 
       def find_element(*args)
         how, what = extract_args(args)
 
-        unless by = FINDERS[how.to_sym]
-          raise ArgumentError, "cannot find element by #{how.inspect}"
-        end
+        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
+      rescue Selenium::WebDriver::Error::TimeoutError
         # Implicit Wait times out in Edge
         raise Selenium::WebDriver::Error::NoSuchElementError
       end
@@ -69,20 +70,15 @@ module Selenium
       #
       # @see SearchContext#find_element
       #
-      # @param [:class, :class_name, :css, :id, :link_text, :link, :partial_link_text, :name, :tag_name, :xpath] how
-      # @param [String] what
-      # @return [Array<Element>]
-      #
 
       def find_elements(*args)
         how, what = extract_args(args)
 
-        unless by = FINDERS[how.to_sym]
-          raise ArgumentError, "cannot find elements by #{how.inspect}"
-        end
+        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
+      rescue Selenium::WebDriver::Error::TimeoutError
         # Implicit Wait times out in Edge
         []
       end
@@ -96,22 +92,17 @@ module Selenium
         when 1
           arg = args.first
 
-          unless arg.respond_to?(:shift)
-            raise ArgumentError, "expected #{arg.inspect}:#{arg.class} to respond to #shift"
-          end
+          raise ArgumentError, "expected #{arg.inspect}:#{arg.class} to respond to #shift" unless arg.respond_to?(:shift)
 
           # this will be a single-entry hash, so use #shift over #first or #[]
           arr = arg.dup.shift
-          unless arr.size == 2
-            raise ArgumentError, "expected #{arr.inspect} to have 2 elements"
-          end
+          raise ArgumentError, "expected #{arr.inspect} to have 2 elements" unless arr.size == 2
 
           arr
         else
           raise ArgumentError, "wrong number of arguments (#{args.size} for 2)"
         end
       end
-
     end # SearchContext
   end # WebDriver
 end # Selenium

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

@@ -0,0 +1,219 @@
+# 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
+    #
+    # Base class implementing default behavior of service object,
+    # responsible for starting and stopping driver implementations.
+    #
+
+    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
+
+        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
+
+        def ie(**opts)
+          IE::Service.new(**opts)
+        end
+        alias_method :internet_explorer, :ie
+
+        def edge(**opts)
+          Edge::Service.new(**opts)
+        end
+
+        def safari(**opts)
+          Safari::Service.new(**opts)
+        end
+
+        def driver_path=(path)
+          Platform.assert_executable path if path.is_a?(String)
+          @driver_path = path
+        end
+      end
+
+      attr_accessor :host
+      attr_reader :executable_path
+
+      #
+      # End users should use a class method for the desired driver, rather than using this directly.
+      #
+      # @api private
+      #
+
+      def initialize(path: nil, port: nil, args: nil)
+        path ||= self.class.driver_path
+        port ||= self.class.default_port
+        args ||= []
+
+        @executable_path = binary_path(path)
+        @host = Platform.localhost
+        @port = Integer(port)
+
+        @extra_args = args.is_a?(Hash) ? extract_service_args(args) : args
+
+        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
+      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
+      end
+
+      def uri
+        @uri ||= URI.parse("http://#{@host}:#{@port}")
+      end
+
+      private
+
+      def binary_path(path = nil)
+        path = path.call if path.is_a?(Proc)
+        path ||= Platform.find_binary(self.class.executable)
+
+        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

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

@@ -1,5 +1,5 @@
-# encoding: utf-8
-#
+# 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
@@ -19,13 +19,11 @@
 
 module Selenium
   module WebDriver
-
     #
     # @api private
     #
 
     class SocketLock
-
       def initialize(port, timeout)
         @port    = port
         @timeout = timeout
@@ -36,7 +34,7 @@ module Selenium
       # execution block if the lock could be successfully obtained.
       #
 
-      def locked(&blk)
+      def locked
         lock
 
         begin
@@ -49,19 +47,21 @@ module Selenium
       private
 
       def lock
-        max_time = Time.now + @timeout
+        max_time = current_time + @timeout
 
-        until can_lock? || Time.now >= max_time
-          sleep 0.1
-        end
+        sleep 0.1 until can_lock? || current_time >= max_time
 
-        unless did_lock?
-          raise Error::WebDriverError, "unable to bind to locking port #{@port} within #{@timeout} seconds"
-        end
+        return if did_lock?
+
+        raise Error::WebDriverError, "unable to bind to locking port #{@port} within #{@timeout} seconds"
+      end
+
+      def current_time
+        Process.clock_gettime(Process::CLOCK_MONOTONIC)
       end
 
       def release
-        @server && @server.close
+        @server&.close
       end
 
       def can_lock?
@@ -70,14 +70,13 @@ module Selenium
 
         true
       rescue SocketError, Errno::EADDRINUSE, Errno::EBADF => ex
-        $stderr.puts "#{self}: #{ex.message}" if $DEBUG
+        WebDriver.logger.debug("#{self}: #{ex.message}")
         false
       end
 
       def did_lock?
-        !!@server
+        !@server.nil?
       end
-
     end # SocketLock
   end # WebDriver
 end # Selenium