bbc-selenium-webdriver 1.17.0

data/lib/selenium/webdriver/firefox.rb

@@ -0,0 +1,37 @@
+require 'timeout'
+require 'socket'
+require 'rexml/document'
+
+require 'selenium/webdriver/firefox/util'
+require 'selenium/webdriver/firefox/extension'
+require 'selenium/webdriver/firefox/socket_lock'
+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/bridge'
+
+module Selenium
+  module WebDriver
+    module Firefox
+
+      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
+
+      def self.path=(path)
+        Binary.path = path
+      end
+
+    end
+  end
+end
+
+
+# SocketError was added in Ruby 1.8.7.
+# If it's not defined, we add it here so it can be used in rescues.
+unless defined? SocketError
+  class SocketError < IOError; end
+end

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

@@ -0,0 +1,161 @@
+module Selenium
+  module WebDriver
+    module Firefox
+
+      # @api private
+      class Binary
+
+        NO_FOCUS_LIBRARY_NAME = "x_ignore_nofocus.so"
+        NO_FOCUS_LIBRARIES    = [
+          ["#{WebDriver.root}/selenium/webdriver/firefox/native/linux/amd64/#{NO_FOCUS_LIBRARY_NAME}", "amd64/#{NO_FOCUS_LIBRARY_NAME}"],
+          ["#{WebDriver.root}/selenium/webdriver/firefox/native/linux/x86/#{NO_FOCUS_LIBRARY_NAME}", "x86/#{NO_FOCUS_LIBRARY_NAME}"],
+        ]
+
+        WAIT_TIMEOUT = 90
+        QUIT_TIMEOUT = 5
+
+        def start_with(profile, profile_path, *args)
+          profile_path = profile_path.gsub("/", "\\") if Platform.windows?
+
+          ENV['XRE_CONSOLE_LOG']           = profile.log_file if profile.log_file
+          ENV['XRE_PROFILE_PATH']          = profile_path
+          ENV['MOZ_NO_REMOTE']             = '1' # able to launch multiple instances
+          ENV['MOZ_CRASHREPORTER_DISABLE'] = '1' # disable breakpad
+          ENV['NO_EM_RESTART']             = '1' # prevent the binary from detaching from the console
+
+          if Platform.linux? && (profile.native_events? || profile.load_no_focus_lib?)
+            modify_link_library_path profile_path
+          end
+
+          execute(*args)
+          cope_with_mac_strangeness(args) if Platform.mac?
+        end
+
+        def quit
+          return unless @process
+          @process.poll_for_exit QUIT_TIMEOUT
+        rescue ChildProcess::TimeoutError
+          # ok, force quit
+          @process.stop QUIT_TIMEOUT
+        end
+
+        def wait
+          @process.poll_for_exit(WAIT_TIMEOUT) if @process
+        end
+
+        private
+
+        def execute(*extra_args)
+          args = [self.class.path, "-no-remote"] + extra_args
+          @process = ChildProcess.build(*args)
+          @process.io.inherit! if $DEBUG
+          @process.start
+        end
+
+        def cope_with_mac_strangeness(args)
+          sleep 0.3
+
+          if @process.crashed?
+            # ok, trying a restart
+            sleep 7
+            execute(*args)
+          end
+
+          # ensure we're ok
+          sleep 0.3
+          if @process.crashed?
+            raise Error::WebDriverError, "unable to start Firefox cleanly, args: #{args.inspect}"
+          end
+        end
+
+        def modify_link_library_path(profile_path)
+          paths = []
+
+          NO_FOCUS_LIBRARIES.each do |from, to|
+            dest = File.join(profile_path, to)
+            FileUtils.mkdir_p File.dirname(dest)
+            FileUtils.cp from, dest
+
+            paths << File.expand_path(File.dirname(dest))
+          end
+
+          paths += ENV['LD_LIBRARY_PATH'].to_s.split(File::PATH_SEPARATOR)
+
+          ENV['LD_LIBRARY_PATH'] = paths.uniq.join(File::PATH_SEPARATOR)
+          ENV['LD_PRELOAD']      = NO_FOCUS_LIBRARY_NAME
+        end
+
+        class << self
+
+          #
+          # @api private
+          #
+          # @see Firefox.path=
+          #
+
+          def path=(path)
+            Platform.assert_executable(path)
+            @path = path
+          end
+
+          def path
+            @path ||= case Platform.os
+                      when :macosx
+                        macosx_path
+                      when :windows
+                        windows_path
+                      when :linux, :unix
+                        Platform.find_binary("firefox3", "firefox2", "firefox") || "/usr/bin/firefox"
+                      else
+                        raise Error::WebDriverError, "unknown platform: #{Platform.os}"
+                      end
+
+            @path = Platform.cygwin_path(@path) if Platform.cygwin?
+
+            unless File.file?(@path.to_s)
+              raise Error::WebDriverError, "Could not find Firefox binary (os=#{Platform.os}). Make sure Firefox is installed or set the path manually with #{self}.path="
+            end
+
+            @path
+          end
+
+          private
+
+          def windows_path
+            windows_registry_path || likely_windows_path || Platform.find_binary("firefox")
+          end
+
+          def macosx_path
+            path = "/Applications/Firefox.app/Contents/MacOS/firefox-bin"
+            path = Platform.find_binary("firefox-bin") unless File.exist?(path)
+
+            path
+          end
+
+          def windows_registry_path
+            require 'win32/registry'
+
+            lm = Win32::Registry::HKEY_LOCAL_MACHINE
+            lm.open("SOFTWARE\\Mozilla\\Mozilla Firefox") do |reg|
+              main = lm.open("SOFTWARE\\Mozilla\\Mozilla Firefox\\#{reg.keys[0]}\\Main")
+              if entry = main.find { |key, type, data| key =~ /pathtoexe/i }
+                return entry.last
+              end
+            end
+          rescue LoadError
+            # older JRuby or IronRuby does not have win32/registry
+          rescue Win32::Registry::Error
+          end
+
+          def likely_windows_path
+            [
+              "#{ ENV['PROGRAMFILES'] || "\\Program Files" }\\Mozilla Firefox\\firefox.exe",
+              "#{ ENV['ProgramFiles(x86)'] || "\\Program Files (x86)" }\\Mozilla Firefox\\firefox.exe"
+            ].find { |path| File.executable?(path) }
+          end
+        end # class << self
+
+      end # Binary
+    end # Firefox
+  end # WebDriver
+end # Selenium

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

