seleniumrc 0.0.1 → 0.0.2

data/CHANGES

@@ -1,2 +1,6 @@
+0.0.2
+* Supports multiple sessions by instantiating multiple SeleniumDrivers
+* Added Seleniumrc::SeleniumDriver which holds most of the polling methods
+
 0.0.1
 * Initial Release. More documentation to come.

data/README

@@ -0,0 +1,38 @@
+== Introduction
+
+Welcome to Selenium RC!
+
+This plugin is designed to let you use Selenium RC to write Selenium tests in Ruby, using a simple series of
+Rake tasks.
+
+== Installation
+
+The current version of this plugin can be found at: http://rubyforge.org/var/svn/pivotalrb/seleniumrc/trunk
+
+You may install the plugin with the following command:
+
+  script/plugin install svn://rubyforge.org/var/svn/pivotalrb/seleniumrc/trunk
+
+== Usage
+The seleniumrc plugin assumes you have a test/selenium directory with a selenium_suite.rb file in
+it.  A sample selenium_suite.rb and selenium_helper.rb can be copied into your test/selenium directory.
+
+You'll get the following tasks:
+  - selenium:test - starts a Selenium RC server, runs selenium tests, and shuts the server down
+     when they're done
+
+and lower level tasks as well:
+  - selenium:server starts up a Selenium RC server
+  - selenium:test_with_server_started  runs Selenium tests off of an existing server
+
+== Future Enhancements
+
+There are a few things we'd like to improve, but we wanted to get this out now.  Check the tracker in the pivotal.rb RubyForge project for details.
+
+== License
+
+Selenium RC Fu is distributed under the MIT license. Copyright © 2007 Pivotal Labs, Inc.
+
+== Contributing
+
+Contributions to this plugin are welcome.  Contributions should be accompanied by tests.  See http://pivotalrb.rubyforge.org for more details.

data/Rakefile

@@ -26,7 +26,7 @@ def run_suite
 end
 
 PKG_NAME = "seleniumrc"
-PKG_VERSION = "0.0.1"
+PKG_VERSION = "0.0.2"
 PKG_FILES = FileList[
   '[A-Z]*',
   '*.rb',

data/lib/seleniumrc.rb

@@ -10,15 +10,13 @@ require 'test/unit/testresult'
 
 require "selenium"
 require "seleniumrc/extensions/testrunnermediator"
-require "seleniumrc/extensions/selenium_driver"
-require "seleniumrc/app_server_checker"
+require "seleniumrc/wait_for"
+require "seleniumrc/selenium_driver"
 require "seleniumrc/selenium_server_runner"
 require "seleniumrc/mongrel_selenium_server_runner"
 require "seleniumrc/webrick_selenium_server_runner"
-require "seleniumrc/wait_for"
 require "seleniumrc/dsl/test_unit_dsl"
 require "seleniumrc/dsl/selenium_dsl"
-require "seleniumrc/selenium_context"
 require "seleniumrc/selenium_configuration"
 require "seleniumrc/selenium_page"
 require "seleniumrc/selenium_element"

data/lib/seleniumrc/dsl/selenium_dsl.rb

@@ -5,21 +5,10 @@ module Seleniumrc
       @configuration ||= SeleniumConfiguration.instance
     end
     attr_writer :configuration
+    attr_accessor :selenium_driver  
     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)
@@ -27,142 +16,18 @@ module Seleniumrc
       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
+      selenium_driver.open(configuration.browser_url)
     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)
+    def method_missing(name, *args)
+      return selenium_driver.send(name, *args)
     end
 
     protected
-    attr_accessor :selenium
     delegate :open,
+             :type,
              :wait_for_condition,
              :get_select_options,
              :get_selected_id,
@@ -176,11 +41,11 @@ module Seleniumrc
              :get_selected_values,
              :get_body_text,
              :get_html_source,
-             :to => :selenium
+             :to => :selenium_driver
 
-    def should_stop_selenese_interpreter?
+    def should_stop_driver?
       return false unless configuration.test_browser_mode?
-      configuration.stop_selenese_interpreter?(passed?)
+      configuration.stop_driver?(passed?)
     end
   end
 end

data/lib/seleniumrc/extensions/testrunnermediator.rb

@@ -8,12 +8,12 @@ class Test::Unit::UI::TestRunnerMediator
   alias_method :initialize, :initialize_with_seleniumrc
 
   protected
-  def start_app_server
+  def start_app_server(*args)
     @app_runner = Seleniumrc::SeleniumConfiguration.instance.create_server_runner
     @app_runner.start
   end
 
-  def stop_app_server
+  def stop_app_server(*args)
     @app_runner.stop
   end
 end

data/lib/seleniumrc/mongrel_selenium_server_runner.rb

@@ -1,23 +1,24 @@
 module Seleniumrc
   class MongrelSeleniumServerRunner < SeleniumServerRunner
     def start
-      @configurator = @context.create_mongrel_configurator
-      initialize_server(@configurator)
+      mongrel_configurator = configuration.create_mongrel_configurator
+      initialize_server(mongrel_configurator)
 
       @thread_class.start do
-        start_server
+        start_server(mongrel_configurator)
       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
