selenium-webdriver 0.0.1

data/firefox/src/rb/lib/selenium/webdriver/firefox/extension_connection.rb

@@ -0,0 +1,82 @@
+module Selenium
+  module WebDriver
+    module Firefox
+      class ExtensionConnection
+
+        def initialize(host, port)
+          @host = host
+          @port = port
+        end
+
+        def connect(timeout = 20)
+          Timeout.timeout(timeout) {
+            loop do
+              begin
+                return new_socket
+              rescue Errno::ECONNREFUSED => e
+                $stderr.puts "#{self} caught #{e.message}" if $DEBUG
+                sleep 0.250
+              end
+            end
+          }
+        end
+
+        def new_socket
+          @socket = TCPSocket.new(@host, @port)
+          @socket.sync = true
+
+          @socket
+        end
+
+        def connected?
+          @socket && !@socket.closed?
+        end
+
+        def send_string(str)
+          str = <<-HTTP
+GET / HTTP/1.1
+Host: localhost
+Content-Length: #{str.length}
+
+#{str}
+HTTP
+          @socket.write str
+          @socket.flush
+        end
+
+        def quit
+          command = {'commandName' => 'quit', 'context' => ''}
+          send_string(command.to_json)
+        ensure
+          @socket.close
+        end
+
+        def close
+          @socket.close
+        end
+
+        def read_response
+          resp     = ""
+          received = ""
+
+          until resp.include?("\n\n")
+            received = @socket.recv 1
+            if received
+              resp += received
+            end
+          end
+
+          length      = resp.split(":")[1].lstrip!.to_i
+          json_string = @socket.recv length
+
+          if json_string.empty?
+            raise Error::WebDriverError, "empty response from extension"
+          end
+
+          JSON.parse json_string
+        end
+
+      end # ExtensionConnection
+    end # Firefox
+  end # WebDriver
+end # Selenium

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

@@ -0,0 +1,132 @@
+module Selenium
+  module WebDriver
+    module Firefox
+      class Launcher
+
+        attr_reader :binary, :connection
+
+        def initialize(binary, port = DEFAULT_PORT, profile_name = DEFAULT_PROFILE_NAME)
+          @binary       = binary
+          @port         = port.to_i
+          @profile_name = profile_name
+
+          @profile      = nil
+          @host         = "localhost"
+        end
+
+        def launch
+          with_lock do
+            find_free_port
+            connect_and_kill
+            create_profile
+            start_silent_and_wait
+            start
+            connect_until_stable
+          end
+
+          self
+        end
+
+        def with_lock
+          socket_lock = TCPServer.new(@host, @port - 1)
+          yield
+        ensure
+          socket_lock.close if socket_lock
+        end
+
+        def find_free_port
+          port = @port
+
+          until free_port?(port)
+            port += 1
+          end
+
+          @port = port
+        end
+
+        def create_profile
+          fetch_profile
+
+          @profile.delete_extensions_cache
+
+          if @profile.nil?
+            raise Error, WebDriverError, "could not find or create profile: #{profile.inspect}"
+          end
+
+          @profile.port = @port
+          @profile.add_extension(true)
+          @profile.update_user_prefs
+        end
+
+        def start
+          assert_profile
+          @binary.start_with @profile
+        end
+
+        def start_silent_and_wait
+          assert_profile
+          @binary.start_with @profile, "--silent"
+          @binary.wait
+        end
+
+        def connect_and_kill
+          connection = ExtensionConnection.new(@host, @port)
+          connection.connect(1)
+          connection.quit
+        rescue Errno::ECONNREFUSED, Timeout::Error => e
+          # ok
+        end
+
+        def connect
+          @connection = ExtensionConnection.new(@host, @port)
+          @connection.connect(5)
+        end
+
+        def connect_until_stable
+          max_time = Time.now + 60
+
+          until Time.now >= max_time
+            begin
+              connection = ExtensionConnection.new(@host, @port)
+              connection.connect(1)
+              connection.close
+
+              connect
+              return
+            rescue Timeout::Error => e
+              # ok
+            end
+          end
+
+          raise Error::WebDriverError, "unable to obtain stable firefox connection"
+        end
+
+        def free_port?(port)
+          s = TCPServer.new(@host, port)
+          s.close
+          true
+        rescue
+          false
+        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 "unable to find or create new profile" unless existing
+          end
+
+          @profile = existing.create_copy
+        end
+
+        def assert_profile
+          raise "must create_profile first" if @profile.nil?
+        end
+
+      end # Launcher
+    end # Firefox
+  end # WebDriver
+end # Selenium

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

