selenium-webdriver 3.142.6 → 4.1.0

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

@@ -20,30 +20,42 @@
 module Selenium
   module WebDriver
     module Firefox
-      module Driver
-        class << self
-
-          #
-          # Instantiates correct Firefox driver implementation
-          # @return [Marionette::Driver, Legacy::Driver]
-          #
-
-          def new(**opts)
-            if marionette?(opts)
-              Firefox::Marionette::Driver.new(opts)
-            else
-              Firefox::Legacy::Driver.new(opts)
-            end
-          end
 
-          private
+      #
+      # Driver implementation for Firefox using GeckoDriver.
+      # @api private
+      #
+
+      class Driver < WebDriver::Driver
+        EXTENSIONS = [DriverExtensions::HasAddons,
+                      DriverExtensions::FullPageScreenshot,
+                      DriverExtensions::HasContext,
+                      DriverExtensions::HasDevTools,
+                      DriverExtensions::HasLogEvents,
+                      DriverExtensions::HasNetworkInterception,
+                      DriverExtensions::HasWebStorage,
+                      DriverExtensions::PrintsPage].freeze
+
+        def browser
+          :firefox
+        end
+
+        private
 
-          def marionette?(opts)
-            opts.delete(:marionette) != false &&
-              (!opts[:desired_capabilities] || opts[:desired_capabilities][:marionette] != false)
+        def devtools_url
+          if capabilities['moz:debuggerAddress'].nil?
+            raise(Error::WebDriverError, "DevTools is not supported by this version of Firefox; use v85 or higher")
           end
+
+          uri = URI("http://#{capabilities['moz:debuggerAddress']}")
+          response = Net::HTTP.get(uri.hostname, '/json/version', uri.port)
+
+          JSON.parse(response)['webSocketDebuggerUrl']
         end
 
+        def devtools_version
+          Firefox::DEVTOOLS_VERSION
+        end
       end # Driver
     end # Firefox
   end # WebDriver

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

@@ -87,6 +87,14 @@ module Selenium
           return unless File.exist?(manifest_path)
 
           manifest = JSON.parse(File.read(manifest_path))
+          applications_gecko_id(manifest) || name_and_version(manifest)
+        end
+
+        def applications_gecko_id(manifest)
+          manifest.dig('applications', 'gecko', 'id')&.strip
+        end
+
+        def name_and_version(manifest)
           [manifest['name'].delete(' '), manifest['version']].join('@')
         end
       end # Extension

data/lib/selenium/webdriver/firefox/features.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
+    module Firefox
+      module Features
+
+        FIREFOX_COMMANDS = {
+          get_context: [:get, 'session/:session_id/moz/context'],
+          set_context: [:post, 'session/:session_id/moz/context'],
+          install_addon: [:post, 'session/:session_id/moz/addon/install'],
+          uninstall_addon: [:post, 'session/:session_id/moz/addon/uninstall'],
+          full_page_screenshot: [:get, 'session/:session_id/moz/screenshot/full']
+        }.freeze
+
+        def commands(command)
+          FIREFOX_COMMANDS[command] || self.class::COMMANDS[command]
+        end
+
+        def install_addon(path, temporary)
+          if @file_detector
+            local_file = @file_detector.call(path)
+            path = upload(local_file) if local_file
+          end
+
+          payload = {path: path}
+          payload[:temporary] = temporary unless temporary.nil?
+          execute :install_addon, {}, payload
+        end
+
+        def uninstall_addon(id)
+          execute :uninstall_addon, {}, {id: id}
+        end
+
+        def full_screenshot
+          execute :full_page_screenshot
+        end
+
+        def context=(context)
+          execute :set_context, {}, {context: context}
+        end
+
+        def context
+          execute :get_context
+        end
+      end # Bridge
+    end # Firefox
+  end # WebDriver
+end # Selenium

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

@@ -20,18 +20,31 @@
 module Selenium
   module WebDriver
     module Firefox
-      class Options
-        attr_reader :args, :prefs, :options, :profile
-        attr_accessor :binary, :log_level
+      class Options < WebDriver::Options
+        attr_accessor :debugger_address
 
         KEY = 'moz:firefoxOptions'
 
