seleniumrc 0.0.1 → 0.0.2

data/lib/seleniumrc/selenium_driver.rb

@@ -0,0 +1,193 @@
+module Seleniumrc
+  class SeleniumDriver < ::Selenium::SeleniumDriver
+    include WaitFor
+    attr_reader :server_host, :server_port
+
+    def browser_start_command
+      @browserStartCommand
+    end
+
+    def browser_url
+      @browserURL
+    end
+
+    def timeout_in_milliseconds
+      @timeout
+    end
+
+    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
+
+    def element(locator)
+      SeleniumElement.new(self, locator)
+    end
+
+    def page
+      SeleniumPage.new(self)
+    end
+
+    #--------- Commands
+    alias_method :confirm, :get_confirmation
+
+    # Type text into a page element
+    def type(locator, value)
+      wait_for_is_element_present(locator)
+      super
+    end
+
+    # Reload the current page that the browser is on.
+    def reload
+      get_eval("selenium.browserbot.getCurrentWindow().location.reload()")
+    end
+
+    def click(locator)
+      wait_for_is_element_present(locator)
+      super
+    end
+    alias_method :wait_for_and_click, :click
+
+    def select(select_locator, option_locator)
+      wait_for_is_element_present(select_locator)
+      super
+    end
+    
+    # Click a link and wait for the page to load.
+    def click_and_wait(locator, wait_for = default_timeout)
+      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
+      go_back
+      wait_for_page_to_load
+    end
+
+    # Open the home page of the Application and wait for the page to load.
+    def open(url)
+      super
+      wait_for_page_to_load
+    end
+    alias_method :open_and_wait, :open
+
+    # Get the inner html of the located element.
+    def get_inner_html(locator)
+      get_eval(inner_html_js(locator))
+    end
+
+    # Does the element at locator contain the text?
+    def element_contains_text(locator, text)
+      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 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_is_element_present(locator, params={})
+      params = {
+        :message => "Expected element '#{locator}' to be present, but it was not"
+      }.merge(params)
+      wait_for(params) do
+        is_element_present(locator)
+      end
+    end
+
+    def wait_for_is_element_not_present(locator, params={})
+      params = {
+        :message => "Expected element '#{locator}' to be absent, but it was not"
+      }.merge(params)
+      wait_for(:message => params[:message]) do
+        !is_element_present(locator)
+      end
+    end
+
+    def wait_for_page_to_load(timeout=default_timeout)
+      super
+      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) do
+        element_contains_text(locator, text)
+      end
+    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 inner_html_js(locator)
+      %Q|this.page().findElement("#{locator}").innerHTML|
+    end
+  end
+end

data/lib/seleniumrc/selenium_element.rb

@@ -1,59 +1,53 @@
 module Seleniumrc
   class SeleniumElement
     include WaitFor
-    attr_reader :selenium, :locator
+    attr_reader :driver, :locator
 
-    def initialize(selenium, locator)
-      @selenium = selenium
+    def initialize(driver, locator)
+      @driver = driver
       @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
+      driver.wait_for_is_element_present(locator, params)
     end
     def is_present?
-      selenium.is_element_present(locator)
+      driver.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
+      driver.wait_for_is_element_not_present(locator, params)
     end
     def is_not_present?
-      !selenium.is_element_present(locator)
+      !driver.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}'"
+      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 has_value?(expected_value, actual_value=selenium.get_value(locator))
+    def has_value?(expected_value, actual_value=driver.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}'"
+      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 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}"
+      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
@@ -64,7 +58,7 @@ module Seleniumrc
         :message => "Expected '#{locator}' to be visible, but it wasn't"
       }.merge(options)
       wait_for(options) do
-        selenium.is_visible(locator)
+        driver.is_visible(locator)
       end
     end
 
@@ -74,29 +68,29 @@ module Seleniumrc
         :message => "Expected '#{locator}' to be hidden, but it wasn't"
       }.merge(options)
       wait_for(options) do
-        !selenium.is_visible(locator)
+        !driver.is_visible(locator)
       end
     end
 
     def is_checked
       is_present
       wait_for(:message => "Expected '#{locator}' to be checked") do
-        selenium.is_checked(locator)
+        driver.is_checked(locator)
       end
     end
 
     def is_not_checked
       is_present
       wait_for(:message => "Expected '#{locator}' to be checked") do
-        !selenium.is_checked(locator)
+        !driver.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}')"
+      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
@@ -122,27 +116,27 @@ module Seleniumrc
       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)
+        actual_sibling_id = driver.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|
+      wait_for do |configuration|
         success = false
 
-        html = selenium.get_text(locator)
+        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?
-          context.message = "Certain fragments weren't found:\n" <<
+          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?
-          context.message = "Certain fragments were out of order:\n" <<
+          configuration.message = "Certain fragments were out of order:\n" <<
                             "#{fragments_out_of_order.join("\n")}\n" <<
                             "\nhtml follows:\n #{html}\n"
         else
@@ -154,12 +148,12 @@ module Seleniumrc
     end
 
     def inner_html
-      selenium.get_eval("this.page().findElement(\"#{locator}\").innerHTML")
+      driver.get_inner_html(locator)
     end
 
     def ==(other)
       return false unless other.is_a?(SeleniumElement)
-      return false unless self.selenium == other.selenium
+      return false unless self.driver == other.driver
       return false unless self.locator == other.locator
       true
     end

data/lib/seleniumrc/selenium_page.rb

@@ -1,26 +1,26 @@
 module Seleniumrc
   class SeleniumPage
     include WaitFor
-    attr_reader :selenium
+    attr_reader :driver
     PAGE_LOADED_COMMAND = "this.browserbot.getDocument().body ? true : false"
 
-    def initialize(selenium)
-      @selenium = selenium
+    def initialize(driver)
+      @driver = driver
     end
 
-    def open_and_wait(url)
-      selenium.open(url)
-      wait_for_page_to_load
+    def open(url)
+      driver.open(url)
     end
+    alias_method :open_and_wait, :open
 
     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}'"
+      wait_for(params) do |configuration|
+        actual_title = driver.get_title
+        configuration.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)
+    def has_title?(expected_title, actual_title=driver.get_title)
       expected_title == actual_title
     end
 
@@ -33,7 +33,7 @@ module Seleniumrc
       end
     end
     def is_text_present?(expected_text)
-      page_loaded? && selenium.is_text_present(expected_text)
+      page_loaded? && driver.is_text_present(expected_text)
     end
 
     def is_text_not_present(unexpected_text, options = {})
@@ -45,23 +45,23 @@ module Seleniumrc
       end
     end
     def is_text_not_present?(unexpected_text)
-      page_loaded? && !selenium.is_text_present(unexpected_text)
+      page_loaded? && !driver.is_text_present(unexpected_text)
     end
 
     def page_loaded?
-      selenium.get_eval(PAGE_LOADED_COMMAND) == true.to_s
+      driver.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}'"
+        :message => "Expected '#{driver.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)}$")
+      if driver.get_location =~ Regexp.new("#{Regexp.escape(ends_with)}$")
         true
       else
         false
@@ -70,7 +70,7 @@ module Seleniumrc
 
     def ==(other)
       return false unless other.is_a?(SeleniumPage)
-      self.selenium == other.selenium
+      self.driver == other.driver
     end
   end
 end

data/lib/seleniumrc/selenium_server_runner.rb

@@ -1,6 +1,6 @@
 module Seleniumrc
   class SeleniumServerRunner
-    attr_accessor :context, :thread_class
+    attr_accessor :configuration, :thread_class
     def initialize
       @started = false
     end