seleniumrc 0.0.1

data/lib/seleniumrc/selenium_context.rb

@@ -0,0 +1,226 @@
+module Seleniumrc
+  # The application state and Dependency Injection container of the Seleniumrc objects.
+  # All objects are created through the SeleniumContext. All global state is encapsulated here.
+  class SeleniumContext
+    attr_accessor :configuration,
+                  :env,
+                  :rails_env,
+                  :rails_root,
+                  :browsers,
+                  :current_browser,
+                  :interpreter,
+                  :browser_mode,
+                  :selenium_server_host,
+                  :selenium_server_port,
+                  :app_server_engine,
+                  :internal_app_server_host,
+                  :internal_app_server_port,
+                  :external_app_server_host,
+                  :external_app_server_port,
+                  :server_engine,
+                  :keep_browser_open_on_failure,
+                  :verify_remote_app_server_is_running
+
+    def initialize
+      self.verify_remote_app_server_is_running = true
+      @before_suite_listeners = []
+      @after_selenese_interpreter_started_listeners = []
+    end
+
+    # A callback hook that gets run before the suite is run.
+    def before_suite(&block)
+      @before_suite_listeners << block
+    end
+
+    # Notify all before_suite callbacks.
+    def notify_before_suite
+      for listener in @before_suite_listeners
+        listener.call
+      end
+    end
+
+    # A callback hook that gets run after the Selenese Interpreter is started.
+    def after_selenese_interpreter_started(&block)
+      @after_selenese_interpreter_started_listeners << block
+    end
+
+    # Notify all after_selenese_interpreter_started callbacks.
+    def notify_after_selenese_interpreter_started(interpreter)
+      for listener in @after_selenese_interpreter_started_listeners
+        listener.call(interpreter)
+      end
+    end
+
+    # The browser formatted for the Selenese interpreter.
+    def formatted_browser
+      return "*#{@current_browser}"
+    end
+
+    # Has a failure occurred in the tests?
+    def failure_has_occurred?
+      @failure_has_occurred = true
+    end
+
+    # Sets the failure state to true
+    def failure_has_occurred!
+      @failure_has_occurred = true
+    end
+
+    # Sets the failure state to false
+    def failure_has_not_occurred!
+      @failure_has_occurred = false
+    end
+
+    # The http host name and port to be entered into the browser address bar
+    def browser_url
+      "http://#{external_app_server_host}:#{external_app_server_port}"
+    end
+
+    # The root directory (public) of the Rails application
+    def server_root
+      File.expand_path("#{rails_root}/public/")
+    end
+
+    # Sets the Test Suite to open a new browser instance for each TestCase
+    def test_browser_mode!
+      @browser_mode = SeleniumConfiguration::BrowserMode::Test
+    end
+
+    # Are we going to open a new browser instance for each TestCase?
+    def test_browser_mode?
+      @browser_mode == SeleniumConfiguration::BrowserMode::Test
+    end
+
+    # Sets the Test Suite to use one browser instance
+    def suite_browser_mode!
+      @browser_mode = SeleniumConfiguration::BrowserMode::Suite
+    end
+
+    # Does the Test Suite to use one browser instance?
+    def suite_browser_mode?
+      @browser_mode == SeleniumConfiguration::BrowserMode::Suite
+    end
+
+    def run_each_browser # nodoc
+      browsers.each do |browser|
+        self.current_browser = browser
+        yield
+        break if @failure_has_occurred
+      end
+    end
+
+    # The Selenese Interpreter object. This is the Interpreter provided by the Selenium RC (http://openqa.org/selenium-rc/) project.
+    def selenese_interpreter
+      return nil unless suite_browser_mode?
+      unless @interpreter
+        @interpreter = create_and_initialize_interpreter
+      end
+      @interpreter
+    end
+
+    def stop_interpreter_if_necessary(suite_passed) # nodoc
+      failure_has_occurred! unless suite_passed
+      if @interpreter && stop_selenese_interpreter?(suite_passed)
+        @interpreter.stop
+        @interpreter = nil
+      end
+    end
+
+    def stop_selenese_interpreter?(passed) # nodoc
+      return true if passed
+      return !keep_browser_open_on_failure
+    end
+
+    def create_app_server_checker # nodoc
+      app_server_checker = AppServerChecker.new()
+      app_server_checker.context = self
+      app_server_checker.tcp_socket_class = TCPSocket
+      return app_server_checker
+    end
+
+    def create_and_initialize_interpreter # nodoc
+      interpreter = create_interpreter
+      interpreter.start
+      notify_after_selenese_interpreter_started(interpreter)
+      interpreter
+    end
+
+    def create_interpreter # nodoc
+      return Selenium::SeleneseInterpreter.new(
+        selenium_server_host,
+        selenium_server_port,
+        formatted_browser,
+        browser_url,
+        15000
+      )
+    end
+
+    def create_server_runner # nodoc
+      case @app_server_engine.to_sym
+      when :mongrel
+        create_mongrel_runner
+      when :webrick
+        create_webrick_runner
+      else
+        raise "Invalid server type: #{selenium_context.app_server_type}"
+      end
+    end
+
+    def create_webrick_runner # nodoc
+      require 'webrick_server'
+      runner = WebrickSeleniumServerRunner.new
+      runner.context = self
+      runner.thread_class = Thread
+      runner.socket = Socket
+      runner.dispatch_servlet = DispatchServlet
+      runner.environment_path = File.expand_path("#{@rails_root}/config/environment")
+      runner
+    end
+
+    def create_webrick_server # nodoc
+      WEBrick::HTTPServer.new({
+        :Port => @internal_app_server_port,
+        :BindAddress => @internal_app_server_host,
+        :ServerType  => WEBrick::SimpleServer,
+        :MimeTypes => WEBrick::HTTPUtils::DefaultMimeTypes,
+        :Logger => new_logger,
+        :AccessLog => []
+      })
+    end
+
+    def new_logger
+      Logger.new(StringIO.new)
+    end
+
+    def create_mongrel_runner # nodoc
+      runner = MongrelSeleniumServerRunner.new
+      runner.context = self
+      runner.thread_class = Thread
+      runner
+    end
+
+    def create_mongrel_configurator # nodoc
+      dir = File.dirname(__FILE__)
+      require 'mongrel/rails'
+      settings = {
+        :host => internal_app_server_host,
+        :port => internal_app_server_port,
+        :cwd => @rails_root,
+        :log_file => "#{@rails_root}/log/mongrel.log",
+        :pid_file => "#{@rails_root}/log/mongrel.pid",
+        :environment => @rails_env,
+        :docroot => "public",
+        :mime_map => nil,
+        :daemon => false,
+        :debug => false,
+        :includes => ["mongrel"],
+        :config_script => nil
+      }
+
+      configurator = Mongrel::Rails::RailsConfigurator.new(settings) do
+        log "Starting Mongrel in #{defaults[:environment]} mode at #{defaults[:host]}:#{defaults[:port]}"
+      end
+      configurator
+    end
+  end
+end

