selenium-webdriver 3.142.6 → 4.1.0

data/lib/selenium/webdriver/devtools/pinned_script.rb

@@ -0,0 +1,59 @@
+# 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 DevTools
+      class PinnedScript
+
+        attr_accessor :key, :devtools_identifier, :script
+
+        def initialize(script)
+          @key = SecureRandom.alphanumeric
+          @script = script
+        end
+
+        #
+        # @api private
+        #
+
+        def callable
+          "function __webdriver_#{key}(arguments) { #{script} }"
+        end
+
+        #
+        # @api private
+        #
+
+        def to_json(*)
+          %{"return __webdriver_#{key}(arguments)"}
+        end
+
+        #
+        # @api private
+        #
+
+        def remove
+          "__webdriver_#{key} = undefined"
+        end
+
+      end # PinnedScript
+    end # DevTools
+  end # WebDriver
+end # Selenium

data/lib/selenium/webdriver/devtools/request.rb

@@ -0,0 +1,67 @@
+# 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 DevTools
+      class Request
+
+        attr_accessor :url, :method, :headers, :post_data
+        attr_reader :id
+
+        #
+        # Creates request from DevTools message.
+        # @api private
+        #
+
+        def self.from(id, params)
+          new(
+            id: id,
+            url: params.dig('request', 'url'),
+            method: params.dig('request', 'method'),
+            headers: params.dig('request', 'headers'),
+            post_data: params.dig('request', 'postData')
+          )
+        end
+
+        def initialize(id:, url:, method:, headers:, post_data:)
+          @id = id
+          @url = url
+          @method = method
+          @headers = headers
+          @post_data = post_data
+        end
+
+        def ==(other)
+          self.class == other.class &&
+            id == other.id &&
+            url == other.url &&
+            method == other.method &&
+            headers == other.headers &&
+            post_data == other.post_data
+        end
+
+        def inspect
+          %(#<#{self.class.name} @id="#{id}" @method="#{method}" @url="#{url}")
+        end
+
+      end # Request
+    end # DevTools
+  end # WebDriver
+end # Selenium

data/lib/selenium/webdriver/devtools/response.rb

@@ -0,0 +1,66 @@
+# 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 DevTools
+      class Response
+
+        attr_accessor :code, :body, :headers
+        attr_reader :id
+
+        #
+        # Creates response from DevTools message.
+        # @api private
+        #
+
+        def self.from(id, encoded_body, params)
+          new(
+            id: id,
+            code: params['responseStatusCode'],
+            body: (Base64.strict_decode64(encoded_body) if encoded_body),
+            headers: params['responseHeaders'].each_with_object({}) do |header, hash|
+              hash[header['name']] = header['value']
+            end
+          )
+        end
+
+        def initialize(id:, code:, body:, headers:)
+          @id = id
+          @code = code
+          @body = body
+          @headers = headers
+        end
+
+        def ==(other)
+          self.class == other.class &&
+            id == other.id &&
+            code == other.code &&
+            body == other.body &&
+            headers == other.headers
+        end
+
+        def inspect
+          %(#<#{self.class.name} @id="#{id}" @code="#{code}")
+        end
+
+      end # Response
+    end # DevTools
+  end # WebDriver
+end # Selenium

data/lib/selenium/webdriver/devtools.rb

@@ -0,0 +1,193 @@
+# 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 DevTools
+      RESPONSE_WAIT_TIMEOUT = 30
+      RESPONSE_WAIT_INTERVAL = 0.1
+
+      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'
+      autoload :Response, 'selenium/webdriver/devtools/response'
+
+      def initialize(url:)
+        @callback_threads = ThreadGroup.new
+
+        @messages = []
+        @session_id = nil
+        @url = url
+
+        process_handshake
+        @socket_thread = attach_socket_listener
+        start_session
+      end
+
+      def close
+        @callback_threads.list.each(&:exit)
+        @socket_thread.exit
+        socket.close
+      end
+
+      def callbacks
+        @callbacks ||= Hash.new { |callbacks, event| callbacks[event] = [] }
+      end
+
+      def send_cmd(method, **params)
+        id = next_id
+        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')
+        socket.write(out_frame.to_s)
+
+        message = wait.until do
+          @messages.find { |m| m['id'] == id }
+        end
+
+        raise Error::WebDriverError, error_message(message['error']) if message['error']
+
+        message
+      end
+
+      def method_missing(method, *_args)
+        desired_class = "Selenium::DevTools::V#{Selenium::DevTools.version}::#{method.capitalize}"
+        return unless Object.const_defined?(desired_class)
+
+        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)
+      end
+
+      def attach_socket_listener
+        Thread.new do
+          Thread.current.abort_on_exception = true
+          Thread.current.report_on_exception = false
+
+          until socket.eof?
+            incoming_frame << socket.readpartial(1024)
+
+            while (frame = incoming_frame.next)
+              message = process_frame(frame)
+              next unless message['method']
+
+              params = message['params']
+              callbacks[message['method']].each do |callback|
+                @callback_threads.add(callback_thread(params, &callback))
+              end
+            end
+          end
+        end
+      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
+
+      def process_frame(frame)
+        message = frame.to_s
+
+        # Firefox will periodically fail on unparsable empty frame
+        return {} if message.empty?
+
+        message = JSON.parse(message)
+        @messages << message
+        WebDriver.logger.debug "DevTools <- #{message}"
+
+        message
+      end
+
+      def callback_thread(params)
+        Thread.new do
+          Thread.current.abort_on_exception = true
+
+          # We might end up blocked forever when we have an error in event.
+          # For example, if network interception event raises error,
+          # the browser will keep waiting for the request to be proceeded
+          # before returning back to the original thread. In this case,
+          # we should at least print the error.
+          Thread.current.report_on_exception = true
+
+          yield params
+        end
+      end
+
+      def wait
+        @wait ||= Wait.new(timeout: RESPONSE_WAIT_TIMEOUT, interval: RESPONSE_WAIT_INTERVAL)
+      end
+
+      def socket
+        @socket ||= begin
+          if URI(@url).scheme == 'wss'
+            socket = TCPSocket.new(ws.host, ws.port)
+            socket = OpenSSL::SSL::SSLSocket.new(socket, OpenSSL::SSL::SSLContext.new)
+            socket.sync_close = true
+            socket.connect
+
+            socket
+          else
+            TCPSocket.new(ws.host, ws.port)
+          end
+        end
+      end
+
+      def ws
+        @ws ||= WebSocket::Handshake::Client.new(url: @url)
+      end
+
+      def next_id
+        @id ||= 0
+        @id += 1
+      end
+
+      def error_message(error)
+        [error['code'], error['message'], error['data']].join(': ')
+      end
+
+    end # DevTools
+  end # WebDriver
+end # Selenium

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

@@ -17,6 +17,8 @@
 # specific language governing permissions and limitations
 # under the License.
 
+require 'selenium/webdriver/chrome/driver'
+
 module Selenium
   module WebDriver
     module Edge
@@ -26,40 +28,16 @@ module Selenium
       # @api private
       #
 
-      class Driver < WebDriver::Driver
-        include DriverExtensions::TakesScreenshot
-
-        def initialize(opts = {})
-          opts[:desired_capabilities] ||= Remote::Capabilities.edge
-
-          opts[:url] ||= service_url(opts)
-
-          listener = opts.delete(:listener)
-
-          # Edge is mostly using W3C dialect, but a request to
-          # create session responds with OSS-like body,
-          # so we need to force W3C implementation.
-          desired_capabilities = opts.delete(:desired_capabilities)
-          bridge = Remote::Bridge.new(opts)
-          capabilities = bridge.create_session(desired_capabilities)
-
-          WebDriver.logger.info 'Forcing W3C dialect.'
-          @bridge = Remote::W3C::Bridge.new(capabilities, bridge.session_id, opts)
-          @bridge.extend Edge::Bridge
-
-          super(@bridge, listener: listener)
-        end
-
+      class Driver < Selenium::WebDriver::Chrome::Driver
         def browser
           :edge
         end
 
-        def quit
-          super
-        ensure
-          @service&.stop
-        end
+        private
 
+        def devtools_address
+          "http://#{capabilities['ms:edgeOptions']['debuggerAddress']}"
+        end
       end # Driver
     end # Edge
   end # WebDriver

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

@@ -0,0 +1,44 @@
+# 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 'selenium/webdriver/chrome/features'
+
+module Selenium
+  module WebDriver
+    module Edge
+      module Features
+
+        include WebDriver::Chrome::Features
+
+        EDGE_COMMANDS = {
+          get_cast_sinks: [:get, 'session/:session_id/ms/cast/get_sinks'],
+          set_cast_sink_to_use: [:post, 'session/:session_id/ms/cast/set_sink_to_use'],
+          start_cast_tab_mirroring: [:post, 'session/:session_id/ms/cast/start_tab_mirroring'],
+          get_cast_issue_message: [:get, 'session/:session_id/ms/cast/get_issue_message'],
+          stop_casting: [:post, 'session/:session_id/ms/cast/stop_casting'],
+          send_command: [:post, 'session/:session_id/ms/cdp/execute']
+        }.freeze
+
+        def commands(command)
+          EDGE_COMMANDS[command] || Chrome::Features::CHROME_COMMANDS[command] || self.class::COMMANDS[command]
+        end
+      end # Bridge
+    end # Edge
+  end # WebDriver
+end # Selenium

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

@@ -17,62 +17,25 @@
 # specific language governing permissions and limitations
 # under the License.
 
+require 'selenium/webdriver/chrome/options'
+
 module Selenium
   module WebDriver
     module Edge
-      class Options
-        attr_accessor :in_private, :start_page
-        attr_reader :extension_paths
+      class Options < Selenium::WebDriver::Chrome::Options
+        KEY = 'ms:edgeOptions'
+        BROWSER = 'MicrosoftEdge'
 
-        #
-        # Create a new Options instance for Edge.
-        #
-        # @example
-        #   options = Selenium::WebDriver::Edge::Options.new(in_private: true)
-        #   driver = Selenium::WebDriver.for :edge, options: options
-        #
-        # @param [Hash] opts the pre-defined options to create the Edge::Options with
-        # @option opts [Boolean] :in_private Start in private mode. Default is false
-        # @option opts [Array<String>] :extension_paths A list of full paths to extensions to install on startup
-        # @option opts [String] :start_page Default page to start with
-        #
-        # @see https://docs.microsoft.com/en-us/microsoft-edge/webdriver
-        #
+        protected
 
-        def initialize(**opts)
-          @in_private = opts.delete(:in_private) || false
-          @extension_paths = opts.delete(:extension_paths) || []
-          @start_page = opts.delete(:start_page)
+        def enable_logging(browser_options)
+          browser_options['ms:loggingPrefs'] = @logging_prefs
         end
 
-        #
-        # Add an extension by local path.
-        #
-        # @example
-        #   options = Selenium::WebDriver::Edge::Options.new
-        #   options.add_extension_path('C:\path\to\extension')
-        #
-        # @param [String] path The local path to the extension folder
-        #
-
-        def add_extension_path(path)
-          raise Error::WebDriverError, "could not find extension at #{path.inspect}" unless File.directory?(path)
-
-          @extension_paths << path
-        end
-
-        #
-        # @api private
-        #
-
-        def as_json(*)
-          opts = {}
-
-          opts['ms:inPrivate'] = true if @in_private
-          opts['ms:extensionPaths'] = @extension_paths if @extension_paths.any?
-          opts['ms:startPage'] = @start_page if @start_page
+        private
 
-          opts
+        def binary_path
+          Edge.path
         end
       end # Options
     end # Edge

data/lib/selenium/webdriver/{common/w3c_manager.rb → edge/profile.rb}

@@ -17,29 +17,17 @@
 # specific language governing permissions and limitations
 # under the License.
 
+require 'selenium/webdriver/chrome/profile'
+
 module Selenium
   module WebDriver
-    class W3CManager < Manager
-
-      #
-      # Get the cookie with the given name
-      #
-      # @param [String] name the name of the cookie
-      # @return [Hash, nil] the cookie, or nil if it wasn't found.
+    module Edge
       #
-
-      def cookie_named(name)
-        convert_cookie(@bridge.cookie(name))
-      end
-
+      # @private
       #
-      # Delete all cookies
-      #
-
-      def delete_all_cookies
-        @bridge.delete_all_cookies
-      end
 
-    end # WC3Options
+      class Profile < Selenium::WebDriver::Chrome::Profile
+      end # Profile
+    end # Edge
   end # WebDriver
 end # Selenium

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

@@ -17,36 +17,20 @@
 # specific language governing permissions and limitations
 # under the License.
 
+require 'selenium/webdriver/chrome/service'
+
 module Selenium
   module WebDriver
     module Edge
-      #
-      # @api private
-      #
-
-      class Service < WebDriver::Service
-        @default_port = 17556
-        @executable = 'MicrosoftWebDriver'
-        @missing_text = <<~ERROR
-          Unable to find MicrosoftWebDriver. Please download the server from
-          https://www.microsoft.com/en-us/download/details.aspx?id=48212 and place it somewhere on your PATH.
-          More info at https://github.com/SeleniumHQ/selenium/wiki/MicrosoftWebDriver.
+      class Service < Selenium::WebDriver::Chrome::Service
+        DEFAULT_PORT = 9515
+        EXECUTABLE = 'msedgedriver'
+        MISSING_TEXT = <<~ERROR
+          Unable to find msedgedriver. Please download the server from
+          https://developer.microsoft.com/en-us/microsoft-edge/tools/webdriver/ and place it somewhere on your PATH.
         ERROR
-        @shutdown_supported = true
-
-        private
-
-        # Note: This processing is deprecated
-        def extract_service_args(driver_opts)
-          driver_args = super
-          driver_opts = driver_opts.dup
-          driver_args << "--host=#{driver_opts[:host]}" if driver_opts.key? :host
-          driver_args << "--package=#{driver_opts[:package]}" if driver_opts.key? :package
-          driver_args << "--silent" if driver_opts[:silent] == true
-          driver_args << "--verbose" if driver_opts[:verbose] == true
-          driver_args
-        end
+        SHUTDOWN_SUPPORTED = true
       end # Service
     end # Edge
   end # WebDriver
-end # Service
+end # Selenium

data/lib/selenium/webdriver/edge.rb

@@ -19,26 +19,23 @@
 
 require 'net/http'
 
-require 'selenium/webdriver/edge/bridge'
-require 'selenium/webdriver/edge/driver'
-require 'selenium/webdriver/edge/options'
-
 module Selenium
   module WebDriver
     module Edge
-      def self.driver_path=(path)
-        WebDriver.logger.deprecate 'Selenium::WebDriver::Edge#driver_path=',
-                                   'Selenium::WebDriver::Edge::Service#driver_path='
-        Selenium::WebDriver::Edge::Service.driver_path = path
+      autoload :Features, 'selenium/webdriver/edge/features'
+      autoload :Driver, 'selenium/webdriver/edge/driver'
+      autoload :Profile, 'selenium/webdriver/edge/profile'
+      autoload :Options, 'selenium/webdriver/edge/options'
+      autoload :Service, 'selenium/webdriver/edge/service'
+
+      def self.path=(path)
+        Platform.assert_executable path
+        @path = path
       end
 
-      def self.driver_path
-        WebDriver.logger.deprecate 'Selenium::WebDriver::Edge#driver_path',
-                                   'Selenium::WebDriver::Edge::Service#driver_path'
-        Selenium::WebDriver::Edge::Service.driver_path
+      def self.path
+        @path ||= nil
       end
     end # Edge
   end # WebDriver
 end # Selenium
-
-require 'selenium/webdriver/edge/service'