seleniumrc 0.0.1

data/CHANGES

@@ -0,0 +1,2 @@
+0.0.1
+* Initial Release. More documentation to come.

data/Rakefile

@@ -0,0 +1,68 @@
+require "rake"
+require 'rake/gempackagetask'
+require 'rake/contrib/rubyforgepublisher'
+require 'rake/clean'
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+desc "Runs the Rspec suite"
+task(:default) do
+  run_suite
+end
+
+desc "Runs the Rspec suite"
+task(:spec) do
+  run_suite
+end
+
+desc "Copies the trunk to a tag with the name of the current release"
+task(:tag_release) do
+  tag_release
+end
+
+def run_suite
+  dir = File.dirname(__FILE__)
+  system("ruby #{dir}/spec/spec_suite.rb") || raise("Example Suite failed")
+end
+
+PKG_NAME = "seleniumrc"
+PKG_VERSION = "0.0.1"
+PKG_FILES = FileList[
+  '[A-Z]*',
+  '*.rb',
+  'lib/**/*.rb',
+  'spec/**/*.rb'
+]
+
+spec = Gem::Specification.new do |s|
+  s.name = PKG_NAME
+  s.version = PKG_VERSION
+  s.summary = "Selenium RC with enhanced assertions that also runs your rails app."
+  s.test_files = "examples/example_suite.rb"
+  s.description = s.summary
+
+  s.files = PKG_FILES.to_a
+  s.require_path = 'lib'
+
+  s.has_rdoc = true
+  s.extra_rdoc_files = [ "README", "CHANGES" ]
+  s.rdoc_options = ["--main", "README", "--inline-source", "--line-numbers"]
+
+  s.test_files = Dir.glob('spec/*_spec.rb')
+  s.require_path = 'lib'
+  s.autorequire = 'rr'
+  s.author = "Pivotal Labs"
+  s.email = "opensource@pivotallabs.com"
+  s.homepage = "http://pivotallabs.com"
+  s.rubyforge_project = "pivotalrb"
+end
+
+Rake::GemPackageTask.new(spec) do |pkg|
+  pkg.need_zip = true
+  pkg.need_tar = true
+end
+
+def tag_release
+  dashed_version = PKG_VERSION.gsub('.', '-')
+  `svn cp svn+ssh://rubyforge.org/var/svn/pivotalrb/seleniumrc/trunk svn+ssh://rubyforge.org/var/svn/pivotalrb/seleniumrc/tags/REL-#{dashed_version} -m 'Version #{PKG_VERSION}'`
+end

data/lib/seleniumrc/app_server_checker.rb

@@ -0,0 +1,43 @@
+module Seleniumrc
+  class AppServerChecker
+
+    attr_accessor :tcp_socket_class
+    attr_accessor :context
+
+    def is_server_started?
+      @host = @context.internal_app_server_host
+      @port = @context.internal_app_server_port
+      if (@host == '0.0.0.0')
+        @host = '127.0.0.1'
+      end
+      if (@host == '127.0.0.1' || @host == 'localhost')
+        return is_started?
+      end
+
+      # must be remote
+      return true if @context.verify_remote_app_server_is_running == false
+
+      # should be verified
+      return true if is_started?
+      # is not started but should be verified, so throw exception
+      error_message = "The 'verify_remote_app_server_is_running flag' was true, but the server was not accessible at '#{@host}:#{@port}'.  " \
+        "You should either start the server, or set the environment variable 'verify_remote_app_server_is_running' to false " \
+        "(IF you are SURE that the server is actually running, but just not accessible from this box)."
+      raise RuntimeError.new(error_message)
+    end
+
+    def is_started?
+      begin
+        @socket = @tcp_socket_class.new(@host, @port)
+      rescue SocketError
+        return false
+      rescue Errno::EBADF
+        return false
+      rescue Errno::ECONNREFUSED
+        return false
+      end
+      @socket.close unless @socket.nil?
+      return true
+    end
+  end
+end