data/lib/seleniumrc/selenium_element.rb

@@ -0,0 +1,195 @@
+module Seleniumrc
+  class SeleniumElement
+    include WaitFor
+    attr_reader :selenium, :locator
+
+    def initialize(selenium, locator)
+      @selenium = selenium
+      @locator = locator
+    end
+
+    def is_present(params={})
+      params = {:message => "Expected element '#{locator}' to be present, but it was not"}.merge(params)
+      wait_for(params) do
+        is_present?
+      end
+    end
+    def is_present?
+      selenium.is_element_present(locator)
+    end
+
+    def is_not_present(params={})
+      params = {:message => "Expected element '#{locator}' to be absent, but it was not"}.merge(params)
+      wait_for(:message => params[:message]) do
+        is_not_present?
+      end
+    end
+    def is_not_present?
+      !selenium.is_element_present(locator)
+    end
+
+    def has_value(expected_value)
+      is_present
+      wait_for do |context|
+        actual_value = selenium.get_value(locator)
+        context.message = "Expected '#{locator}' to be '#{expected_value}' but was '#{actual_value}'"
+        has_value? expected_value, actual_value
+      end
+    end
+    def has_value?(expected_value, actual_value=selenium.get_value(locator))
+      expected_value == actual_value
+    end
+
+    def has_attribute(expected_value)
+      is_present
+      wait_for do |context|
+        actual = selenium.get_attribute(locator)  #todo: actual value
+        context.message = "Expected attribute '#{locator}' to be '#{expected_value}' but was '#{actual}'"
+        expected_value == actual
+      end
+    end
+
+    def has_selected(expected_value)
+      is_present
+      wait_for do |context|
+        actual = selenium.get_selected_label(locator)
+        context.message = "Expected '#{locator}' to be selected with '#{expected_value}' but was '#{actual}"
+        expected_value == actual
+      end
+    end
+
+    def is_visible(options={})
+      is_present
+      options = {
+        :message => "Expected '#{locator}' to be visible, but it wasn't"
+      }.merge(options)
+      wait_for(options) do
+        selenium.is_visible(locator)
+      end
+    end
+
+    def is_not_visible(options={})
+      is_present
+      options = {
+        :message => "Expected '#{locator}' to be hidden, but it wasn't"
+      }.merge(options)
+      wait_for(options) do
+        !selenium.is_visible(locator)
+      end
+    end
+
+    def is_checked
+      is_present
+      wait_for(:message => "Expected '#{locator}' to be checked") do
+        selenium.is_checked(locator)
+      end
+    end
+
+    def is_not_checked
+      is_present
+      wait_for(:message => "Expected '#{locator}' to be checked") do
+        !selenium.is_checked(locator)
+      end
+    end
+
+    def has_text(expected_text, options={})
+      is_present
+      wait_for(options) do |context|
+        actual = selenium.get_text(locator)
+        context.message = "Expected text '#{expected_text}' to be full contents of #{locator} but was '#{actual}')"
+        expected_text == actual
+      end
+    end
+
+    def contains_text(expected_text, options={})
+      is_present
+      options = {
+        :message => "#{locator} should contain #{expected_text}"
+      }.merge(options)
+      wait_for(options) do
+        inner_html.include?(expected_text)
+      end
+    end
+
+    def does_not_contain_text(expected_text, options={})
+      is_present
+      wait_for(options) do
+        !inner_html.include?(expected_text)
+      end
+    end
+
+    def has_next_sibling(expected_sibling_id, options = {})
+      is_present
+      eval_js = "this.page().findElement('#{locator}').nextSibling.id"
+      wait_for(:message => "id '#{locator}' should be next to '#{expected_sibling_id}'") do
+        actual_sibling_id = selenium.get_eval(eval_js)
+        expected_sibling_id == actual_sibling_id
+      end
+    end
+
+    def has_text_in_order(*text_fragments)
+      is_present
+      wait_for do |context|
+        success = false
+
+        html = selenium.get_text(locator)
+        results = find_text_order_error_fragments(html, text_fragments)
+        fragments_not_found = results[:fragments_not_found]
+        fragments_out_of_order = results[:fragments_out_of_order]
+
+        if !fragments_not_found.empty?
+          context.message = "Certain fragments weren't found:\n" <<
+                            "#{fragments_not_found.join("\n")}\n" <<
+                            "\nhtml follows:\n #{html}\n"
+        elsif !fragments_out_of_order.empty?
+          context.message = "Certain fragments were out of order:\n" <<
+                            "#{fragments_out_of_order.join("\n")}\n" <<
+                            "\nhtml follows:\n #{html}\n"
+        else
+          success = true
+        end
+
+        success
+      end
+    end
+
+    def inner_html
+      selenium.get_eval("this.page().findElement(\"#{locator}\").innerHTML")
+    end
+
+    def ==(other)
+      return false unless other.is_a?(SeleniumElement)
+      return false unless self.selenium == other.selenium
+      return false unless self.locator == other.locator
+      true
+    end
+
+    protected
+    def find_text_order_error_fragments(html, text_fragments)
+      fragments_not_found = []
+      fragments_out_of_order = []
+
+      previous_index = -1
+      previous_fragment = ''
+      text_fragments.each do |current_fragment|
+        current_index = html.index(current_fragment)
+        if current_index
+          if current_index < previous_index
+            message = "Fragment #{current_fragment} out of order:\n" <<
+                    "\texpected '#{previous_fragment}'\n" <<
+                    "\tto come before '#{current_fragment}'\n"
+            fragments_out_of_order << message
+          end
+        else
+          fragments_not_found << "Fragment #{current_fragment} was not found\n"
+        end
+        previous_index = current_index
+        previous_fragment = current_fragment
+      end
+      {
+        :fragments_not_found => fragments_not_found,
+        :fragments_out_of_order => fragments_out_of_order
+      }
+    end
+  end
+end

