selenium-webdriver 4.0.0.beta1 → 4.0.0.rc1

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

@@ -65,37 +65,26 @@ module Selenium
         arr << Errno::EALREADY if Platform.wsl?
       }.freeze
 
-      if Platform.jruby?
-        # 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
-        rescue *NOT_CONNECTED_ERRORS
-          false
-        end
-      else
-        def listening?
-          addr     = Socket.getaddrinfo(@host, @port, Socket::AF_INET, Socket::SOCK_STREAM)
-          sock     = Socket.new(Socket::AF_INET, Socket::SOCK_STREAM, 0)
-          sockaddr = Socket.pack_sockaddr_in(@port, addr[0][3])
-
-          begin
-            sock.connect_nonblock sockaddr
-          rescue Errno::EINPROGRESS
-            retry if socket_writable?(sock) && conn_completed?(sock)
-            raise Errno::ECONNREFUSED
-          rescue *CONNECTED_ERRORS
-            # yay!
-          end
-
-          sock.close
-          true
-        rescue *NOT_CONNECTED_ERRORS
-          sock&.close
-          WebDriver.logger.debug("polling for socket on #{[@host, @port].inspect}")
-          false
+      def listening?
+        addr     = Socket.getaddrinfo(@host, @port, Socket::AF_INET, Socket::SOCK_STREAM)
+        sock     = Socket.new(Socket::AF_INET, Socket::SOCK_STREAM, 0)
+        sockaddr = Socket.pack_sockaddr_in(@port, addr[0][3])
+
+        begin
+          sock.connect_nonblock sockaddr
+        rescue Errno::EINPROGRESS
+          retry if socket_writable?(sock) && conn_completed?(sock)
+          raise Errno::ECONNREFUSED
+        rescue *CONNECTED_ERRORS
+          # yay!
         end
+
+        sock.close
+        true
+      rescue *NOT_CONNECTED_ERRORS
+        sock&.close
+        WebDriver.logger.debug("polling for socket on #{[@host, @port].inspect}")
+        false
       end
 
       def socket_writable?(sock)

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

@@ -24,38 +24,41 @@ module Selenium
     #
     module TakesScreenshot
       #
-      # Save a PNG screenshot to the given path
+      # Save a PNG screenshot of the viewport to the given path
       #
       # @api public
       #
 
-      def save_screenshot(png_path)
+      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) }
+        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)
+      def screenshot_as(format, full_page: false)
         case format
         when :base64
-          screenshot
+          full_page ? full_screenshot : screenshot
         when :png
-          screenshot.unpack1('m')
+          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

data/lib/selenium/webdriver/common.rb

@@ -57,18 +57,23 @@ require 'selenium/webdriver/common/driver_extensions/has_session_id'
 require 'selenium/webdriver/common/driver_extensions/has_remote_status'
 require 'selenium/webdriver/common/driver_extensions/has_network_conditions'
 require 'selenium/webdriver/common/driver_extensions/has_network_connection'
+require 'selenium/webdriver/common/driver_extensions/has_network_interception'
 require 'selenium/webdriver/common/driver_extensions/has_permissions'
 require 'selenium/webdriver/common/driver_extensions/has_debugger'
 require 'selenium/webdriver/common/driver_extensions/prints_page'
 require 'selenium/webdriver/common/driver_extensions/uploads_files'
+require 'selenium/webdriver/common/driver_extensions/full_page_screenshot'
 require 'selenium/webdriver/common/driver_extensions/has_addons'
 require 'selenium/webdriver/common/driver_extensions/has_devtools'
 require 'selenium/webdriver/common/driver_extensions/has_authentication'
 require 'selenium/webdriver/common/driver_extensions/has_logs'
 require 'selenium/webdriver/common/driver_extensions/has_log_events'
+require 'selenium/webdriver/common/driver_extensions/has_pinned_scripts'
+require 'selenium/webdriver/common/driver_extensions/has_cdp'
 require 'selenium/webdriver/common/keys'
 require 'selenium/webdriver/common/profile_helper'
 require 'selenium/webdriver/common/options'
 require 'selenium/webdriver/common/takes_screenshot'
 require 'selenium/webdriver/common/driver'
 require 'selenium/webdriver/common/element'
+require 'selenium/webdriver/common/shadow_root'

data/lib/selenium/webdriver/{firefox/bridge.rb → devtools/pinned_script.rb}

@@ -19,29 +19,41 @@
 
 module Selenium
   module WebDriver
-    module Firefox
-      class Bridge < WebDriver::Remote::Bridge
+    class DevTools
+      class PinnedScript
 