@@ -0,0 +1,58 @@
+module Selenium
+  module WebDriver
+    module Firefox
+
+      # @api private
+      class Bridge < Remote::Bridge
+
+        def initialize(opts = {})
+          port        = opts.delete(:port) || DEFAULT_PORT
+          profile     = opts.delete(:profile)
+          http_client = opts.delete(:http_client)
+
+          @launcher   = create_launcher(port, profile)
+
+          unless opts.empty?
+            raise ArgumentError, "unknown option#{'s' if opts.size != 1}: #{opts.inspect}"
+          end
+
+          @launcher.launch
+
+          remote_opts = {
+            :url                  => @launcher.url,
+            :desired_capabilities => Remote::Capabilities.firefox(:native_events => DEFAULT_ENABLE_NATIVE_EVENTS)
+          }
+
+          remote_opts.merge!(:http_client => http_client) if http_client
+
+          super(remote_opts)
+        end
+
+        def browser
+          :firefox
+        end
+
+        def driver_extensions
+          [
+            DriverExtensions::TakesScreenshot,
+            DriverExtensions::HasInputDevices
+          ]
+        end
+
+        def quit
+          super
+          @launcher.quit
+
+          nil
+        end
+
+        private
+
+        def create_launcher(port, profile)
+          Launcher.new Binary.new, port, profile
+        end
+
+      end # Bridge
+    end # Firefox
+  end # WebDriver
+end # Selenium

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

