selenium-webdriver 3.142.7 → 4.10.0

data/lib/selenium/webdriver/common/driver_extensions/has_launching.rb

@@ -0,0 +1,36 @@
+# 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
+    module DriverExtensions
+      module HasLaunching
+        #
+        # Launches Chromium app specified by id.
+        #
+        # @param [String] id
+        #
+
+        def launch_app(id)
+          @bridge.launch_app(id)
+        end
+      end # HasLaunching
+    end # DriverExtensions
+  end # WebDriver
+end # Selenium

data/lib/selenium/webdriver/common/driver_extensions/has_location.rb

@@ -17,23 +17,19 @@
 # specific language governing permissions and limitations
 # under the License.
 
+# TODO: Deprecated; Delete after 4.0 release
 module Selenium
   module WebDriver
     module DriverExtensions
       module HasLocation
         def location
-          @bridge.location
+          raise Error::UnsupportedOperationError, 'The W3C standard does not currently support getting location'
         end
 
-        def location=(loc)
-          raise TypeError, "expected #{Location}, got #{loc.inspect}:#{loc.class}" unless loc.is_a?(Location)
-
-          @bridge.set_location loc.latitude, loc.longitude, loc.altitude
-        end
-
-        def set_location(lat, lon, alt)
-          self.location = Location.new(Float(lat), Float(lon), Float(alt))
+        def location=(*)
+          raise Error::UnsupportedOperationError, 'The W3C standard does not currently support setting location'
         end
+        alias set_location location
       end # HasLocation
     end # DriverExtensions
   end # WebDriver

data/lib/selenium/webdriver/common/driver_extensions/has_log_events.rb

@@ -0,0 +1,143 @@
+# 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
+    module DriverExtensions
+      module HasLogEvents
+        include Atoms
+
+        KINDS = %i[console exception mutation].freeze
+
+        #
+        # Registers listener to be called whenever browser receives
+        # a new Console API message such as console.log() or an unhandled
+        # exception.
+        #
+        # This currently relies on DevTools so is only supported in
+        # Chromium browsers.
+        #
+        # @example Collect console messages
+        #   logs = []
+        #   driver.on_log_event(:console) do |event|
+        #     logs.push(event)
+        #   end
+        #
+        # @example Collect JavaScript exceptions
+        #   exceptions = []
+        #   driver.on_log_event(:exception) do |event|
+        #     exceptions.push(event)
+        #   end
+        #
+        # @example Collect DOM mutations
+        #   mutations = []
+        #   driver.on_log_event(:mutation) do |event|
+        #     mutations.push(event)
+        #   end
+        #
+        # @param [Symbol] kind :console, :exception or :mutation
+        # @param [#call] block which is called when event happens
+        # @yieldparam [DevTools::ConsoleEvent, DevTools::ExceptionEvent, DevTools::MutationEvent]
+        #
+
+        def on_log_event(kind, &block)
+          raise Error::WebDriverError, "Don't know how to handle #{kind} events" unless KINDS.include?(kind)
+
+          enabled = log_listeners[kind].any?
+          log_listeners[kind] << block
+          return if enabled
+
+          devtools.runtime.enable
+          __send__("log_#{kind}_events")
+        end
+
+        private
+
+        def log_listeners
+          @log_listeners ||= Hash.new { |listeners, kind| listeners[kind] = [] }
+        end
+
+        def log_console_events
+          devtools.runtime.on(:console_api_called) do |params|
+            event = DevTools::ConsoleEvent.new(
+              type: params['type'],
+              timestamp: params['timestamp'],
+              args: params['args']
+            )
+
+            log_listeners[:console].each do |listener|
+              listener.call(event)
+            end
+          end
+        end
+
+        def log_exception_events
+          devtools.runtime.on(:exception_thrown) do |params|
+            description = if params.dig('exceptionDetails', 'exception')
+                            params.dig('exceptionDetails', 'exception', 'description')
+                          else
+                            params.dig('exceptionDetails', 'text')
+                          end
+
+            event = DevTools::ExceptionEvent.new(
+              description: description,
+              timestamp: params['timestamp'],
+              stacktrace: params.dig('exceptionDetails', 'stackTrace', 'callFrames')
+            )
+
+            log_listeners[:exception].each do |listener|
+              listener.call(event)
+            end
+          end
+        end
+
+        def log_mutation_events
+          devtools.page.enable
+
+          devtools.runtime.add_binding(name: '__webdriver_attribute')
+          execute_script(mutation_listener)
+          devtools.page.add_script_to_evaluate_on_new_document(source: mutation_listener)
+
+          devtools.runtime.on(:binding_called) { |event| log_mutation_event(event) }
+        end
+
+        def log_mutation_event(params)
+          payload = JSON.parse(params['payload'])
+          elements = find_elements(css: "*[data-__webdriver_id='#{payload['target']}']")
+          return if elements.empty?
+
+          event = DevTools::MutationEvent.new(
+            element: elements.first,
+            attribute_name: payload['name'],
+            current_value: payload['value'],
+            old_value: payload['oldValue']
+          )
+
+          log_listeners[:mutation].each do |log_listener|
+            log_listener.call(event)
+          end
+        end
+
+        def mutation_listener
+          @mutation_listener ||= read_atom(:mutationListener)
+        end
+      end # HasLogEvents
+    end # DriverExtensions
+  end # WebDriver
+end # Selenium