data/lib/seleniumrc/dsl/selenium_dsl.rb

@@ -0,0 +1,186 @@
+module Seleniumrc
+  module SeleniumDsl
+    # The SeleniumConfiguration object.
+    def configuration
+      @configuration ||= SeleniumConfiguration.instance
+    end
+    attr_writer :configuration
+    include WaitFor
+    include TestUnitDsl
+
+    def type(locator,value)
+      element(locator).is_present
+      selenium.type(locator,value)
+    end
+
+    def click(locator)
+      element(locator).is_present
+      selenium.click(locator)
+    end
+
+    alias_method :wait_for_and_click, :click
+
+    # Download a file from the Application Server
+    def download(path)
+      uri = URI.parse(configuration.browser_url + path)
+      puts "downloading #{uri.to_s}"
+      Net::HTTP.get(uri)
+    end
+
+    def select(select_locator,option_locator)
+      element(select_locator).is_present
+      selenium.select(select_locator,option_locator)
+    end
+
+    # Reload the current page that the browser is on.
+    def reload
+      selenium.get_eval("selenium.browserbot.getCurrentWindow().location.reload()")
+    end
+
+    def method_missing(name, *args)
+      return selenium.send(name, *args)
+    end
+
+
+#--------- Commands
+
+    # Open a location and wait for the page to load.
+    def open_and_wait(url)
+      page.open_and_wait url
+    end
+
+    # Click a link and wait for the page to load.
+    def click_and_wait(locator, wait_for = default_timeout)
+      selenium.click locator
+      wait_for_page_to_load(wait_for)
+    end
+    alias_method :click_and_wait_for_page_to_load, :click_and_wait
+
+    # Click the back button and wait for the page to load.
+    def go_back_and_wait
+      selenium.go_back
+      wait_for_page_to_load
+    end
+
+    # Open the home page of the Application and wait for the page to load.
+    def open_home_page
+      selenium.open(configuration.browser_url)
+      wait_for_page_to_load
+    end
+
+    # Get the inner html of the located element.
+    def get_inner_html(locator)
+      element(locator).inner_html
+    end
+
+    # Does the element at locator contain the text?
+    def element_contains_text(locator, text)
+      selenium.is_element_present(locator) && get_inner_html(locator).include?(text)
+    end
+
+    # Does the element at locator not contain the text?
+    def element_does_not_contain_text(locator, text)
+      return true unless selenium.is_element_present(locator)
+      return !get_inner_html(locator).include?(text)
+    end
+
+    # Does locator element have text fragments in a certain order?
+    def is_text_in_order(locator, *text_fragments)
+      container = Hpricot(get_text(locator))
+
+      everything_found = true
+      wasnt_found_message = "Certain fragments weren't found:\n"
+
+      everything_in_order = true
+      wasnt_in_order_message = "Certain fragments were out of order:\n"
+
+      text_fragments.inject([-1, nil]) do |old_results, new_fragment|
+        old_index = old_results[0]
+        old_fragment = old_results[1]
+        new_index = container.inner_html.index(new_fragment)
+
+        unless new_index
+          everything_found = false
+          wasnt_found_message << "Fragment #{new_fragment} was not found\n"
+        end
+
+        if new_index < old_index
+          everything_in_order = false
+          wasnt_in_order_message << "Fragment #{new_fragment} out of order:\n"
+          wasnt_in_order_message << "\texpected '#{old_fragment}'\n"
+          wasnt_in_order_message << "\tto come before '#{new_fragment}'\n"
+        end
+
+        [new_index, new_fragment]
+      end
+
+      wasnt_found_message << "\n\nhtml follows:\n #{container.inner_html}\n"
+      wasnt_in_order_message << "\n\nhtml follows:\n #{container.inner_html}\n"
+
+      unless everything_found && everything_in_order
+        yield(everything_found, wasnt_found_message, everything_in_order, wasnt_in_order_message)
+      end
+    end
+#----- Waiting for conditions
+
+    def wait_for_page_to_load(timeout=default_timeout)
+      selenium.wait_for_page_to_load timeout
+      if get_title.include?("Exception caught")
+        flunk "We got a new page, but it was an application exception page.\n\n" + get_html_source
+      end
+    end
+
+    def wait_for_element_to_contain(locator, text, message=nil, timeout=default_wait_for_time)
+      wait_for({:message => message, :timeout => timeout}) {element_contains_text(locator, text)}
+    end
+    alias_method :wait_for_element_to_contain_text, :wait_for_element_to_contain
+
+    # Open the log window on the browser. This is useful to diagnose issues with Selenium Core.
+    def show_log(log_level = "debug")
+      get_eval "LOG.setLogLevelThreshold('#{log_level}')"
+    end
+
+    # Slow down each Selenese step after this method is called.
+    def slow_mode
+      get_eval "slowMode = true"
+      get_eval 'window.document.getElementsByName("FASTMODE")[0].checked = true'
+    end
+
+    # Speeds up each Selenese step to normal speed after this method is called.
+    def fast_mode
+      get_eval "slowMode = false"
+      get_eval 'window.document.getElementsByName("FASTMODE")[0].checked = false'
+    end
+
+    def page
+      SeleniumPage.new(@selenium)
+    end
+
+    def element(locator)
+      SeleniumElement.new(@selenium, locator)
+    end
+
+    protected
+    attr_accessor :selenium
+    delegate :open,
+             :wait_for_condition,
+             :get_select_options,
+             :get_selected_id,
+             :get_selected_id,
+             :get_selected_ids,
+             :get_selected_index,
+             :get_selected_indexes,
+             :get_selected_label,
+             :get_selected_labels,
+             :get_selected_value,
+             :get_selected_values,
+             :get_body_text,
+             :get_html_source,
+             :to => :selenium
+
+    def should_stop_selenese_interpreter?
+      return false unless configuration.test_browser_mode?
+      configuration.stop_selenese_interpreter?(passed?)
+    end
+  end
+end

