polonium 0.1.0

data/lib/polonium/dsl/selenium_dsl.rb

@@ -0,0 +1,33 @@
+module Polonium
+  module SeleniumDsl
+    # The Configuration object.
+    def configuration
+      @configuration ||= Configuration.instance
+    end
+    attr_writer :configuration
+    attr_accessor :selenium_driver  
+    include WaitFor
+
+    # 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
+
+    # Open the home page of the Application and wait for the page to load.
+    def open_home_page
+      selenium_driver.open(configuration.browser_url)
+    end
+
+    protected
+    Driver.public_instance_methods(false).each do |method_name|
+      delegate method_name, :to => :selenium_driver
+    end
+
+    def should_stop_driver?
+      return false unless configuration.test_browser_mode?
+      configuration.stop_driver?(passed?)
+    end
+  end
+end

data/lib/polonium/dsl/test_unit_dsl.rb

@@ -0,0 +1,58 @@
+module Polonium
+  module TestUnitDsl
+    include SeleniumDsl
+    class << self
+      def page_assertion(name)
+        module_eval(
+          "def assert_#{name}(value, params={})\n" +
+          "  page.assert_#{name}(value, params)\n" +
+          "end",
+          __FILE__,
+          __LINE__ - 4
+        )
+      end
+
+      def element_assertion(name)
+        module_eval(
+          "def assert_#{name}(locator, *args)\n" +
+          "  element(locator).assert_#{name}(*args)\n" +
+          "end",
+          __FILE__,
+          __LINE__ - 4
+        )
+      end
+    end
+
+    page_assertion :title
+    page_assertion :text_present
+    page_assertion :text_not_present
+    page_assertion :location_ends_with
+    deprecate :assert_location_ends_in, :assert_location_ends_with
+
+    element_assertion :value
+    element_assertion :attribute   # yes, it's a little weird... in this case element is really an attribute
+    element_assertion :selected
+    element_assertion :checked
+    element_assertion :not_checked
+    element_assertion :text
+    element_assertion :element_present
+    element_assertion :element_not_present
+    element_assertion :next_sibling
+    element_assertion :contains_in_order
+    element_assertion :visible
+    element_assertion :not_visible
+
+    # Assert and wait for locator element to contain text.
+    def assert_element_contains(locator, text, options = {})
+      element(locator).assert_contains(text, options)
+    end
+
+    # Assert and wait for locator element to not contain text.
+    def assert_element_does_not_contain(locator, text, options={})
+      element(locator).assert_does_not_contain(text, options)
+    end
+    deprecate :assert_element_does_not_contain_text, :assert_element_does_not_contain
+    deprecate :wait_for_element_to_not_contain_text, :assert_element_does_not_contain
+    deprecate :wait_for_text_in_order, :assert_contains_in_order
+  end
+end

data/lib/polonium/element.rb

@@ -0,0 +1,207 @@
+module Polonium
+  class Element
+    include WaitFor
+    attr_reader :driver, :locator
+
+    def initialize(driver, locator)
+      @driver = driver
+      @locator = locator
+    end
+
+    def assert_element_present(params={})
+      driver.wait_for_is_element_present(locator, params)
+    end
+
+    def assert_element_not_present(params={})
+      driver.wait_for_is_element_not_present(locator, params)
+    end
+
+    def assert_value(expected_value)
+      assert_element_present
+      wait_for do |configuration|
+        actual_value = driver.get_value(locator)
+        configuration.message = "Expected '#{locator}' to be '#{expected_value}' but was '#{actual_value}'"
+        has_value? expected_value, actual_value
+      end
+    end
+
+    def assert_attribute(expected_value)
+      assert_element_present
+      wait_for do |configuration|
+        actual = driver.get_attribute(locator)  #todo: actual value
+        configuration.message = "Expected attribute '#{locator}' to be '#{expected_value}' but was '#{actual}'"
+        expected_value == actual
+      end
+    end
+
+    def assert_selected(expected_value)
+      assert_element_present
+      wait_for do |configuration|
+        actual = driver.get_selected_label(locator)
+        configuration.message = "Expected '#{locator}' to be selected with '#{expected_value}' but was '#{actual}"
+        expected_value == actual
+      end
+    end
+
+    def assert_visible(options={})
+      assert_element_present
+      options = {
+        :message => "Expected '#{locator}' to be visible, but it wasn't"
+      }.merge(options)
+      wait_for(options) do
+        driver.is_visible(locator)
+      end
+    end
+
+    def assert_not_visible(options={})
+      assert_element_present
+      options = {
+        :message => "Expected '#{locator}' to be hidden, but it wasn't"
+      }.merge(options)
+      wait_for(options) do
+        !driver.is_visible(locator)
+      end
+    end
+
+    def assert_checked
+      assert_element_present
+      wait_for(:message => "Expected '#{locator}' to be checked") do
+        driver.is_checked(locator)
+      end
+    end
+
+    def assert_not_checked
+      assert_element_present
+      wait_for(:message => "Expected '#{locator}' to be checked") do
+        !driver.is_checked(locator)
+      end
+    end
+
+    def assert_text(expected_text, options={})
+      assert_element_present
+      wait_for(options) do |configuration|
+        actual = driver.get_text(locator)
+        configuration.message = "Expected text '#{expected_text}' to be full contents of #{locator} but was '#{actual}')"
+        expected_text == actual
+      end
+    end
+
+    def assert_contains(expected_text, options={})
+      return assert_contains_in_order(*expected_text) if expected_text.is_a? Array
+      assert_element_present
+      options = {
+        :message => "#{locator} should contain #{expected_text}"
+      }.merge(options)
+      wait_for(options) do
+        contains?(expected_text)
+      end
+    end
+
+    def assert_does_not_contain(expected_text, options={})
+      assert_element_present
+      wait_for(options) do
+        !inner_html.include?(expected_text)
+      end
+    end
+
+    def assert_next_sibling(expected_sibling_id, options = {})
+      assert_element_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 = driver.get_eval(eval_js)
+        expected_sibling_id == actual_sibling_id
+      end
+    end
+
+    def assert_contains_in_order(*text_fragments)
+      assert_element_present
+      wait_for do |configuration|
+        success = false
+
+        html = driver.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?
+          configuration.message = "Certain fragments weren't found:\n" <<
+                            "#{fragments_not_found.join("\n")}\n" <<
+                            "\nhtml follows:\n #{html}\n"
+        elsif !fragments_out_of_order.empty?
+          configuration.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 is_present?
+      driver.is_element_present(locator)
+    end
+
+    def is_not_present?
+      !driver.is_element_present(locator)
+    end
+
+    def has_value?(expected_value, actual_value=driver.get_value(locator))
+      expected_value == actual_value
+    end
+
+    def inner_html
+      driver.get_inner_html(locator)
+    end
+
+    def contains?(text)
+      inner_html.include?(text)
+    end
+
+    def ==(other)
+      return false unless other.is_a?(Element)
+      return false unless self.driver == other.driver
+      return false unless self.locator == other.locator
+      true
+    end
+
+    protected
+    def method_missing(method_name, *args, &blk)
+      if driver.respond_to?(method_name)
+        driver_args = [locator] + args
+        driver.__send__(method_name, *driver_args, &blk)
+      else
+        super
+      end
+    end
+    
+    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/polonium/extensions/module.rb

