selenium-webdriver 3.142.7 → 4.10.0

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

@@ -0,0 +1,125 @@
+# 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.
+
+require 'open3'
+
+module Selenium
+  module WebDriver
+    #
+    # Wrapper for getting information from the Selenium Manager binaries.
+    # This implementation is still in beta, and may change.
+    # @api private
+    #
+    class SeleniumManager
+      class << self
+        attr_writer :bin_path
+
+        def bin_path
+          @bin_path ||= '../../../../../bin'
+        end
+
+        # @param [Options] options browser options.
+        # @return [String] the path to the correct driver.
+        def driver_path(options)
+          message = 'applicable driver not found; attempting to install with Selenium Manager (Beta)'
+          WebDriver.logger.debug(message, id: :selenium_manager)
+
+          command = generate_command(binary, options)
+
+          location = run(*command)
+          WebDriver.logger.debug("Driver found at #{location}", id: :selenium_manager)
+          Platform.assert_executable location
+
+          location
+        end
+
+        private
+
+        def generate_command(binary, options)
+          command = [binary, '--browser', options.browser_name, '--output', 'json']
+          if options.browser_version
+            command << '--browser-version'
+            command << options.browser_version
+          end
+          if options.respond_to?(:binary) && !options.binary.nil?
+            command << '--browser-path'
+            command << options.binary.gsub('\\', '\\\\\\')
+          end
+          if options.proxy
+            command << '--proxy'
+            (command << options.proxy.ssl) || options.proxy.http
+          end
+          command << '--debug' if WebDriver.logger.debug?
+          command
+        end
+
+        # @return [String] the path to the correct selenium manager
+        def binary
+          @binary ||= begin
+            path = File.expand_path(bin_path, __FILE__)
+            path << if Platform.windows?
+                      '/windows/selenium-manager.exe'
+                    elsif Platform.mac?
+                      '/macos/selenium-manager'
+                    elsif Platform.linux?
+                      '/linux/selenium-manager'
+                    end
+            location = File.expand_path(path, __FILE__)
+
+            begin
+              Platform.assert_file(location)
+              Platform.assert_executable(location)
+            rescue TypeError
+              raise Error::WebDriverError,
+                    "Unable to locate or obtain Selenium Manager binary; #{location} is not a valid file object"
+            rescue Error::WebDriverError => e
+              raise Error::WebDriverError, "Selenium Manager binary located, but #{e.message}"
+            end
+
+            WebDriver.logger.debug("Selenium Manager binary found at #{location}", id: :selenium_manager)
+            location
+          end
+        end
+
+        def run(*command)
+          WebDriver.logger.debug("Executing Process #{command}", id: :selenium_manager)
+
+          begin
+            stdout, stderr, status = Open3.capture3(*command)
+            json_output = stdout.empty? ? nil : JSON.parse(stdout)
+            result = json_output&.dig('result', 'message')
+          rescue StandardError => e
+            raise Error::WebDriverError, "Unsuccessful command executed: #{command}; #{e.message}"
+          end
+
+          (json_output&.fetch('logs') || []).each do |log|
+            level = log['level'].casecmp('info').zero? ? 'debug' : log['level'].downcase
+            WebDriver.logger.send(level, log['message'], id: :selenium_manager)
+          end
+
+          if status.exitstatus.positive?
+            raise Error::WebDriverError, "Unsuccessful command executed: #{command}\n#{result}#{stderr}"
+          end
+
+          result
+        end
+      end
+    end # SeleniumManager
+  end # WebDriver
+end # Selenium

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

@@ -21,51 +21,31 @@ 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
 
         def ie(**opts)
           IE::Service.new(**opts)
         end
-        alias_method :internet_explorer, :ie
+        alias internet_explorer ie
 
         def edge(**opts)
           Edge::Service.new(**opts)
         end
+        alias microsoftedge edge
+        alias msedge edge
 
         def safari(**opts)
           Safari::Service.new(**opts)
@@ -77,8 +57,8 @@ module Selenium
         end
       end
 