data/lib/selenium/webdriver/common/driver_extensions/{has_remote_status.rb → has_logs.rb}

@@ -20,11 +20,11 @@
 module Selenium
   module WebDriver
     module DriverExtensions
-      module HasRemoteStatus
-        def remote_status
-          @bridge.status
+      module HasLogs
+        def logs
+          @logs ||= Logs.new(@bridge)
         end
-      end # HasRemoteStatus
+      end # HasLogs
     end # DriverExtensions
   end # WebDriver
 end # Selenium

data/lib/selenium/webdriver/common/driver_extensions/has_network_conditions.rb

@@ -21,7 +21,6 @@ module Selenium
   module WebDriver
     module DriverExtensions
       module HasNetworkConditions
-
         #
         # Returns network conditions.
         #
@@ -38,13 +37,29 @@ module Selenium
         # @param [Hash] conditions
         # @option conditions [Integer] :latency
         # @option conditions [Integer] :throughput
+        # @option conditions [Integer] :upload_throughput
+        # @option conditions [Integer] :download_throughput
         # @option conditions [Boolean] :offline
         #
 
         def network_conditions=(conditions)
+          conditions[:latency] ||= 0
+          unless conditions.key?(:throughput)
+            conditions[:download_throughput] ||= -1
+            conditions[:upload_throughput] ||= -1
+          end
+          conditions[:offline] = false unless conditions.key?(:offline)
+
           @bridge.network_conditions = conditions
         end
 
+        #
+        # Resets Chromium network emulation settings.
+        #
+
+        def delete_network_conditions
+          @bridge.delete_network_conditions
+        end
       end # HasNetworkConditions
     end # DriverExtensions
   end # WebDriver

data/lib/selenium/webdriver/common/driver_extensions/has_network_connection.rb

@@ -17,40 +17,19 @@
 # specific language governing permissions and limitations
 # under the License.
 
+# TODO: Deprecated; Delete after 4.0 release
 module Selenium
   module WebDriver
     module DriverExtensions
       module HasNetworkConnection
         def network_connection_type
-          connection_value = @bridge.network_connection
-
-          connection_type = values_to_type[connection_value]
-
-          # In case the connection type is not recognized return the
-          # connection value.
-          connection_type || connection_value
-        end
-
-        def network_connection_type=(connection_type)
-          raise ArgumentError, 'Invalid connection type' unless valid_type? connection_type
-
-          connection_value = type_to_values[connection_type]
-
-          @bridge.network_connection = connection_value
-        end
-
-        private
-
-        def type_to_values
-          {airplane_mode: 1, wifi: 2, data: 4, all: 6, none: 0}
-        end
-
-        def values_to_type
-          type_to_values.invert
+          raise Error::UnsupportedOperationError,
+                'The W3C standard does not currently support getting network connection'
         end
 