data/lib/seleniumrc/dsl/test_unit_dsl.rb

@@ -0,0 +1,95 @@
+module Seleniumrc
+  module TestUnitDsl
+    #------ Assertions and Conditions
+    # Assert and wait for the page title.
+    def assert_title(title, params={})
+      page.has_title(title, params)
+    end
+
+    # Assert and wait for page to contain text.
+    def assert_text_present(pattern, options = {})
+      page.is_text_present(pattern, options)
+    end
+
+    # Assert and wait for page to not contain text.
+    def assert_text_not_present(pattern, options = {})
+      page.is_text_not_present(pattern, options)
+    end
+
+    # Assert and wait for the locator element to have value.
+    def assert_value(locator, value)
+      element(locator).has_value(value)
+    end
+
+    # Assert and wait for the locator attribute to have a value.
+    def assert_attribute(locator, value)
+      element(locator).has_attribute(value)
+    end
+
+    # Assert and wait for locator select element to have value option selected.
+    def assert_selected(locator, value)
+      element(locator).has_selected(value)
+    end
+
+    # Assert and wait for locator check box to be checked.
+    def assert_checked(locator)
+      element(locator).is_checked
+    end
+
+    # Assert and wait for locator check box to not be checked.
+    def assert_not_checked(locator)
+      element(locator).is_not_checked
+    end
+
+    # Assert and wait for locator element to have text equal to passed in text.
+    def assert_text(locator, text, options={})
+      element(locator).has_text(text, options)
+    end
+
+    # Assert and wait for locator element to be present.
+    def assert_element_present(locator, params = {})
+      element(locator).is_present(params)
+    end
+
+    # Assert and wait for locator element to not be present.
+    def assert_element_not_present(locator, params = {})
+      element(locator).is_not_present(params)
+    end
+
+    # Assert and wait for locator element to contain text.
+    def assert_element_contains(locator, text, options = {})
+      element(locator).contains_text(text, options)
+    end
+
+    # Assert and wait for locator element to not contain text.
+    def assert_element_does_not_contain_text(locator, text, options={})
+      element(locator).does_not_contain_text(text, options)
+    end
+    alias_method :assert_element_does_not_contain, :assert_element_does_not_contain_text
+    alias_method :wait_for_element_to_not_contain_text, :assert_element_does_not_contain_text
+
+    # Assert and wait for the element with id next sibling is the element with id expected_sibling_id.
+    def assert_next_sibling(locator, expected_sibling_id, options = {})
+      element(locator).has_next_sibling(expected_sibling_id, options)
+    end
+
+    # Assert browser url ends with passed in url.
+    def assert_location_ends_in(ends_with, options={})
+      page.url_ends_with(ends_with, options)
+    end
+
+    # Assert and wait for locator element has text fragments in a certain order.
+    def assert_text_in_order(locator, *text_fragments)
+      element(locator).has_text_in_order(*text_fragments)
+    end
+    alias_method :wait_for_text_in_order, :assert_text_in_order
+
+    def assert_visible(locator, options = {})
+      element(locator).is_visible(options)
+    end
+
+    def assert_not_visible(locator, options = {})
+      element(locator).is_not_visible(options)
+    end    
+  end
+end