-      attr_accessor :host
-      attr_reader :executable_path
+      attr_accessor :host, :executable_path, :port, :log, :args
+      alias extra_args args
 
       #
       # End users should use a class method for the desired driver, rather than using this directly.
@@ -86,134 +66,43 @@ module Selenium
       # @api private
       #
 
-      def initialize(path: nil, port: nil, args: nil)
-        path ||= self.class.driver_path
-        port ||= self.class.default_port
+      def initialize(path: nil, port: nil, log: nil, args: nil)
+        port ||= self.class::DEFAULT_PORT
         args ||= []
 
-        @executable_path = binary_path(path)
+        @executable_path = path
         @host = Platform.localhost
         @port = Integer(port)
+        @log = case log
+               when :stdout
+                 $stdout
+               when :stderr
+                 $stderr
+               else
+                 log
+               end
 
-        @extra_args = args.is_a?(Hash) ? extract_service_args(args) : args
+        @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?
+      def launch
+        ServiceManager.new(self).tap(&:start)
       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)
+      def shutdown_supported
+        self.class::SHUTDOWN_SUPPORTED
       end
 
       protected
 
       def extract_service_args(driver_opts)
+        WebDriver.logger.deprecate('initializing Service class with :args using Hash',
+                                   ':args parameter with an Array of String values',
+                                   id: :driver_opts)
         driver_opts.key?(:args) ? driver_opts.delete(:args) : []
       end
-
     end # Service
   end # WebDriver
 end # Selenium

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

@@ -0,0 +1,144 @@
+# 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_manager object,
+    # responsible for starting and stopping driver implementations.
+    #
+    # @api private
+    #
+    class ServiceManager
+      START_TIMEOUT = 20
+      SOCKET_LOCK_TIMEOUT = 45
+      STOP_TIMEOUT = 20
+
+      #
+      # End users should use a class method for the desired driver, rather than using this directly.
+      #
+      # @api private
+      #
+
+      def initialize(config)
+        @executable_path = config.executable_path
+        @host = Platform.localhost
+        @port = config.port
+        @extra_args = config.args
+        @io = config.log
+        @shutdown_supported = config.shutdown_supported
+
+        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 { 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 @shutdown_supported
+        return if process_exited?
+
+        stop_server
+        @process.poll_for_exit STOP_TIMEOUT
+      rescue ChildProcess::TimeoutError, Errno::ECONNREFUSED
+        nil # noop
+      ensure
+        stop_process
+      end
+
+      def uri
+        @uri ||= URI.parse("http://#{@host}:#{@port}")
+      end
+
+      private
+
+      def build_process(*command)
+        WebDriver.logger.debug("Executing Process #{command}", id: :driver_service)
+        @process = ChildProcess.build(*command)
+        @io ||= WebDriver.logger.io if WebDriver.logger.debug?
+        @process.io = @io if @io
+
+        @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)
+        @process.start
+      end
+
+      def stop_process
+        return if process_exited?
+
+        @process.stop STOP_TIMEOUT
+      end
+
+      def stop_server
+        connect_to_server do |http|
+          headers = WebDriver::Remote::Http::Common::DEFAULT_HEADERS.dup
+          http.get('/shutdown', headers)
+        end
+      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 #{@executable_path} #{@host}:#{@port}"
+      end
+
+      def socket_lock
+        @socket_lock ||= SocketLock.new(@port - 1, SOCKET_LOCK_TIMEOUT)
+      end
+    end # Service
+  end # WebDriver
+end # Selenium

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