+    def start_server(mongrel_configurator)
+      mongrel_configurator.run
+      mongrel_configurator.log "Mongrel running at #{configuration.internal_app_server_host}:#{configuration.internal_app_server_port}"
+      mongrel_configurator.join
     end
 
     def initialize_server(config)
+      configuration = self.configuration
       config.listener do |*args|
         mongrel = (args.first || self)
         mongrel.log "Starting Rails in environment #{defaults[:environment]} ..."
@@ -26,6 +27,7 @@ module Seleniumrc
 
         mongrel.log "Loading any Rails specific GemPlugins"
         mongrel.load_plugins
+        configuration.app_server_initialization.call(mongrel)
       end
     end
 

data/lib/seleniumrc/selenium_configuration.rb

@@ -1,7 +1,7 @@
 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
+  # You can access the SeleniumConfiguration object by calling
+  #   Seleniumrc::SeleniumConfiguration.instance
   class SeleniumConfiguration
     module BrowserMode
       Suite = "suite" unless const_defined? :Suite
@@ -10,8 +10,8 @@ module Seleniumrc
     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.
+    class << self
+      # The instance of the Singleton SeleniumConfiguration. 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)
@@ -20,59 +20,252 @@ module Seleniumrc
       # * 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
+        return @instance if @instance
+        @instance = new
+        @instance.env = ENV
+
+        @instance.browser = FIREFOX
+        @instance.selenium_server_host = "localhost"     # address of selenium RC server (java)
+        @instance.selenium_server_port = 4444
+        @instance.app_server_engine = :webrick
+        @instance.internal_app_server_host = "0.0.0.0"    # internal address of app server (webrick or mongrel)
+        @instance.internal_app_server_port = 4000
+        @instance.external_app_server_host = "localhost"             # external address of app server (webrick or mongrel)
+        @instance.external_app_server_port = 4000
+        @instance.server_engine = :webrick
+        @instance.keep_browser_open_on_failure = true
+        @instance.browser_mode = BrowserMode::Suite
+        @instance.verify_remote_app_server_is_running = true
 
         establish_environment
-        @context
+        @instance
       end
+      attr_writer :instance
 
       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)
+        @instance.rails_env = env['RAILS_ENV'] if env.include?('RAILS_ENV')
+        @instance.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|
+          if env.include?(env_key)
+            @instance.send("#{env_key}=", env[env_key])
+          end
         end
-        ['browsers'].each do |env_key|
-          @context.send(env_key + "=", env[env_key].split(",")) if env.include?(env_key)
+        [
+          'keep_browser_open_on_failure',
+          'verify_remote_app_server_is_running'
+        ].each do |env_key|
+          if env.include?(env_key)
+            @instance.send("#{env_key}=", env[env_key].to_s != false.to_s)
+          end
         end
+        @instance.browser = env['browser'] if env.include?('browser')
       end
 
       def env
-        @context.env
+        @instance.env
+      end
+    end
+
+        attr_accessor :configuration,
+                  :env,
+                  :rails_env,
+                  :rails_root,
+                  :browser,
+                  :driver,
+                  :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,
+                  :app_server_initialization
+
+    def initialize
+      self.verify_remote_app_server_is_running = true
+      @after_driver_started_listeners = []
+      @app_server_initialization = proc {}
+      @failure_has_occurred = false
+    end
+
+    # A callback hook that gets run after the Selenese Interpreter is started.
+    def after_driver_started(&block)
+      @after_driver_started_listeners << block
+    end
+
+    # Notify all after_driver_started callbacks.
+    def notify_after_driver_started(driver)
+      for listener in @after_driver_started_listeners
+        listener.call(driver)
+      end
+    end
+
+    # The browser formatted for the Selenese driver.
+    def formatted_browser
+      return "*#{@browser}"
+    end
+
+    # Has a failure occurred in the tests?
+    def failure_has_occurred?
+      @failure_has_occurred = true
+    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
+
+    # The SeleniumDriver object, which sublcasses the SeleniumDriver provided by the Selenium RC (http://openqa.org/selenium-rc/) project.
+    def driver
+      return nil unless suite_browser_mode?
+      @driver ||= create_and_initialize_driver
+    end
+
+    def stop_driver_if_necessary(suite_passed) # nodoc
+      failure_has_occurred unless suite_passed
+      if @driver && stop_driver?(suite_passed)
+        @driver.stop
+        @driver = nil
+      end
+    end
+
+    def stop_driver?(passed) # nodoc
+      return true if passed
+      return !keep_browser_open_on_failure
+    end
+
+    def create_and_initialize_driver # nodoc
+      driver = create_driver
+      driver.start
+      notify_after_driver_started(driver)
+      driver
+    end
+
+    def create_driver # nodoc
+      return ::Seleniumrc::SeleniumDriver.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_configuration.app_server_type}"
       end
     end
-    extend ClassMethods
+
+    def create_webrick_runner # nodoc
+      require 'webrick_server'
+      runner = WebrickSeleniumServerRunner.new
+      runner.configuration = 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.configuration = 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 => "#{@rails_root}/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
+
+    protected
+    # Sets the failure state to true
+    def failure_has_occurred
+      @failure_has_occurred = true
+    end
   end
 end