-        COMMANDS = {
-          install_addon: [:post, 'session/:session_id/moz/addon/install'],
-          uninstall_addon: [:post, 'session/:session_id/moz/addon/uninstall']
-        }.freeze
+        attr_accessor :key, :devtools_identifier, :script
 
-        def commands(command)
-          COMMANDS[command] || super
+        def initialize(script)
+          @key = SecureRandom.alphanumeric
+          @script = script
         end
 
-        def install_addon(path, temporary)
-          payload = {path: path}
-          payload[:temporary] = temporary unless temporary.nil?
-          execute :install_addon, {}, payload
+        #
+        # @api private
+        #
+
+        def callable
+          "function __webdriver_#{key}(arguments) { #{script} }"
         end
 
-        def uninstall_addon(id)
-          execute :uninstall_addon, {}, {id: id}
+        #
+        # @api private
+        #
+
+        def to_json(*)
+          %{"return __webdriver_#{key}(arguments)"}
+        end
+
+        #
+        # @api private
+        #
+
+        def remove
+          "__webdriver_#{key} = undefined"
         end
 
-      end # Bridge
-    end # Firefox
+      end # PinnedScript
+    end # DevTools
   end # WebDriver
 end # Selenium

data/lib/selenium/webdriver/devtools/{v87/console.rb → request.rb}

@@ -17,43 +17,41 @@
 # specific language governing permissions and limitations
 # under the License.
 
-# This file is automatically generated. Any changes will be lost!
 module Selenium
   module WebDriver
     class DevTools