@@ -0,0 +1,86 @@
+# 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 ShadowRoot
+      ROOT_KEY = 'shadow-6066-11e4-a52e-4f735466cecf'
+
+      include SearchContext
+
+      #
+      # Creates a new shadow root
+      #
+      # @api private
+      #
+
+      def initialize(bridge, id)
+        @bridge = bridge
+        @id = id
+      end
+
+      def inspect
+        format '#<%<class>s:0x%<hash>x id=%<id>s>', class: self.class, hash: hash * 2, id: @id.inspect
+      end
+
+      def ==(other)
+        other.is_a?(self.class) && ref == other.ref
+      end
+      alias eql? ==
+
+      def hash
+        [@id, @bridge].hash
+      end
+
+      #
+      # @api private
+      # @see SearchContext
+      #
+
+      def ref
+        [:shadow_root, @id]
+      end
+
+      #
+      # Convert to a ShadowRoot JSON Object for transmission over the wire.
+      # @see https://github.com/SeleniumHQ/selenium/wiki/JsonWireProtocol#basic-terms-and-concepts
+      #
+      # @api private
+      #
+
+      def to_json(*)
+        JSON.generate as_json
+      end
+
+      #
+      # For Rails 3 - http://jonathanjulian.com/2010/04/rails-to_json-or-as_json/
+      #
+      # @api private
+      #
+
+      def as_json(*)
+        {ROOT_KEY => @id}
+      end
+
+      private
+
+      attr_reader :bridge
+    end # ShadowRoot
+  end # WebDriver
+end # Selenium

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

@@ -26,6 +26,7 @@ module Selenium
     class SocketLock
       def initialize(port, timeout)
         @port    = port
+        @server  = nil
         @timeout = timeout
       end
 
@@ -66,11 +67,10 @@ module Selenium
 
       def can_lock?
         @server = TCPServer.new(Platform.localhost, @port)
-        ChildProcess.close_on_exec @server
-
+        @server.close_on_exec = true
         true
-      rescue SocketError, Errno::EADDRINUSE, Errno::EBADF => ex
-        WebDriver.logger.debug("#{self}: #{ex.message}")
+      rescue SocketError, Errno::EADDRINUSE, Errno::EBADF => e
+        WebDriver.logger.debug("#{self}: #{e.message}", id: :driver_service)
         false
       end
 

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

@@ -66,8 +66,8 @@ module Selenium
       }.freeze
 
       if Platform.jruby?
-        # we use a plain TCPSocket here since JRuby has issues select()ing on a connecting socket
-        # see http://jira.codehaus.org/browse/JRUBY-5165
+        # we use a plain TCPSocket here since JRuby has issues closing socket
+        # see https://github.com/jruby/jruby/issues/5709
         def listening?
           TCPSocket.new(@host, @port).close
           true
@@ -93,13 +93,13 @@ module Selenium
           true
         rescue *NOT_CONNECTED_ERRORS
           sock&.close
-          WebDriver.logger.debug("polling for socket on #{[@host, @port].inspect}")
+          WebDriver.logger.debug("polling for socket on #{[@host, @port].inspect}", id: :driver_service)
           false
         end
       end
 
       def socket_writable?(sock)
-        IO.select(nil, [sock], nil, CONNECT_TIMEOUT)
+        sock.wait_writable(CONNECT_TIMEOUT)
       end
 
       def conn_completed?(sock)

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

@@ -0,0 +1,65 @@
+# 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
+    #
+    # @api private
+    #
+    module TakesScreenshot
+      #
+      # Save a PNG screenshot of the viewport to the given path
+      #
+      # @api public
+      #
+
+      def save_screenshot(png_path, full_page: false)
+        extension = File.extname(png_path).downcase
+        if extension != '.png'
+          WebDriver.logger.warn 'name used for saved screenshot does not match file type. ' \
+                                'It should end with .png extension',
+                                id: :screenshot
+        end
+        File.open(png_path, 'wb') { |f| f << screenshot_as(:png, full_page: full_page) }
+      end
+
+      #
+      # Return a PNG screenshot in the given format as a string
+      #
+      # @param [:base64, :png] format
+      # @param [Boolean] full_page allows taking full page screenshots if supported
+      # @return String screenshot
+      #
+      # @api public
+
+      def screenshot_as(format, full_page: false)
+        case format
+        when :base64
+          full_page ? full_screenshot : screenshot
+        when :png
+          screenshot_as(:base64, full_page: full_page).unpack1('m')
+        else
+          raise Error::UnsupportedOperationError, "unsupported format: #{format.inspect}"
+        end
+      rescue NameError
+        raise Error::UnsupportedOperationError, "Full Page Screenshots are not supported for #{inspect}"
+      end
+    end # TakesScreenshot
+  end # WebDriver
+end # Selenium