-        def valid_type?(type)
-          type_to_values.key? type
+        def network_connection_type=(*)
+          raise Error::UnsupportedOperationError,
+                'The W3C standard does not currently support setting network connection'
         end
       end # HasNetworkConnection
     end # DriverExtensions

data/lib/selenium/webdriver/common/driver_extensions/has_network_interception.rb

@@ -0,0 +1,69 @@
+# 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
+    module DriverExtensions
+      module HasNetworkInterception
+        #
+        # Intercepts requests coming from browser allowing
+        # to either pass them through like proxy or provide
+        # a stubbed response instead.
+        #
+        # @example Log requests and pass through
+        #   driver.intercept do |request, &continue|
+        #     puts "#{request.method} #{request.url}"
+        #     continue.call(request)
+        #   end
+        #
+        # @example Stub requests for images
+        #   driver.intercept do |request, &continue|
+        #     if request.url.match?(/\.png$/)
+        #       request.url = 'https://upload.wikimedia.org/wikipedia/commons/d/d5/Selenium_Logo.png'
+        #     end
+        #     continue.call(request)
+        #   end
+        #
+        # @example Log responses and pass through
+        #   driver.intercept do |request, &continue|
+        #     continue.call(request) do |response|
+        #       puts "#{response.code} #{response.body}"
+        #     end
+        #   end
+        #
+        # @example Mutate specific response
+        #   driver.intercept do |request, &continue|
+        #     continue.call(request) do |response|
+        #       response.body << 'Added by Selenium!' if request.url.include?('/myurl')
+        #     end
+        #   end
+        #
+        # @param [Proc] block which is called when request is intercepted
+        # @yieldparam [DevTools::Request] request
+        # @yieldparam [Proc] continue block which proceeds with the request and optionally yields response
+        #
+
+        def intercept(&block)
+          @interceptor ||= DevTools::NetworkInterceptor.new(devtools)
+          @interceptor.intercept(&block)
+        end
+      end # HasNetworkInterception
+    end # DriverExtensions
+  end # WebDriver
+end # Selenium

data/lib/selenium/webdriver/common/driver_extensions/has_permissions.rb

@@ -21,30 +21,28 @@ module Selenium
   module WebDriver
     module DriverExtensions
       module HasPermissions
-
         #
-        # Returns permissions.
+        # Set one permission.
         #
-        # @return [Hash]
+        # @param [String] name which permission to set
+        # @param [String] value what to set the permission to
         #
 
-        def permissions
-          @bridge.permissions
+        def add_permission(name, value)
+          @bridge.set_permission(name, value)
         end
 
         #
-        # Sets permissions.
-        #
-        # @example
-        #   driver.permissions = {'getUserMedia' => true}
+        # Set multiple permissions.
         #
-        # @param [Hash<Symbol, Boolean>] permissions
+        # @param [Hash] opt key/value pairs to set permissions
         #
 
-        def permissions=(permissions)
-          @bridge.permissions = permissions
+        def add_permissions(opt)
+          opt.each do |key, value|
+            @bridge.set_permission(key, value)
+          end
         end
-
       end # HasPermissions
     end # DriverExtensions
   end # WebDriver

data/lib/selenium/webdriver/common/driver_extensions/has_pinned_scripts.rb