@@ -0,0 +1,174 @@
+module Selenium
+  module WebDriver
+    module Firefox
+      class Profile
+
+        ANONYMOUS_PROFILE_NAME = "WEBDRIVER_ANONYMOUS_PROFILE"
+        EXTENSION_NAME         = "fxdriver@googlecode.com"
+        EM_NAMESPACE_URI       = "http://www.mozilla.org/2004/em-rdf#"
+
+        # TODO: hardcoded paths
+        DEFAULT_EXTENSION_SOURCE = File.expand_path("#{WebDriver.root}/firefox/src/extension")
+
+        XPTS                     = {
+          "#{WebDriver.root}/firefox/prebuilt/nsINativeEvents.xpt"     => "components/nsINativeEvents.xpt",
+          "#{WebDriver.root}/firefox/prebuilt/nsICommandProcessor.xpt" => "components/nsICommandProcessor.xpt",
+          "#{WebDriver.root}/firefox/prebuilt/nsIResponseHandler.xpt"  => "components/nsIResponseHandler.xpt"
+        }
+
+        SHARED = {
+          "#{WebDriver.root}/common/src/js/extension/dommessenger.js" => "content/dommessenger.js"
+        }
+
+        attr_reader :name, :directory
+        attr_accessor :port
+
+        class << self
+
+          def ini
+            @ini ||= ProfilesIni.new
+          end
+
+          def from_name(name)
+            ini[name]
+          end
+
+        end
+
+        def initialize(directory = nil)
+          if directory
+            @directory = directory
+          else
+            @directory = Dir.mktmpdir("webdriver-profile")
+          end
+
+          unless File.directory?(@directory)
+            raise Error::WebDriverError, "Profile directory does not exist: #{@directory.inspect}"
+          end
+
+          @extension_source = DEFAULT_EXTENSION_SOURCE # make configurable?
+        end
+
+        def absolute_path
+          if Platform.win?
+            directory.gsub("/", "\\")
+          else
+            directory
+          end
+        end
+
+        def update_user_prefs
+          prefs = existing_user_prefs.merge DEFAULT_PREFERENCES
+          prefs['webdriver.firefox_port'] = @port
+
+          write_prefs prefs
+        end
+
+        def add_extension(force = false)
+          ext_path = File.join(extensions_dir, EXTENSION_NAME)
+
+          if File.exists?(ext_path)
+            return unless force
+          end
+
+          FileUtils.rm_rf ext_path
+          FileUtils.mkdir_p File.dirname(ext_path), :mode => 0700
+          FileUtils.cp_r @extension_source, ext_path
+
+          XPTS.each do |source, destination|
+            FileUtils.cp source, File.join(ext_path, destination)
+          end
+
+          SHARED.each do |source, destination|
+            FileUtils.cp source, File.join(ext_path, destination)
+          end
+
+          delete_extensions_cache
+        end
+
+        def create_copy
+          tmp_directory = Dir.mktmpdir("webdriver-rb-profilecopy")
+          FileUtils.cp_r @directory, tmp_directory
+
+          Profile.new(tmp_directory)
+        end
+
+        def port
+          @port ||= Firefox::DEFAULT_PORT
+        end
+
+        def extensions_dir
+          @extensions_dir ||= File.join(directory, "extensions")
+        end
+
+        def user_prefs_path
+          @user_prefs_js ||= File.join(directory, "user.js")
+        end
+
+        def delete_extensions_cache
+          cache = File.join(@directory, "extensions.cache")
+          FileUtils.rm_f cache if File.exist?(cache)
+        end
+
+        private
+
+        def existing_user_prefs
+          return {} unless File.exist?(user_prefs_path)
+
+          prefs = {}
+
+          File.read(user_prefs_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)
+          File.open(user_prefs_path, "w") do |file|
+            prefs.each do |key, value|
+              file.puts "user_pref(#{key.inspect}, #{value});"
+            end
+          end
+        end
+
+        DEFAULT_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.search.update"                     => 'false',
+          "browser.sessionstore.resume_from_crash"    => 'false',
+          "browser.shell.checkDefaultBrowser"         => 'false',
+          "browser.startup.page"                      => '0',
+          "browser.tabs.warnOnClose"                  => 'false',
+          "browser.tabs.warnOnOpen"                   => 'false',
+          "dom.disable_open_during_load"              => 'false',
+          "extensions.update.enabled"                 => 'false',
+          "extensions.update.notifyUser"              => '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',
+          "startup.homepage_welcome_url"              => '"about:blank"',
+          "javascript.options.showInConsole"          => 'true',
+          "browser.dom.window.dump.enabled"           => 'true'
+        }
+
+      end # Profile
+    end # Firefox
+  end # WebDriver
+end # Selenium

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

@@ -0,0 +1,60 @@
+module Selenium
+  module WebDriver
+    module Firefox
+      class ProfilesIni
+
+        def initialize
+          @path = File.join(Util.app_data_path, "profiles.ini")
+          @profiles = {}
+          parse if File.exist?(@path)
+        end
+
+        def [](name)
+          @profiles[name]
+        end
+
+        def refresh
+          @profiles.clear
+          parse
+        end
+
+        private
+
+        def parse
+          string      = File.read @path
+          name        = nil
+          is_relative = nil
+          path        = nil
+
+          string.split("\n").each do |line|
+            case line
+            when /^\[Profile/
+              if p = new_profile(name, is_relative, path)
+                @profiles[name] = p
+                name, path = nil
+              end
+            when /^Name=(.+)$/
+              name = $1.strip
+            when /^IsRelative=(.+)$/
+              is_relative = $1.strip == "1"
+            when /^Path=(.+)$/
+              path = $1.strip
+            end
+          end
+
+          if p = new_profile(name, is_relative, path)
+            @profiles[name] = p
+          end
+        end
+
+        def new_profile(name, is_relative, path)
+          return unless [name, path].any?
+          path = is_relative ? File.join(Util.app_data_path, path) : path
+
+          Profile.new(path)
+        end
+
+      end # ProfilesIni
+    end # Firefox
+  end # WebDriver
+end # Selenium