+        # see: https://firefox-source-docs.mozilla.org/testing/geckodriver/Capabilities.html
+        CAPABILITIES = {binary: 'binary',
+                        args: 'args',
+                        log: 'log',
+                        prefs: 'prefs',
+                        android_package: 'androidPackage',
+                        android_activity: 'androidActivity',
+                        android_device_serial: 'androidDeviceSerial',
+                        android_intent_arguments: 'androidIntentArguments'}.freeze
+        BROWSER = 'firefox'
+
+        # NOTE: special handling of 'profile' to validate when set instead of when used
+        attr_reader :profile
+
         #
         # Create a new Options instance, only for W3C-capable versions of Firefox.
         #
         # @example
         #   options = Selenium::WebDriver::Firefox::Options.new(args: ['--host=127.0.0.1'])
-        #   driver = Selenium::WebDriver.for :firefox, options: options
+        #   driver = Selenium::WebDriver.for :firefox, capabilities: options
         #
         # @param [Hash] opts the pre-defined options to create the Firefox::Options with
         # @option opts [String] :binary Path to the Firefox executable to use
@@ -42,13 +55,16 @@ module Selenium
         # @option opts [Hash] :options A hash for raw options
         #
 
-        def initialize(**opts)
-          @args = Set.new(opts.delete(:args) || [])
-          @binary = opts.delete(:binary)
-          @profile = process_profile(opts.delete(:profile))
-          @log_level = opts.delete(:log_level)
-          @prefs = opts.delete(:prefs) || {}
-          @options = opts.delete(:options) || {}
+        def initialize(log_level: nil, **opts)
+          @debugger_address = opts.delete(:debugger_address)
+
+          super(**opts)
+
+          @options[:args] ||= []
+          @options[:prefs] ||= {}
+          @options[:log] ||= {level: log_level} if log_level
+
+          process_profile(@options.delete(:profile))
         end
 
         #
@@ -62,22 +78,7 @@ module Selenium
         #
 
         def add_argument(arg)
-          @args << arg
-        end
-
-        #
-        # Add a new option not yet handled by these bindings.
-        #
-        # @example
-        #   options = Selenium::WebDriver::Firefox::Options.new
-        #   options.add_option(:foo, 'bar')
-        #
-        # @param [String, Symbol] name Name of the option
-        # @param [Boolean, String, Integer] value Value of the option
-        #
-
-        def add_option(name, value)
-          @options[name] = value
+          @options[:args] << arg
         end
 
         #
@@ -92,7 +93,7 @@ module Selenium
         #
 
         def add_preference(name, value)
-          prefs[name] = value
+          @options[:prefs][name] = value
         end
 
         #
@@ -123,38 +124,58 @@ module Selenium
         #
 
         def profile=(profile)
-          @profile = process_profile(profile)
+          process_profile(profile)
         end
 
-        #
-        # @api private
-        #
+        def log_level
+          @options.dig(:log, :level)
+        end
 
-        def as_json(*)
-          opts = @options
+        def log_level=(level)
+          @options[:log] = {level: level}
+        end
 
-          opts[:profile] = @profile.encoded if @profile
-          opts[:args] = @args.to_a if @args.any?
-          opts[:binary] = @binary if @binary
-          opts[:prefs] = @prefs unless @prefs.empty?
-          opts[:log] = {level: @log_level} if @log_level
+        #
+        # Enables mobile browser use on Android.
+        #
+        # @see https://developer.mozilla.org/en-US/docs/Web/WebDriver/Capabilities/firefoxOptions#android
+        #
+        # @param [String] package The package name of the Chrome or WebView app.
+        # @param [String] serial_number The serial number of the device on which to launch the application.
+        #   If not specified and multiple devices are attached, an error will be returned.
+        # @param [String] activity The fully qualified class name of the activity to be launched.
+        # @param [Array] intent_arguments Arguments to launch the intent with.
+        #
 
-          {KEY => opts}
+        def enable_android(package: 'org.mozilla.firefox', serial_number: nil, activity: nil, intent_arguments: nil)
+          @options[:android_package] = package
+          @options[:android_activity] = activity unless activity.nil?
+          @options[:android_device_serial] = serial_number unless serial_number.nil?
+          @options[:android_intent_arguments] = intent_arguments unless intent_arguments.nil?
         end
 
         private
 