@@ -0,0 +1,52 @@
+module Selenium
+  module WebDriver
+    module Firefox
+
+      # @api private
+      class Extension
+        def initialize(path)
+          unless File.exist?(path)
+            raise Error::WebDriverError, "could not find extension at #{path.inspect}"
+          end
+
+          @path             = path
+          @should_reap_root = false
+        end
+
+        def write_to(extensions_dir)
+          root_dir = create_root
+          ext_path = File.join extensions_dir, read_id_from_install_rdf(root_dir)
+
+          FileUtils.rm_rf ext_path
+          FileUtils.mkdir_p File.dirname(ext_path), :mode => 0700
+          FileUtils.cp_r root_dir, ext_path
+
+          FileReaper.reap(root_dir) if @should_reap_root
+        end
+
+        private
+
+        def create_root
+          if File.directory? @path
+            @path
+          else
+            unless Zipper::EXTENSIONS.include? File.extname(@path)
+              raise Error::WebDriverError, "expected #{Zipper::EXTENSIONS.join(" or ")}, got #{@path.inspect}"
+            end
+
+            @should_reap_root = true
+            Zipper.unzip(@path)
+          end
+        end
+
+        def read_id_from_install_rdf(directory)
+          rdf_path = File.join(directory, "install.rdf")
+          doc = REXML::Document.new(File.read(rdf_path))
+
+          REXML::XPath.first(doc, "//em:id").text
+        end
+
+      end # Extension
+    end # Firefox
+  end # WebDriver
+end # Selenium

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

@@ -0,0 +1,104 @@
+module Selenium
+  module WebDriver
+    module Firefox
+
+      # @api private
+      class Launcher
+
+        SOCKET_LOCK_TIMEOUT       = 45
+        STABLE_CONNECTION_TIMEOUT = 60
+
+        def initialize(binary, port, profile = nil)
+          @binary = binary
+          @port   = Integer(port)
+
+          raise Error::WebDriverError, "invalid port: #{@port}" if @port < 1
+
+          if profile.kind_of? Profile
+            @profile = profile
+          else
+            @profile_name = profile
+            @profile = nil
+          end
+
+          @host = "127.0.0.1"
+        end
+
+        def url
+          "http://#{@host}:#{@port}/hub"
+        end
+
+        def launch
+          socket_lock.locked do
+            find_free_port
+            create_profile
+            start_silent_and_wait
+            start
+            connect_until_stable
+          end
+
+          self
+        end
+
+        def quit
+          @binary.quit
+          FileReaper.reap(@profile_dir) if @profile_dir
+        end
+
+        def find_free_port
+          @port = PortProber.above @port
+        end
+
+        def create_profile
+          fetch_profile unless @profile
+
+          @profile.add_webdriver_extension
+          @profile.port = @port
+          @profile_dir = @profile.layout_on_disk
+        end
+
+        def start
+          assert_profile
+          @binary.start_with @profile, @profile_dir, "-foreground"
+        end
+
+        def start_silent_and_wait
+          assert_profile
+
+          @binary.start_with @profile, @profile_dir, "-silent"
+          @binary.wait
+        end
+
+        def connect_until_stable
+          poller = SocketPoller.new(@host, @port, STABLE_CONNECTION_TIMEOUT)
+
+          unless poller.connected?
+            @binary.quit
+            raise Error::WebDriverError, "unable to obtain stable firefox connection in #{STABLE_CONNECTION_TIMEOUT} seconds (#{@host}:#{@port})"
+          end
+        end
+
+        def fetch_profile
+          if @profile_name
+            @profile = Profile.from_name @profile_name
+
+            unless @profile
+              raise Error::WebDriverError, "unable to find profile named: #{@profile_name.inspect}"
+            end
+          else
+            @profile = Profile.new
+          end
+        end
+
+        def assert_profile
+          raise Error::WebDriverError, "must create_profile first" unless @profile && @profile_dir
+        end
+
+        def socket_lock
+          @socket_lock ||= SocketLock.new(@port - 1, SOCKET_LOCK_TIMEOUT)
+        end
+
+      end # Launcher
+    end # Firefox
+  end # WebDriver
+end # Selenium

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

