selenium-webdriver 0.0.28 → 0.0.29

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

@@ -1,5 +1,3 @@
-require "fcntl"
-
 module Selenium
   module WebDriver
     module Firefox
@@ -10,9 +8,11 @@ module Selenium
         SOCKET_LOCK_TIMEOUT       = 45
         STABLE_CONNECTION_TIMEOUT = 60
 
-        def initialize(binary, port = DEFAULT_PORT, profile = DEFAULT_PROFILE_NAME)
+        def initialize(binary, port, profile = nil)
           @binary = binary
-          @port   = port.to_i
+          @port   = Integer(port)
+
+          raise Error::WebDriverError, "invalid port: #{@port}" if @port < 1
 
           if profile.kind_of? Profile
             @profile = profile
@@ -21,12 +21,6 @@ module Selenium
             @profile = nil
           end
 
-          # need to be really specific about what host to use
-          #
-          # on os x, "localhost" will resolve to 3 different addresses (see /etc/hosts)
-          # Ruby will loop over these and happily bind to the same port on each one,
-          # making it completely unusable for our purposes.
-          #
           @host = "127.0.0.1"
         end
 
@@ -35,7 +29,7 @@ module Selenium
         end
 
         def launch
-          with_lock do
+          socket_lock.locked do
             find_free_port
             create_profile
             start_silent_and_wait
@@ -46,28 +40,6 @@ module Selenium
           self
         end
 
-        def with_lock
-          max_time = Time.now + SOCKET_LOCK_TIMEOUT
-          locking_port = @port - 1
-
-          until Time.now > max_time
-            begin
-              socket_lock = TCPServer.new(@host, locking_port)
-              # make sure the fd is not inherited by firefox
-              socket_lock.fcntl(Fcntl::F_SETFD, Fcntl::FD_CLOEXEC) if defined? Fcntl::FD_CLOEXEC
-
-              yield
-              return
-            rescue SocketError, Errno::EADDRINUSE
-              sleep 0.1
-            end
-          end
-
-          raise Error::WebDriverError, "unable to bind to locking port #{locking_port} within #{SOCKET_LOCK_TIMEOUT} seconds"
-        ensure
-          socket_lock.close if socket_lock
-        end
-
         def find_free_port
           port = @port
 
@@ -79,47 +51,29 @@ module Selenium
         end
 
         def create_profile
-          unless @profile
-            fetch_profile
-            if @profile.nil?
-              raise Error, WebDriverError, "could not find or create profile: #{profile.inspect}"
-            end
-          end
+          fetch_profile if @profile.nil?
 
-          @profile.delete_extensions_cache
+          @profile.add_webdriver_extension
           @profile.port = @port
-          @profile.add_webdriver_extension(true)
-          @profile.update_user_prefs
+          @profile_dir = @profile.layout_on_disk
         end
 
         def start
           assert_profile
-          @binary.start_with @profile
+          @binary.start_with @profile, @profile_dir
         end
 
         def start_silent_and_wait
           assert_profile
-          @binary.start_with @profile, "--silent"
+          @binary.start_with @profile, @profile_dir, "--silent"
           @binary.wait
         end
 
         def connect_until_stable
-          max_time = Time.now + STABLE_CONNECTION_TIMEOUT
-
-          until Time.now >= max_time
-            return if can_connect?
-            sleep 0.25
+          poller = SocketPoller.new(@host, @port, STABLE_CONNECTION_TIMEOUT)
+          unless poller.success?
+            raise Error::WebDriverError, "unable to obtain stable firefox connection in #{STABLE_CONNECTION_TIMEOUT} seconds"
           end
-
-          raise Error::WebDriverError, "unable to obtain stable firefox connection in #{STABLE_CONNECTION_TIMEOUT} seconds"
-        end
-
-        def can_connect?
-          TCPSocket.new(@host, @port).close
-          true
-        rescue Errno::ECONNREFUSED, Errno::ENOTCONN, SocketError => e
-          $stderr.puts "#{e.message} for #{@host}:#{@port}" if $DEBUG
-          false
         end
 
         def free_port?(port)
@@ -131,20 +85,22 @@ module Selenium
         end
 
         def fetch_profile
-          existing = Profile.from_name @profile_name
-
-          unless existing
-            @binary.create_base_profile @profile_name
-            Profile.ini.refresh
-            existing = Profile.from_name @profile_name
-            raise Error::WebDriverError, "unable to find or create new profile" unless existing
+          if @profile_name
+            @profile = Profile.from_name @profile_name
+            if @profile.nil?
+              raise Error::WebDriverError, "unable to find profile named: #{@profile_name.inspect}"
+            end
+          else
+            @profile = Profile.new
           end
-
-          @profile = existing
         end
 
         def assert_profile
-          raise Error::WebDriverError, "must create_profile first" unless @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

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