+        def process_browser_options(browser_options)
+          browser_options['moz:debuggerAddress'] = true if @debugger_address
+          options = browser_options[KEY]
+          options['binary'] ||= Firefox.path if Firefox.path
+          options['profile'] = @profile if @profile
+        end
+
         def process_profile(profile)
-          return unless profile
-
-          case profile
-          when Profile
-            profile
-          when String
-            Profile.from_name(profile)
-          else
-            raise Error::WebDriverError, "don't know how to handle profile: #{profile.inspect}"
-          end
+          @profile = case profile
+                     when nil
+                       nil
+                     when Profile
+                       profile
+                     else
+                       Profile.from_name(profile)
+                     end
+        end
+
+        def camelize?(key)
+          key != "prefs"
         end
       end # Options
     end # Firefox

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

@@ -23,18 +23,18 @@ module Selenium
       class Profile
         include ProfileHelper
 
-        VALID_PREFERENCE_TYPES   = [TrueClass, FalseClass, Integer, Float, String].freeze
-        WEBDRIVER_EXTENSION_PATH = File.expand_path("#{WebDriver.root}/selenium/webdriver/firefox/extension/webdriver.xpi")
-        WEBDRIVER_PREFS          = {
-          native_events: 'webdriver_enable_native_events',
-          untrusted_certs: 'webdriver_accept_untrusted_certs',
-          untrusted_issuer: 'webdriver_assume_untrusted_issuer',
-          port: 'webdriver_firefox_port',
-          log_file: 'webdriver.log.file'
+        VALID_PREFERENCE_TYPES = [TrueClass, FalseClass, Integer, Float, String].freeze
+
+        DEFAULT_PREFERENCES = {
+          "browser.newtabpage.enabled" => false,
+          "browser.startup.homepage" => "about:blank",
+          "browser.usedOnWindows10.introURL" => "about:blank",
+          "network.captive-portal-service.enabled" => false,
+          "security.csp.enable" => false
         }.freeze
 
         attr_reader   :name, :log_file
-        attr_writer   :secure_ssl, :native_events, :load_no_focus_lib
+        attr_writer   :secure_ssl, :load_no_focus_lib
 
         class << self
           def ini
@@ -48,10 +48,8 @@ module Selenium
             raise Error::WebDriverError, "unable to find profile named: #{name.inspect}"
           end
 
-          def default_preferences
-            @default_preferences ||= JSON.parse(
-              File.read(File.expand_path("#{WebDriver.root}/selenium/webdriver/firefox/extension/prefs.json"))
-            ).freeze
+          def decoded(json)
+            JSON.parse(json)
           end
         end
 
@@ -70,25 +68,7 @@ module Selenium
         def initialize(model = nil)
           @model = verify_model(model)
 
-          model_prefs = read_model_prefs
-
-          if model_prefs.empty?
-            @native_events     = DEFAULT_ENABLE_NATIVE_EVENTS
-            @secure_ssl        = DEFAULT_SECURE_SSL
-            @untrusted_issuer  = DEFAULT_ASSUME_UNTRUSTED_ISSUER
-            @load_no_focus_lib = DEFAULT_LOAD_NO_FOCUS_LIB
-
-            @additional_prefs  = {}
-          else
-            # TODO: clean this up
-            @native_events     = model_prefs.delete(WEBDRIVER_PREFS[:native_events]) == 'true'
-            @secure_ssl        = model_prefs.delete(WEBDRIVER_PREFS[:untrusted_certs]) != 'true'
-            @untrusted_issuer  = model_prefs.delete(WEBDRIVER_PREFS[:untrusted_issuer]) == 'true'
-            # not stored in profile atm, so will always be false.
-            @load_no_focus_lib = model_prefs.delete(WEBDRIVER_PREFS[:load_no_focus_lib]) == 'true'
-            @additional_prefs  = model_prefs
-          end
-
+          @additional_prefs = read_model_prefs
           @extensions = {}
         end
 
@@ -116,7 +96,7 @@ module Selenium
             raise TypeError, "expected one of #{VALID_PREFERENCE_TYPES.inspect}, got #{value.inspect}:#{value.class}"
           end
 
-          if value.is_a?(String) && Util.stringified?(value)
+          if value.is_a?(String) && stringified?(value)
             raise ArgumentError, "preference values must be plain strings: #{key.inspect} => #{value.inspect}"
           end
 
@@ -132,12 +112,6 @@ module Selenium
           self[WEBDRIVER_PREFS[:log_file]] = file
         end
 
-        def add_webdriver_extension
-          return if @extensions.key?(:webdriver)
-
-          add_extension(WEBDRIVER_EXTENSION_PATH, :webdriver)
-        end
-
         #
         # Add the extension (directory, .zip or .xpi) at the given path to the profile.
         #
@@ -146,26 +120,6 @@ module Selenium
           @extensions[name] = Extension.new(path)
         end
 
-        def native_events?
-          @native_events == true
-        end
-
-        def load_no_focus_lib?
-          @load_no_focus_lib == true
-        end
-
-        def secure_ssl?
-          @secure_ssl == true
-        end
-
-        def assume_untrusted_certificate_issuer?
-          @untrusted_issuer == true
-        end
-
-        def assume_untrusted_certificate_issuer=(bool)
-          @untrusted_issuer = bool
-        end
-
         def proxy=(proxy)
           raise TypeError, "expected #{Proxy.name}, got #{proxy.inspect}:#{proxy.class}" unless proxy.is_a? Proxy
 
@@ -189,9 +143,7 @@ module Selenium
           end
         end
 
-        def encoded
-          Zipper.zip(layout_on_disk)
-        end
+        alias_method :as_json, :encoded
 
         private
 
@@ -236,17 +188,11 @@ module Selenium
         def update_user_prefs_in(directory)
           path = File.join(directory, 'user.js')
           prefs = read_user_prefs(path)
-
-          prefs.merge! self.class.default_preferences.fetch 'mutable'
-          prefs.merge! @additional_prefs
-          prefs.merge! self.class.default_preferences.fetch 'frozen'
-
-          prefs[WEBDRIVER_PREFS[:untrusted_certs]]  = !secure_ssl?
-          prefs[WEBDRIVER_PREFS[:native_events]]    = native_events?
-          prefs[WEBDRIVER_PREFS[:untrusted_issuer]] = assume_untrusted_certificate_issuer?
+          prefs.merge! self.class::DEFAULT_PREFERENCES
+          prefs.merge!(@additional_prefs)
 
           # If the user sets the home page, we should also start up there
-          prefs['startup.homepage_welcome_url'] = prefs['browser.startup.homepage']
+          prefs['startup.homepage_welcome_url'] ||= prefs['browser.startup.homepage']
 
           write_prefs prefs, path
         end
@@ -275,6 +221,10 @@ module Selenium
             end
           end
         end
+
+        def stringified?(str)
+          /^".*"$/.match?(str)
+        end
       end # Profile
     end # Firefox
   end # WebDriver

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

@@ -20,23 +20,19 @@
 module Selenium
   module WebDriver
     module Firefox
-      #
-      # @api private
-      #
-
       class Service < WebDriver::Service
-        @default_port = 4444
-        @executable = 'geckodriver'
-        @missing_text = <<~ERROR
+        DEFAULT_PORT = 4444
+        EXECUTABLE = 'geckodriver'
+        MISSING_TEXT = <<~ERROR
           Unable to find Mozilla geckodriver. Please download the server from
           https://github.com/mozilla/geckodriver/releases and place it somewhere on your PATH.
           More info at https://developer.mozilla.org/en-US/docs/Mozilla/QA/Marionette/WebDriver.
         ERROR
-        @shutdown_supported = false
+        SHUTDOWN_SUPPORTED = false
 
         private
 
-        # Note: This processing is deprecated
+        # NOTE: This processing is deprecated
         def extract_service_args(driver_opts)
           driver_args = super
           driver_opts = driver_opts.dup

data/lib/selenium/webdriver/firefox.rb

@@ -21,46 +21,48 @@ require 'timeout'
 require 'socket'
 require 'rexml/document'
 
-require 'selenium/webdriver/firefox/driver'
-
-require 'selenium/webdriver/firefox/util'
-require 'selenium/webdriver/firefox/extension'
-require 'selenium/webdriver/firefox/binary'
-require 'selenium/webdriver/firefox/profiles_ini'
-require 'selenium/webdriver/firefox/profile'
-require 'selenium/webdriver/firefox/launcher'
-require 'selenium/webdriver/firefox/legacy/driver'
-
-require 'selenium/webdriver/firefox/marionette/bridge'
-require 'selenium/webdriver/firefox/marionette/driver'
-require 'selenium/webdriver/firefox/options'
-
 module Selenium
   module WebDriver
     module Firefox
+      autoload :Extension, 'selenium/webdriver/firefox/extension'
+      autoload :ProfilesIni, 'selenium/webdriver/firefox/profiles_ini'
+      autoload :Profile, 'selenium/webdriver/firefox/profile'
+      autoload :Features, 'selenium/webdriver/firefox/features'
+      autoload :Driver, 'selenium/webdriver/firefox/driver'
+      autoload :Options, 'selenium/webdriver/firefox/options'
+      autoload :Service, 'selenium/webdriver/firefox/service'
+
       DEFAULT_PORT = 7055
-      DEFAULT_ENABLE_NATIVE_EVENTS = Platform.os == :windows
       DEFAULT_SECURE_SSL = false
       DEFAULT_ASSUME_UNTRUSTED_ISSUER = true
       DEFAULT_LOAD_NO_FOCUS_LIB = false
 
+      # Mozilla Automation Team asked to only support 85
+      # until WebDriver Bidi is available.
+      DEVTOOLS_VERSION = 85
+
       def self.driver_path=(path)
         WebDriver.logger.deprecate 'Selenium::WebDriver::Firefox#driver_path=',
-                                   'Selenium::WebDriver::Firefox::Service#driver_path='
+                                   'Selenium::WebDriver::Firefox::Service#driver_path=',
+                                   id: :driver_path
         Selenium::WebDriver::Firefox::Service.driver_path = path
       end
 
       def self.driver_path
         WebDriver.logger.deprecate 'Selenium::WebDriver::Firefox#driver_path',
-                                   'Selenium::WebDriver::Firefox::Service#driver_path'
+                                   'Selenium::WebDriver::Firefox::Service#driver_path',
+                                   id: :driver_path
         Selenium::WebDriver::Firefox::Service.driver_path
       end
 
       def self.path=(path)
-        Binary.path = path
+        Platform.assert_executable path
+        @path = path
+      end
+
+      def self.path
+        @path ||= nil
       end
     end # Firefox
   end # WebDriver
 end # Selenium
-
-require 'selenium/webdriver/firefox/service'

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

@@ -28,57 +28,11 @@ module Selenium
       #
 
       class Driver < WebDriver::Driver
-        include DriverExtensions::HasWebStorage
-        include DriverExtensions::TakesScreenshot
-
-        def initialize(opts = {})
-          opts[:desired_capabilities] = create_capabilities(opts)
-
-          opts[:url] ||= service_url(opts)
-
-          listener = opts.delete(:listener)
-          @bridge = Remote::Bridge.handshake(opts)
-          super(@bridge, listener: listener)
-        end
+        EXTENSIONS = [DriverExtensions::HasWebStorage].freeze
 
         def browser
           :internet_explorer
         end
-
-        def quit
-          super
-        ensure
-          @service&.stop
-        end
-
-        private
-
-        def create_capabilities(opts)
-          caps = opts.delete(:desired_capabilities) { Remote::Capabilities.internet_explorer }
-          options = opts.delete(:options) { Options.new }
-
-          if opts.delete(:introduce_flakiness_by_ignoring_security_domains)
-            WebDriver.logger.deprecate ':introduce_flakiness_by_ignoring_security_domains',
-                                       'Selenium::WebDriver::IE::Options#ignore_protected_mode_settings='
-            options.ignore_protected_mode_settings = true
-          end
-
-          native_events = opts.delete(:native_events)
-          unless native_events.nil?
-            WebDriver.logger.deprecate ':native_events', 'Selenium::WebDriver::IE::Options#native_events='
-            options.native_events = native_events
-          end
-
-          # Backward compatibility with older IEDriverServer versions
-          caps[:ignore_protected_mode_settings] = options.ignore_protected_mode_settings
-          caps[:native_events] = options.native_events
-
-          options = options.as_json
-          caps.merge!(options) unless options.empty?
-
-          caps
-        end
-
       end # Driver
     end # IE
   end # WebDriver