@@ -0,0 +1,75 @@
+# 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
+    module DriverExtensions
+      module HasPinnedScripts
+        #
+        # Returns the list of all pinned scripts.
+        #
+        # @return [Array<DevTools::PinnedScript>]
+        #
+
+        def pinned_scripts
+          @pinned_scripts ||= []
+        end
+
+        #
+        # Pins JavaScript snippet that is available during the whole
+        # session on every page. This allows to store and call
+        # scripts without sending them over the wire every time.
+        #
+        # @example
+        #   script = driver.pin_script('return window.location.href')
+        #   driver.execute_script(script)
+        #   # navigate to a new page
+        #   driver.execute_script(script)
+        #
+        # @param [String] script
+        # @return [DevTools::PinnedScript]
+        #
+
+        def pin_script(script)
+          script = DevTools::PinnedScript.new(script)
+          pinned_scripts << script
+
+          devtools.page.enable
+          devtools.runtime.evaluate(expression: script.callable)
+          response = devtools.page.add_script_to_evaluate_on_new_document(source: script.callable)
+          script.devtools_identifier = response.dig('result', 'identifier')
+
+          script
+        end
+
+        #
+        # Unpins script making it undefined for the subsequent calls.
+        #
+        # @param [DevTools::PinnedScript] script
+        #
+
+        def unpin_script(script)
+          devtools.runtime.evaluate(expression: script.remove)
+          devtools.page.remove_script_to_evaluate_on_new_document(identifier: script.devtools_identifier)
+          pinned_scripts.delete(script)
+        end
+      end # HasPinnedScripts
+    end # DriverExtensions
+  end # WebDriver
+end # Selenium

data/lib/selenium/webdriver/common/driver_extensions/{rotatable.rb → prints_page.rb}

@@ -19,43 +19,41 @@
 
 module Selenium
   module WebDriver
-    #
-    # @api private
-    #
-
     module DriverExtensions
-      module Rotatable
-        ORIENTATIONS = %i[landscape portrait].freeze
-
+      module PrintsPage
+        #
+        # Save a page as a PDF to the given path
         #
-        # Change the screen orientation
+        # @example Save Printed Page
+        #   driver.save_print_page('../printed_page.pdf')
         #
-        # @param [:landscape, :portrait] orientation
+        # @param [String] path to where the pdf should be saved
         #
         # @api public
         #
 
-        def rotation=(orientation)
-          unless ORIENTATIONS.include?(orientation)
-            raise ArgumentError, "expected #{ORIENTATIONS.inspect}, got #{orientation.inspect}"
+        def save_print_page(path, **options)
+          File.open(path, 'wb') do |file|
+            content = Base64.decode64 print_page(**options)
+            file << content
           end
-
-          bridge.screen_orientation = orientation.to_s.upcase
         end
-        alias_method :rotate, :rotation=
 
         #
-        # Get the current screen orientation
+        # Return a Base64 encoded Print Page as a string
         #
-        # @return [:landscape, :portrait] orientation
+        # @see https://w3c.github.io/webdriver/#print-page
         #
         # @api public
         #
 
-        def orientation
-          bridge.screen_orientation.to_sym.downcase
+        def print_page(**options)
+          options[:pageRanges] = Array(options.delete(:page_ranges)) || []
+          options[:shrinkToFit] = options.delete(:shrink_to_fit) { true }
+
+          @bridge.print_page(options)
         end
-      end # Rotatable
+      end # PrintsPage
     end # DriverExtensions
   end # WebDriver
 end # Selenium

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

@@ -0,0 +1,47 @@
+# 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 DriverFinder
+      def self.path(options, klass)
+        path = klass.driver_path
+        path = path.call if path.is_a?(Proc)
+        path ||= Platform.find_binary(klass::EXECUTABLE)
+
+        path ||= begin
+          SeleniumManager.driver_path(options) unless options.is_a?(Remote::Capabilities)
+        rescue StandardError => e
+          raise Error::NoSuchDriverError, "Unable to obtain #{klass::EXECUTABLE} using Selenium Manager; #{e.message}"
+        end
+
+        begin
+          Platform.assert_file(path)
+          Platform.assert_executable(path)
+        rescue TypeError
+          raise Error::NoSuchDriverError, "Unable to locate or obtain #{klass::EXECUTABLE}"
+        rescue Error::WebDriverError => e
+          raise Error::NoSuchDriverError, "#{klass::EXECUTABLE} located, but: #{e.message}"
+        end
+
+        path
+      end
+    end
+  end
+end