@@ -5,12 +5,17 @@ module Selenium
 
         ANONYMOUS_PROFILE_NAME   = "WEBDRIVER_ANONYMOUS_PROFILE"
         EXTENSION_NAME           = "fxdriver@googlecode.com"
-        EM_NAMESPACE_URI         = "http://www.mozilla.org/2004/em-rdf#"
         WEBDRIVER_EXTENSION_PATH = File.expand_path("#{WebDriver.root}/selenium/webdriver/firefox/extension/webdriver.xpi")
-
-        attr_reader   :name, :directory
+        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
-        attr_accessor :port
 
         class << self
           def ini
@@ -34,23 +39,56 @@ module Selenium
         #   driver = Selenium::WebDriver.for :firefox, :profile => profile
         #
 
-        def initialize(directory = nil)
-          @directory = directory ? create_tmp_copy(directory) : Dir.mktmpdir("webdriver-profile")
+        def initialize(model = nil)
+          @model = verify_model(model)
+
+          model_prefs = read_model_prefs
 
-          unless File.directory? @directory
-            raise Error::WebDriverError, "Profile directory does not exist: #{@directory.inspect}"
+          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
+          else
+            @native_events     = model_prefs[WEBDRIVER_PREFS[:native_events]] == "true"
+            @secure_ssl        = model_prefs[WEBDRIVER_PREFS[:untrusted_certs]] != "true" # FIXME: 'untrusted_certs' vs 'secure_ssl'
+            @untrusted_issuer  = model_prefs[WEBDRIVER_PREFS[:untrusted_issuer]] == "true"
+            @load_no_focus_lib = model_prefs[WEBDRIVER_PREFS[:load_no_focus_lib]] == "true" # not stored in profile atm, so will always be false.
           end
 
-          FileReaper << @directory
+          @additional_prefs  = {}
+          @extensions        = {}
+        end
 
-          # TODO: replace constants with options hash
-          @port              = DEFAULT_PORT
-          @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
+        def layout_on_disk
+          profile_dir = @model ? create_tmp_copy(@model) : Dir.mktmpdir("webdriver-profile")
+          FileReaper << profile_dir
 
-          @additional_prefs  = {}
+          install_extensions(profile_dir)
+          delete_lock_files(profile_dir)
+          delete_extensions_cache(profile_dir)
+          update_user_prefs_in(profile_dir)
+
+          profile_dir
+        end
+
+        def as_json(opts = nil)
+          {'zip' => Zipper.zip(layout_on_disk)}
+        end
+
+        def to_json(*args)
+          as_json.to_json(*args)
+        end
+
+        def self.from_json(json)
+          zip_file = Tempfile.new("webdriver-profile-duplicate-#{json.hash}")
+
+          zip_file << JSON.parse(json)['zip'].unpack("m")[0]
+          zip_file.close
+
+          new(Zipper.unzip(zip_file.path))
+        ensure
+          zip_file.delete if zip_file
         end
 
         #
@@ -75,80 +113,27 @@ module Selenium
           @additional_prefs[key.to_s] = value
         end
 
-        def absolute_path
-          if Platform.win?
-            directory.gsub("/", "\\")
-          else
-            directory
-          end
+        def port=(port)
+          self[WEBDRIVER_PREFS[:port]] = port
         end
 