-      def console
-        @console ||= V87::Console.new(self)
-      end
-
-      module V87
-        class Console
-          EVENTS = {
-            message_added: 'messageAdded'
-          }.freeze
-
-          def initialize(devtools)
-            @devtools = devtools
-          end
-
-          def on(event, &block)
-            event = EVENTS[event] if event.is_a?(Symbol)
-            @devtools.callbacks["Console.#{event}"] << block
-          end
-
-          def clear_messages
-            @devtools.send_cmd('Console.clearMessages')
-          end
-
-          def disable
-            @devtools.send_cmd('Console.disable')
-          end
-
-          def enable
-            @devtools.send_cmd('Console.enable')
-          end
-
-        end # V87
-      end # Console
+      class Request
+
+        attr_reader :url, :method, :headers
+
+        def initialize(devtools:, id:, url:, method:, headers:)
+          @devtools = devtools
+          @id = id
+          @url = url
+          @method = method
+          @headers = headers
+        end
+
+        def continue
+          @devtools.fetch.continue_request(request_id: @id)
+        end
+
+        def respond(code: 200, headers: {}, body: '')
+          @devtools.fetch.fulfill_request(
+            request_id: @id,
+            body: Base64.strict_encode64(body),
+            response_code: code,
+            response_headers: headers.map do |k, v|
+              {name: k, value: v}
+            end
+          )
+        end
+
+        def inspect
+          %(#<#{self.class.name} @method="#{method}" @url="#{url}")
+        end
+
+      end # Request
     end # DevTools
   end # WebDriver
 end # Selenium

data/lib/selenium/webdriver/devtools.rb

@@ -23,19 +23,17 @@ module Selenium
       autoload :ConsoleEvent, 'selenium/webdriver/devtools/console_event'
       autoload :ExceptionEvent, 'selenium/webdriver/devtools/exception_event'
       autoload :MutationEvent, 'selenium/webdriver/devtools/mutation_event'
+      autoload :PinnedScript, 'selenium/webdriver/devtools/pinned_script'
+      autoload :Request, 'selenium/webdriver/devtools/request'
 
-      SUPPORTED_VERSIONS = [85, 86, 87, 88].freeze
-
-      def initialize(url:, version:)
+      def initialize(url:)
         @messages = []
-        @uri = URI("http://#{url}")
+        @session_id = nil
+        @url = url
 
-        load_devtools_version(version)
         process_handshake
         attach_socket_listener
-
-        target.attach_to_target(target_id: page_target['id'])
-        target.set_auto_attach(auto_attach: true, wait_for_debugger_on_start: false)
+        start_session
       end
 
       def callbacks
@@ -44,7 +42,9 @@ module Selenium
 
       def send_cmd(method, **params)
         id = next_id
-        data = JSON.generate(id: id, method: method, params: params.reject { |_, v| v.nil? })
+        data = {id: id, method: method, params: params.reject { |_, v| v.nil? }}
+        data[:sessionId] = @session_id if @session_id
+        data = JSON.generate(data)
         WebDriver.logger.debug "DevTools -> #{data}"
 
         out_frame = WebSocket::Frame::Outgoing::Client.new(version: ws.version, data: data, type: 'text')
@@ -59,16 +59,26 @@ module Selenium
         message
       end
 
-      private
+      def method_missing(method, *_args)
+        desired_class = "Selenium::DevTools::V#{Selenium::DevTools.version}::#{method.capitalize}"
+        return unless Object.const_defined?(desired_class)
 
-      def load_devtools_version(version)
-        closest_version = SUPPORTED_VERSIONS.min_by { |v| (version - v).abs }
-        WebDriver.logger.info("Loading DevTools::V#{closest_version} for #{version}.")
-        Dir["#{__dir__}/devtools/v#{closest_version}/*"].sort.each do |f|
-          require f
+        self.class.class_eval do
+          define_method(method) do
+            Object.const_get(desired_class).new(self)
+          end
         end
+
+        send(method)
+      end
+
+      def respond_to_missing?(method, *_args)
+        desired_class = "Selenium::DevTools::V#{Selenium::DevTools.version}::#{method.capitalize}"
+        Object.const_defined?(desired_class)
       end
 
+      private
+
       def process_handshake
         socket.print(ws.to_s)
         ws << socket.readpartial(1024)
@@ -89,7 +99,8 @@ module Selenium
               next unless message['method']
 
               callbacks[message['method']].each do |callback|
-                Thread.new { callback.call(message['params']) }
+                params = message['params'] # take in current thread!
+                Thread.new { callback.call(params) }
               end
             end
           end
@@ -97,6 +108,13 @@ module Selenium
         socket_listener.abort_on_exception = true
       end
 
+      def start_session
+        targets = target.get_targets.dig('result', 'targetInfos')
+        page_target = targets.find { |target| target['type'] == 'page' }
+        session = target.attach_to_target(target_id: page_target['targetId'], flatten: true)
+        @session_id = session.dig('result', 'sessionId')
+      end
+
       def incoming_frame
         @incoming_frame ||= WebSocket::Frame::Incoming::Client.new(version: ws.version)
       end
@@ -110,15 +128,7 @@ module Selenium
       end
 
       def ws
-        @ws ||= WebSocket::Handshake::Client.new(url: page_target['webSocketDebuggerUrl'])
-      end
-
-      def page_target
-        @page_target ||= begin
-          response = Net::HTTP.get(@uri.hostname, '/json/list', @uri.port)
-          targets = JSON.parse(response)
-          targets.find { |target| target['type'] == 'page' }
-        end
+        @ws ||= WebSocket::Handshake::Client.new(url: @url)
       end
 
       def next_id

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

@@ -33,14 +33,10 @@ module Selenium
           :edge
         end
 
-        def bridge_class
-          Bridge
-        end
-
         private
 
-        def debugger_address
-          capabilities['ms:edgeOptions']['debuggerAddress']
+        def devtools_address
+          "http://#{capabilities['ms:edgeOptions']['debuggerAddress']}"
         end
       end # Driver
     end # Edge

data/lib/selenium/webdriver/edge.rb

@@ -22,7 +22,7 @@ require 'net/http'
 module Selenium
   module WebDriver
     module Edge
-      autoload :Bridge, 'selenium/webdriver/edge/bridge'
+      autoload :Features, 'selenium/webdriver/edge/features'
       autoload :Driver, 'selenium/webdriver/edge/driver'
       autoload :Profile, 'selenium/webdriver/edge/profile'
       autoload :Options, 'selenium/webdriver/edge/options'

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

@@ -27,28 +27,29 @@ module Selenium
       #
 
       class Driver < WebDriver::Driver
-        include DriverExtensions::HasAddons
-        include DriverExtensions::HasDevTools
-        include DriverExtensions::HasLogEvents
-        include DriverExtensions::HasWebStorage
-        include DriverExtensions::PrintsPage
+        EXTENSIONS = [DriverExtensions::HasAddons,
+                      DriverExtensions::FullPageScreenshot,
+                      DriverExtensions::HasDevTools,
+                      DriverExtensions::HasLogEvents,
+                      DriverExtensions::HasNetworkInterception,
+                      DriverExtensions::HasWebStorage,
+                      DriverExtensions::PrintsPage].freeze
 
         def browser
           :firefox
         end
 
-        def bridge_class
-          Bridge
-        end
-
         private
 
-        def devtools_version
-          85
+        def devtools_url
+          uri = URI("http://#{capabilities['moz:debuggerAddress']}")
+          response = Net::HTTP.get(uri.hostname, '/json/version', uri.port)
+
+          JSON.parse(response)['webSocketDebuggerUrl']
         end
 
-        def debugger_address
-          capabilities['moz:debuggerAddress']
+        def devtools_version
+          Firefox::DEVTOOLS_VERSION
         end
       end # Driver
     end # Firefox