data/lib/seleniumrc/selenium_helper.rb

@@ -0,0 +1,5 @@
+# Expand the path to environment so that Ruby does not load it multiple times
+# File.expand_path can be removed if Ruby 1.9 is in use.
+if (Object.const_defined?(:ActiveRecord) && !ActiveRecord::Base.allow_concurrency)
+  raise "Since Selenium spawns an internal app server, we need ActiveRecord to be multi-threaded. Please set 'ActiveRecord::Base.allow_concurrency = true' in your environment file (e.g. test.rb)."
+end

data/lib/seleniumrc/selenium_page.rb

@@ -0,0 +1,76 @@
+module Seleniumrc
+  class SeleniumPage
+    include WaitFor
+    attr_reader :selenium
+    PAGE_LOADED_COMMAND = "this.browserbot.getDocument().body ? true : false"
+
+    def initialize(selenium)
+      @selenium = selenium
+    end
+
+    def open_and_wait(url)
+      selenium.open(url)
+      wait_for_page_to_load
+    end
+
+    def has_title(expected_title, params = {})
+      wait_for(params) do |context|
+        actual_title = selenium.get_title
+        context.message = "Expected title '#{expected_title}' but was '#{actual_title}'"
+        has_title? expected_title, actual_title
+      end
+    end
+    def has_title?(expected_title, actual_title=selenium.get_title)
+      expected_title == actual_title
+    end
+
+    def is_text_present(expected_text, options = {})
+      options = {
+        :message => "Expected '#{expected_text}' to be present, but it wasn't"
+      }.merge(options)
+      wait_for(options) do
+        is_text_present? expected_text
+      end
+    end
+    def is_text_present?(expected_text)
+      page_loaded? && selenium.is_text_present(expected_text)
+    end
+
+    def is_text_not_present(unexpected_text, options = {})
+      options = {
+        :message => "Expected '#{unexpected_text}' to be absent, but it wasn't"
+      }.merge(options)
+      wait_for(options) do
+        is_text_not_present? unexpected_text
+      end
+    end
+    def is_text_not_present?(unexpected_text)
+      page_loaded? && !selenium.is_text_present(unexpected_text)
+    end
+
+    def page_loaded?
+      selenium.get_eval(PAGE_LOADED_COMMAND) == true.to_s
+    end
+
+    def url_ends_with(ends_with, options={})
+      options = {
+        :message => "Expected '#{selenium.get_location}' to end with '#{ends_with}'"
+      }.merge(options)
+      wait_for(options) do
+        url_ends_with? ends_with
+      end
+    end
+    def url_ends_with?(ends_with)
+      if selenium.get_location =~ Regexp.new("#{Regexp.escape(ends_with)}$")
+        true
+      else
+        false
+      end
+    end
+
+    def ==(other)
+      return false unless other.is_a?(SeleniumPage)
+      self.selenium == other.selenium
+    end
+  end
+end