-        def update_user_prefs
-          prefs = current_user_prefs
-
-          prefs.merge! OVERRIDABLE_PREFERENCES
-          prefs.merge! @additional_prefs
-          prefs.merge! DEFAULT_PREFERENCES
-
-          prefs['webdriver_firefox_port']            = @port
-          prefs['webdriver_accept_untrusted_certs']  = !secure_ssl?
-          prefs['webdriver_enable_native_events']    = native_events?
-          prefs['webdriver_assume_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
+        def log_file=(file)
+          @log_file = file
+          self[WEBDRIVER_PREFS[:log_file]] = file
         end
 
-        def add_webdriver_extension(force_creation = false)
-          ext_path = File.join(extensions_dir, EXTENSION_NAME)
-
-          if File.exists? ext_path
-            return unless force_creation
+        def add_webdriver_extension
+          unless @extensions.has_key?(:webdriver)
+            add_extension(WEBDRIVER_EXTENSION_PATH, :webdriver)
           end
-
-          add_extension WEBDRIVER_EXTENSION_PATH
-          delete_extensions_cache
         end
 
         #
-        # Aadd the extension (directory, .zip or .xpi) at the given path to the profile.
+        # Add the extension (directory, .zip or .xpi) at the given path to the profile.
         #
 
-        def add_extension(path)
-          unless File.exist?(path)
-            raise Error::WebDriverError, "could not find extension at #{path.inspect}"
-          end
-
-          if File.directory? path
-            root = path
-          else
-            unless %w[.zip .xpi].include? File.extname(path)
-              raise Error::WebDriverError, "expected .zip or .xpi extension, got #{path.inspect}"
-            end
-
-            root = ZipHelper.unzip(path)
-          end
-
-          ext_path = File.join extensions_dir, read_id_from_install_rdf(root)
-
-          FileUtils.rm_rf ext_path
-          FileUtils.mkdir_p File.dirname(ext_path), :mode => 0700
-          FileUtils.cp_r root, ext_path
-        end
-
-        def extensions_dir
-          @extensions_dir ||= File.join(directory, "extensions")
-        end
-
-        def user_prefs_path
-          @user_prefs_path ||= File.join(directory, "user.js")
-        end
-
-        def delete_extensions_cache
-          cache = File.join(directory, "extensions.cache")
-          FileUtils.rm_f cache if File.exist?(cache)
+        def add_extension(path, name = extension_name_for(path))
+          @extensions[name] = Extension.new(path)
         end
 
         def native_events?
@@ -173,11 +158,42 @@ module Selenium
 
         private
 
-        def read_id_from_install_rdf(directory)
-          rdf_path = File.join(directory, "install.rdf")
-          doc = REXML::Document.new(File.read(rdf_path))
+        def install_extensions(directory)
+          destination = File.join(directory, "extensions")
 
-          REXML::XPath.first(doc, "//em:id").text
+          @extensions.each do |name, extension|
+            p :extension => name if $DEBUG
+            extension.write_to(destination)
+          end
+        end
+
+        def verify_model(model)
+          return unless model
+
+          raise Errno::ENOENT, model unless File.exist?(model)
+          raise Errno::ENOTDIR, model unless File.directory?(model)
+
+          model
+        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 create_tmp_copy(directory)
@@ -191,13 +207,30 @@ module Selenium
           tmp_directory
         end
 
+        def update_user_prefs_in(directory)
+          path = File.join(directory, 'user.js')
+          prefs = read_user_prefs(path)
+
+          prefs.merge! OVERRIDABLE_PREFERENCES
+          prefs.merge! @additional_prefs
+          prefs.merge! DEFAULT_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 current_user_prefs
-          return {} unless File.exist?(user_prefs_path)
+        def read_user_prefs(path)
+          return {} unless File.exist?(path)
 
           prefs = {}
 
-          File.read(user_prefs_path).split("\n").each do |line|
+          File.read(path).split("\n").each do |line|
             if line =~ /user_pref\("([^"]+)"\s*,\s*(.+?)\);/
               prefs[$1.strip] = $2.strip
             end
@@ -206,8 +239,8 @@ module Selenium
           prefs
         end
 
-        def write_prefs(prefs)
-          File.open(user_prefs_path, "w") { |file|
+        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});}
@@ -238,6 +271,7 @@ module Selenium
           "extensions.update.enabled"                 => 'false',
           "extensions.update.notifyUser"              => 'false',
           "network.manage-offline-status"             => 'false',
+          "network.http.max-connections-per-server"   => '10',
           "security.warn_entering_secure"             => 'false',
           "security.warn_submit_insecure"             => 'false',
           "security.warn_entering_secure.show_once"   => 'false',

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

@@ -13,7 +13,8 @@ module Selenium
         end
 
         def [](name)
-          Profile.new @profile_paths[name]
+          path = @profile_paths[name]
+          path && Profile.new(path)
         end
 
         def refresh

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

@@ -0,0 +1,77 @@
+require "fcntl"
+
+module Selenium
+  module WebDriver
+    module Firefox
+
+      #
+      # @private
+      #
+
+      class SocketLock
+
+        #
+        # Need to be really specific about what host to use
+        #
+        # On os x, "localhost" will resolve to 3 different addresses (see /etc/hosts).
+        # Ruby will loop over these and happily bind to the same port on each one,
+        # making it completely unusable for our purposes.
+        #
+
+        HOST = "127.0.0.1"
+
+        def initialize(port, timeout)
+          @port    = port
+          @timeout = timeout
+        end
+
+        def locked(&blk)
+          lock
+
+          begin
+            yield
+          ensure
+            release
+          end
+        end
+
+        private
+
+        def lock
+          max_time = Time.now + @timeout
+
+          until can_lock? || Time.now >= max_time
+            sleep 0.1
+          end
+
+          unless did_lock?
+            raise Error::WebDriverError, "unable to bind to locking port #{@port} within #{@timeout} seconds"
+          end
+        end
+
+        def release
+          @server && @server.close
+        end
+
+        def can_lock?
+          @server = TCPServer.new(HOST, @port)
+
+          # make sure the fd is not inherited by exec()'d processes
+          if defined? Fcntl::FD_CLOEXEC
+            @server.fcntl(Fcntl::F_SETFD, Fcntl::FD_CLOEXEC)
+          end
+
+          true
+        rescue SocketError, Errno::EADDRINUSE => ex
+          $stderr.puts "#{self}: #{ex.message}" if $DEBUG
+          false
+        end
+
+        def did_lock?
+          !!@server
+        end
+
+      end # SocketLock
+    end # Firefox
+  end # WebDriver
+end # Selenium