@@ -0,0 +1,8 @@
+class Module
+  def deprecate(old_method_name, new_method_name)
+    define_method old_method_name do |*args|
+      warn "#{old_method_name} is deprecated. Use #{new_method_name} instead."
+      __send__(new_method_name, *args)
+    end
+  end
+end

data/lib/polonium/extensions/testrunnermediator.rb

@@ -0,0 +1,22 @@
+class Test::Unit::UI::TestRunnerMediator
+  alias_method :run_suite_without_seleniumrc, :run_suite
+  def run_suite_with_seleniumrc
+    start_app_server
+    result = run_suite_without_seleniumrc
+    stop_app_server(result)
+    result
+  end
+  alias_method :run_suite, :run_suite_with_seleniumrc
+
+  protected
+  def start_app_server
+    @selenium_driver = Polonium::Configuration.instance
+    @app_runner = @selenium_driver.create_server_runner
+    @app_runner.start
+  end
+
+  def stop_app_server(result)
+    @app_runner.stop
+    @selenium_driver.stop_driver_if_necessary(result.passed?)
+  end
+end

data/lib/polonium/mongrel_selenium_server_runner.rb

@@ -0,0 +1,37 @@
+module Polonium
+  class MongrelSeleniumServerRunner < ServerRunner
+    def start
+      mongrel_configurator = configuration.create_mongrel_configurator
+      initialize_server(mongrel_configurator)
+
+      @thread_class.start do
+        start_server(mongrel_configurator)
+      end
+      @started = true
+    end
+
+    protected
+    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]} ..."
+        mongrel.uri "/", :handler => mongrel.rails
+        mongrel.log "Rails loaded."
+
+        mongrel.log "Loading any Rails specific GemPlugins"
+        mongrel.load_plugins
+        configuration.app_server_initialization.call(mongrel)
+      end
+    end
+
+    def stop_server
+    end
+  end
+end

data/lib/polonium/page.rb

@@ -0,0 +1,84 @@
+module Polonium
+  class Page
+    include WaitFor
+    attr_reader :driver
+    PAGE_LOADED_COMMAND = "this.browserbot.getDocument().body ? true : false"
+
+    def initialize(driver)
+      @driver = driver
+    end
+
+    def open(url)
+      driver.open(url)
+    end
+    alias_method :open_and_wait, :open
+
+    def assert_title(expected_title, params = {})
+      wait_for(params) do |configuration|
+        actual_title = title
+        configuration.message = "Expected title '#{expected_title}' but was '#{actual_title}'"
+        expected_title == actual_title
+      end
+    end
+    def title
+      driver.get_title
+    end
+
+    def assert_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? && driver.is_text_present(expected_text)
+    end
+
+    def assert_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? && !driver.is_text_present(unexpected_text)
+    end
+
+    def page_loaded?
+      driver.get_eval(PAGE_LOADED_COMMAND) == true.to_s
+    end
+
+    def assert_location_ends_with(ends_with, options  ={})
+      options = {
+        :message => "Expected '#{driver.get_location}' to end with '#{ends_with}'"
+      }.merge(options)
+      wait_for(options) do
+        location_ends_with? ends_with
+      end
+    end
+    def location_ends_with?(ends_with)
+      if driver.get_location =~ Regexp.new("#{Regexp.escape(ends_with)}$")
+        true
+      else
+        false
+      end
+    end
+
+    def ==(other)
+      return false unless other.is_a?(Page)
+      self.driver == other.driver
+    end
+
+    def method_missing(method_name, *args, &blk)
+      if driver.respond_to?(method_name)
+        driver.__send__(method_name, *args, &blk)
+      else
+        super
+      end
+    end
+  end
+end