data/lib/seleniumrc/extensions/selenium_driver.rb

@@ -0,0 +1,33 @@
+module Selenium
+  class SeleniumDriver
+    attr_reader :server_host, :server_port
+
+    def browser_start_command
+      @browserStartCommand
+    end
+
+    def browser_url
+      @browserURL
+    end
+
+    def timeout_in_milliseconds
+      @timeout
+    end
+
+    alias_method :confirm, :get_confirmation
+
+    def insert_javascript_file(uri)
+      js = <<-USEREXTENSIONS
+      var headTag = document.getElementsByTagName("head").item(0);
+      var scriptTag = document.createElement("script");
+      scriptTag.src = "#{uri}";
+      headTag.appendChild( scriptTag );
+      USEREXTENSIONS
+      get_eval(js)
+    end
+
+    def insert_user_extensions
+      insert_javascript_file("/selenium/user-extensions.js")
+    end
+  end
+end

data/lib/seleniumrc/extensions/testrunnermediator.rb

@@ -0,0 +1,19 @@
+class Test::Unit::UI::TestRunnerMediator
+  alias_method :initialize_without_seleniumrc, :initialize
+  def initialize_with_seleniumrc(suite)
+    initialize_without_seleniumrc(suite)
+    add_listener(TestCase::STARTED, &method(:start_app_server))
+    add_listener(TestCase::FINISHED, &method(:stop_app_server))
+  end
+  alias_method :initialize, :initialize_with_seleniumrc
+
+  protected
+  def start_app_server
+    @app_runner = Seleniumrc::SeleniumConfiguration.instance.create_server_runner
+    @app_runner.start
+  end
+
+  def stop_app_server
+    @app_runner.stop
+  end
+end

data/lib/seleniumrc/mongrel_selenium_server_runner.rb

@@ -0,0 +1,35 @@
+module Seleniumrc
+  class MongrelSeleniumServerRunner < SeleniumServerRunner
+    def start
+      @configurator = @context.create_mongrel_configurator
+      initialize_server(@configurator)
+
+      @thread_class.start do
+        start_server
+      end
+      @started = true
+    end
+
+    protected
+    def start_server
+      @configurator.run
+      @configurator.log "Mongrel running at #{@context.internal_app_server_host}:#{@context.internal_app_server_port}"
+      @configurator.join
+    end
+
+    def initialize_server(config)
+      config.listener do |*args|
+        mongrel = (args.first || self)
+        mongrel.log "Starting Rails in environment #{defaults[:environment]} ..."
+        mongrel.uri "/", :handler => mongrel.rails
+        mongrel.log "Rails loaded."
+
+        mongrel.log "Loading any Rails specific GemPlugins"
+        mongrel.load_plugins
+      end
+    end
+
+    def stop_server
+    end
+  end
+end