data/lib/seleniumrc/selenium_server_runner.rb

@@ -0,0 +1,33 @@
+module Seleniumrc
+  class SeleniumServerRunner
+    attr_accessor :context, :thread_class
+    def initialize
+      @started = false
+    end
+
+    def start
+      @thread_class.start do
+        start_server
+      end
+      @started = true
+    end
+
+    def stop
+      stop_server
+      @started = false
+    end
+
+    def started?
+      @started
+    end
+
+    protected
+    def start_server
+      raise NotImplementedError.new("this is abstract!")
+    end
+
+    def stop_server
+      raise NotImplementedError.new("this is abstract!")
+    end
+  end
+end

data/lib/seleniumrc/selenium_test_case.rb

@@ -0,0 +1,95 @@
+module Seleniumrc
+  # The Test Case class that runs your Selenium tests.
+  # You are able to use all methods provided by Selenium::SeleneseInterpreter with some additions.
+  class SeleniumTestCase < Test::Unit::TestCase
+    module ClassMethods
+      def subclasses
+        @subclasses ||= []
+      end
+
+      def inherited(subclass)
+        # keep a list of all subclasses on the fly, so we can run them all later from the Runner
+        subclasses << subclass unless subclasses.include?(subclass)
+        super
+      end
+
+      def all_subclasses_as_suite(configuration)
+        suite = Test::Unit::TestSuite.new
+        all_descendant_classes.each do |test_case_class|
+          test_case_class.suite.tests.each do |test_case|
+            test_case.configuration = configuration
+            suite << test_case
+          end
+        end
+        suite
+      end
+
+      def all_descendant_classes
+        extract_subclasses(self)
+      end
+
+      def extract_subclasses(parent_class)
+        classes = []
+        parent_class.subclasses.each do |subclass|
+          classes << subclass
+          classes.push(*extract_subclasses(subclass))
+        end
+        classes
+      end
+
+      unless Object.const_defined?(:RAILS_ROOT)
+        attr_accessor :use_transactional_fixtures, :use_instantiated_fixtures
+      end
+    end
+    extend ClassMethods
+
+    self.use_transactional_fixtures = false
+    self.use_instantiated_fixtures  = true
+
+    include SeleniumDsl
+    def setup
+      #   set "setup_once" to true
+      #   to prevent fixtures from being re-loaded and data deleted from the DB.
+      #   this is handy if you want to generate a DB full of sample data
+      #   from the tests.  Make sure none of your selenium tests manually
+      #   reset data!
+      #TODO: make this configurable
+      setup_once = false
+
+      raise "Cannot use transactional fixtures if ActiveRecord concurrency is turned on (which is required for Selenium tests to work)." if self.class.use_transactional_fixtures
+  #        @beginning = time_class.now
+      unless setup_once
+        ActiveRecord::Base.connection.update('SET FOREIGN_KEY_CHECKS = 0')
+        super
+        ActiveRecord::Base.connection.update('SET FOREIGN_KEY_CHECKS = 1')
+      else
+        unless InstanceMethods.const_defined?("ALREADY_SETUP_ONCE")
+          super
+          InstanceMethods.const_set("ALREADY_SETUP_ONCE", true)
+        end
+      end
+  #        puts self.class.to_s + "#" + @method_name
+      @selenium = configuration.selenese_interpreter
+    end
+
+    def teardown
+      @selenium.stop if should_stop_selenese_interpreter?
+      super
+      if @beginning
+        duration = (time_class.now - @beginning).to_f
+        puts "#{duration} seconds"
+      end
+    end
+
+    def selenium_test_case
+      @selenium_test_case ||= SeleniumTestCase
+    end
+
+    def run(result, &block)
+      return if @method_name.nil? || @method_name.to_sym == :default_test
+      super
+    end
+  end
+end
+
+SeleniumTestCase = Seleniumrc::SeleniumTestCase