@@ -0,0 +1,315 @@
+module Selenium
+  module WebDriver
+    module Firefox
+      class Profile
+        include ProfileHelper
+
+        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'
+        }
+
+        attr_reader   :name, :log_file
+        attr_writer   :secure_ssl, :native_events, :load_no_focus_lib
+
+        class << self
+          def ini
+            @ini ||= ProfilesIni.new
+          end
+
+          def from_name(name)
+            ini[name]
+          end
+        end
+
+        #
+        # Create a new Profile instance
+        #
+        # @example User configured profile
+        #
+        #   profile = Selenium::WebDriver::Firefox::Profile.new
+        #   profile['network.proxy.http'] = 'localhost'
+        #   profile['network.proxy.http_port'] = 9090
+        #
+        #   driver = Selenium::WebDriver.for :firefox, :profile => profile
+        #
+
+        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"
+            @load_no_focus_lib = model_prefs.delete(WEBDRIVER_PREFS[:load_no_focus_lib]) == "true" # not stored in profile atm, so will always be false.
+            @additional_prefs  = model_prefs
+          end
+
+          @extensions        = {}
+        end
+
+        def layout_on_disk
+          profile_dir = @model ? create_tmp_copy(@model) : Dir.mktmpdir("webdriver-profile")
+          FileReaper << profile_dir
+
+          install_extensions(profile_dir)
+          delete_lock_files(profile_dir)
+          delete_extensions_cache(profile_dir)
+          update_user_prefs_in(profile_dir)
+
+          profile_dir
+        end
+
+
+        #
+        # Set a preference for this particular profile.
+        #
+        # @see http://kb.mozillazine.org/About:config_entries
+        # @see http://preferential.mozdev.org/preferences.html
+        #
+
+        def []=(key, value)
+          case value
+          when String
+            if Util.stringified?(value)
+              raise ArgumentError, "preference values must be plain strings: #{key.inspect} => #{value.inspect}"
+            end
+
+            value = MultiJson.encode(value)
+          when TrueClass, FalseClass, Integer, Float
+            value = value.to_s
+          else
+            raise TypeError, "invalid preference: #{value.inspect}:#{value.class}"
+          end
+
+          @additional_prefs[key.to_s] = value
+        end
+
+        def port=(port)
+          self[WEBDRIVER_PREFS[:port]] = port
+        end
+
+        def log_file=(file)
+          @log_file = file
+          self[WEBDRIVER_PREFS[:log_file]] = file
+        end
+
+        def add_webdriver_extension
+          unless @extensions.has_key?(:webdriver)
+            add_extension(WEBDRIVER_EXTENSION_PATH, :webdriver)
+          end
+        end
+
+        #
+        # Add the extension (directory, .zip or .xpi) at the given path to the profile.
+        #
+
+        def add_extension(path, name = extension_name_for(path))
+          @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)
+          unless proxy.kind_of? Proxy
+            raise TypeError, "expected #{Proxy.name}, got #{proxy.inspect}:#{proxy.class}"
+          end
+
+          case proxy.type
+          when :manual
+            self['network.proxy.type'] = 1
+
+            set_manual_proxy_preference "ftp", proxy.ftp
+            set_manual_proxy_preference "http", proxy.http
+            set_manual_proxy_preference "ssl", proxy.ssl
+
+            if proxy.no_proxy
+              self["network.proxy.no_proxies_on"] = proxy.no_proxy
+            else
+              self["network.proxy.no_proxies_on"] = ""
+            end
+          when :pac
+            self['network.proxy.type'] = 2
+            self['network.proxy.autoconfig_url'] = proxy.pac
+          when :auto_detect
+            self['network.proxy.type'] = 4
+          else
+            raise ArgumentError, "unsupported proxy type #{proxy.type}"
+          end
+
+          proxy
+        end
+
+        private
+
+        def set_manual_proxy_preference(key, value)
+          return unless value
+
+          host, port = value.to_s.split(":", 2)
+
+          self["network.proxy.#{key}"] = host
+          self["network.proxy.#{key}_port"] = Integer(port) if port
+        end
+
+        def install_extensions(directory)
+          destination = File.join(directory, "extensions")
+
+          @extensions.each do |name, extension|
+            p :extension => name if $DEBUG
+            extension.write_to(destination)
+          end
+        end
+
+        def read_model_prefs
+          return {} unless @model
+
+          read_user_prefs(File.join(@model, 'user.js'))
+        end
+
+        def delete_extensions_cache(directory)
+          FileUtils.rm_f File.join(directory, "extensions.cache")
+        end
+
+        def delete_lock_files(directory)
+          %w[.parentlock parent.lock].each do |name|
+            FileUtils.rm_f File.join(directory, name)
+          end
+        end
+
+        def extension_name_for(path)
+          File.basename(path, File.extname(path))
+        end
+
+        def update_user_prefs_in(directory)
+          path = File.join(directory, 'user.js')
+          prefs = read_user_prefs(path)
+
+          prefs.merge! DEFAULT_PREFERENCES
+          prefs.merge! @additional_prefs
+          prefs.merge! FROZEN_PREFERENCES
+
+          prefs[WEBDRIVER_PREFS[:untrusted_certs]]  = !secure_ssl?
+          prefs[WEBDRIVER_PREFS[:native_events]]    = native_events?
+          prefs[WEBDRIVER_PREFS[:untrusted_issuer]] = assume_untrusted_certificate_issuer?
+
+          # If the user sets the home page, we should also start up there
+          prefs["startup.homepage_welcome_url"] = prefs["browser.startup.homepage"]
+
+          write_prefs prefs, path
+        end
+
+        def read_user_prefs(path)
+          return {} unless File.exist?(path)
+
+          prefs = {}
+
+          File.read(path).split("\n").each do |line|
+            if line =~ /user_pref\("([^"]+)"\s*,\s*(.+?)\);/
+              prefs[$1.strip] = $2.strip
+            end
+          end
+
+          prefs
+        end
+
+        def write_prefs(prefs, path)
+          File.open(path, "w") { |file|
+            prefs.each do |key, value|
+              p key => value if $DEBUG
+              file.puts %{user_pref("#{key}", #{value});}
+            end
+          }
+        end
+
+        DEFAULT_PREFERENCES = {
+          "browser.startup.page"     => '0',
+          "browser.startup.homepage" => '"about:blank"',
+          "dom.max_script_run_time"  => '30',
+        }.freeze
+
+
+        # Profile preferences that are essential to the Firefox driver operating
+        # correctly. Users are not permitted to override these values.
+
+        FROZEN_PREFERENCES = {
+          "app.update.auto"                           => 'false',
+          "app.update.enabled"                        => 'false',
+          "browser.download.manager.showWhenStarting" => 'false',
+          "browser.EULA.override"                     => 'true',
+          "browser.EULA.3.accepted"                   => 'true',
+          "browser.link.open_external"                => '2',
+          "browser.link.open_newwindow"               => '2',
+          "browser.safebrowsing.enabled"              => 'false',
+          "browser.safebrowsing.malware.enabled"      => 'false',
+          "browser.search.update"                     => 'false',
+          "browser.sessionstore.resume_from_crash"    => 'false',
+          "browser.shell.checkDefaultBrowser"         => 'false',
+          "browser.tabs.warnOnClose"                  => 'false',
+          "browser.tabs.warnOnOpen"                   => 'false',
+          "devtools.errorconsole.enabled"             => 'true',
+          "dom.disable_open_during_load"              => 'false',
+          "extensions.autoDisableScopes"              => '10',
+          "extensions.logging.enabled"                => 'true',
+          "extensions.update.enabled"                 => 'false',
+          "extensions.update.notifyUser"              => 'false',
+          "network.manage-offline-status"             => 'false',
+          "network.http.phishy-userpass-length"       => '255',
+          "network.http.max-connections-per-server"   => '10',
+          "offline-apps.allow_by_default"             => 'true',
+          "prompts.tab_modal.enabled"                 => "false",
+          "security.warn_entering_secure"             => 'false',
+          "security.warn_submit_insecure"             => 'false',
+          "security.warn_entering_secure.show_once"   => 'false',
+          "security.warn_entering_weak"               => 'false',
+          "security.warn_entering_weak.show_once"     => 'false',
+          "security.warn_leaving_secure"              => 'false',
+          "security.warn_leaving_secure.show_once"    => 'false',
+          "security.warn_submit_insecure"             => 'false',
+          "security.warn_viewing_mixed"               => 'false',
+          "security.warn_viewing_mixed.show_once"     => 'false',
+          "signon.rememberSignons"                    => 'false',
+          "toolkit.networkmanager.disable"            => 'true',
+          "toolkit.telemetry.prompted"                => '2',
+          "toolkit.telemetry.enabled"                 => 'false',
+          "toolkit.telemetry.rejected"                => 'true',
+          "javascript.options.showInConsole"          => 'true',
+          "browser.dom.window.dump.enabled"           => 'true',
+          "dom.report_all_js_exceptions"              => "true"
+        }.freeze
+
+      end # Profile
+    end # Firefox
+  end # WebDriver
+end # Selenium