data/lib/seleniumrc/selenium_configuration.rb

@@ -0,0 +1,78 @@
+module Seleniumrc
+  # The configuration interface. This SeleniumConfiguration acts as a singleton to a SeleniumContext.
+  # You can access the SeleniumContext object by calling
+  #   Seleniumrc::SeleniumContext.instance
+  class SeleniumConfiguration
+    module BrowserMode
+      Suite = "suite" unless const_defined? :Suite
+      Test = "test" unless const_defined? :Test
+    end
+    FIREFOX = "firefox" unless const_defined? :FIREFOX
+    IEXPLORE = "iexplore" unless const_defined? :IEXPLORE
+
+    module ClassMethods
+      # The instance of the Singleton SeleniumContext. On its initial call, the initial configuration is set.
+      # The initial configuration is based on Environment variables and defaults.
+      # The environment variables are:
+      # * RAILS_ENV - The Rails environment (defaults: test)
+      # * selenium_server_host - The host name for the Selenium RC server (default: localhost)
+      # * selenium_server_port - The port for the Selenium RC server (default: 4444)
+      # * webrick_host - The host name that the application server will start under (default: localhost)
+      # * webrick_port - The port that the application server will start under (default: 4000)
+      # * app_server_engine - The type of server the application will be run with (webrick or mongrel)
+      # * browsers - A comma-delimited list of browsers that will be tested (e.g. firebox,iexplore)
+      # * internal_app_server_host - The host name for the Application server that the Browser will access (default: localhost)
+      # * internal_app_server_host - The port for the Application server that the Browser will access (default: 4000)
+      # * keep_browser_open_on_failure - If there is a failure in the test suite, keep the browser window open (default: true)
+      # * verify_remote_app_server_is_running - Raise an exception if the Application Server is not running (default: true)
+      def instance
+        return @context if @context
+        @context = SeleniumContext.new
+        @context.env = ENV
+
+        # TODO: BT - We need to only run one browser per run. Having an array makes the architecture wack.
+        @context.browsers = [FIREFOX] # Crack is wack
+        @context.failure_has_not_occurred!
+        @context.selenium_server_host = "localhost"     # address of selenium RC server (java)
+        @context.selenium_server_port = 4444
+        @context.app_server_engine = :webrick
+        @context.internal_app_server_host = "0.0.0.0"    # internal address of app server (webrick)
+        @context.internal_app_server_port = 4000
+        @context.external_app_server_host = "localhost"             # external address of app server (webrick)
+        @context.external_app_server_port = 4000
+        @context.server_engine = :webrick
+        @context.keep_browser_open_on_failure = true
+        @context.browser_mode = BrowserMode::Suite
+        @context.verify_remote_app_server_is_running = true
+
+        establish_environment
+        @context
+      end
+
+      private
+      def context
+        @context || SeleniumContext.new
+      end
+
+      def establish_environment
+        @context.rails_env = env['RAILS_ENV'] if env.include?('RAILS_ENV')
+        @context.rails_root = Object.const_get(:RAILS_ROOT) if Object.const_defined?(:RAILS_ROOT)
+        ['selenium_server_host', 'selenium_server_port', 'internal_app_server_port', 'internal_app_server_host',
+          'app_server_engine', 'external_app_server_host', 'external_app_server_port'].each do |env_key|
+          @context.send(env_key + "=", env[env_key]) if env.include?(env_key)
+        end
+        ['keep_browser_open_on_failure', 'verify_remote_app_server_is_running'].each do |env_key|
+          @context.send(env_key + "=", env[env_key].to_s != false.to_s) if env.include?(env_key)
+        end
+        ['browsers'].each do |env_key|
+          @context.send(env_key + "=", env[env_key].split(",")) if env.include?(env_key)
+        end
+      end
+
+      def env
+        @context.env
+      end
+    end
+    extend ClassMethods
+  end
+end