data/lib/seleniumrc/tasks/selenium_test_task.rb

@@ -0,0 +1,21 @@
+
+module Seleniumrc
+  module Tasks
+    class SeleniumTestTask
+      attr_reader :rails_env, :rails_root
+
+      def initialize(rails_env = RAILS_ENV, rails_root = RAILS_ROOT)
+        @rails_env = rails_env
+        @rails_root = rails_root
+      end
+
+      def invoke(suite_relative_path = "test/selenium/selenium_suite")
+        rails_env.replace "test"
+        require "#{rails_root}/" + suite_relative_path
+
+        passed = Test::Unit::AutoRunner.run
+        raise "Test failures" unless passed
+      end
+    end
+  end
+end

data/lib/seleniumrc/wait_for.rb

@@ -0,0 +1,47 @@
+module Seleniumrc
+  module WaitFor
+    Context = Struct.new(:message)
+    # Poll continuously for the return value of the block to be true. You can use this to assert that a client side
+    # or server side condition was met.
+    #   wait_for do
+    #     User.count == 5
+    #   end
+    def wait_for(params={})
+      timeout = params[:timeout] || default_wait_for_time
+      message = params[:message] || "Timeout exceeded"
+      context = Context.new(message)
+      begin_time = time_class.now
+      while (time_class.now - begin_time) < timeout
+        return if yield(context)
+        sleep 0.25
+      end
+      flunk(context.message + " (after #{timeout} sec)")
+      true
+    end
+
+    def default_wait_for_time
+      5
+    end
+
+    def time_class
+      Time
+    end
+
+    def wait_for_page_to_load(timeout=default_timeout)
+      selenium.wait_for_page_to_load timeout
+      if selenium.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
+
+    # The default Selenium Core client side timeout.
+    def default_timeout
+      @default_timeout ||= 20000
+    end
+    attr_writer :default_timeout
+
+    def flunk(message)
+      raise Test::Unit::AssertionFailedError, message
+    end
+  end
+end