rwebunit 0.1.1 → 0.2.0

data/lib/rwebunit/web_tester.rb

@@ -8,386 +8,403 @@ require 'runit/assert'
 
 module RWebUnit
 
-##
-#  Wrapping WATIR and provide assertions
-#
-class WebTester 
-  include Watir::Simple
-  include RUNIT::Assert
-
-  attr_accessor :test_context
-
-  def initialize
-    @test_context = TestContext.new
-  end
-
-  def beginAt(relativeURL)
-    url = @test_context.base_url  + relativeURL
-    new_browser_at(url) # create @@browser
-  end
-
-  def closeBrowser
-    begin
-     close_browser
-    rescue 
-    end
-  end
-
-
-  def goBack
-    go_back()
-  end
-
-  def goForward
-    go_forward()
-  end
-
-  def gotoPage(page)
-    navigate_to(page)
-  end
-
-  # assertions
-  def assertTitleEquals(title)
-    assert_equals(title, html_title())
-  end
-
-  # text fields
-  def setFormElement(elementName, elementValue)
-     enter_text_into_field_with_name(elementName, elementValue)
-  end
-  alias enterText setFormElement
-
-  def assertTextPresentInTextField(textfieldName, text, msg = nil)
-    assert_text_in_field(textfieldName, text, msg)
-  end
-
-  #links
-  def clickLink(linkId)
-    click_link_with_id(linkId)
-  end
-
-  def clickLinkWithText(linkText)
-    click_link_with_text(linkText)
-  end
-
-  def assertLinkPresentWithExactText(linkText)
-    html_links.each { |link|
-      return if linkText == link.text
-    }
-    fail( "can't find the link with text: #{linkText}")
-  end
-
-  def assertLinkNotPresentWithExactText(linkText)
-    html_links.each { |link|
-      assert(linkText != link.text, "unexpected link (exact): #{linkText} found")
-    }
-  end
-
-  def assertLinkPresentWithText(linkText)
-    html_links.each { |link|
-      return if link.text.include?(linkText)
-    }
-    fail( "can't find the link containing text: #{linkText}")
-  end
-
-  def assertLinkNotPresentWithText(linkText)
-    html_links.each { |link|
-      assert(!link.Text.include?(linkText), "unexpected link containing: #{linkText} found")
-    }
-  end
-
-
-  ##
-  # buttons
-
-  # submit first submit button
-  def submit(buttonName = nil)
-    if (buttonName.nil?) then
-      html_buttons.each { |button|
-        next if button.type != 'submit'
-        button.click
-        return
-      }
-    else
-      click_button_with_name(buttonName)
-    end
-  end
-
-  def clickButton(buttonId)
-    click_button_with_id(buttonId)
-  end
-
-  def clickButtonWithCaption(caption)
-    click_button_with_caption(caption)
-  end
-
-  def clickButtonWithValue(value)
-    click_button_with_value(value)
-  end
-
-  def assertButtonNotPresent(buttonId)
-   html_buttons.each { |button|
-     assert(button.id != buttonId, "unexpected button id: #{buttonId} found")
-   }
-  end
-
-  def assertButtonNotPresentWithText(text) 
-   html_buttons.each { |button|
-     assert(button.value != text, "unexpected button id: #{text} found")
-   }
-  end
- 
-  def assertButtonPresent(buttonID) 
-   html_buttons.each { |button|
-      return if buttonID == button.id
-   }
-   assert(false, "can't find the button with id: #{buttonID}")
-  end
-
-  def assertButtonPresentWithText(buttonText)
-   html_buttons.each { |button|
-      return if buttonText == button.value
-   }
-   assert(false, "can't find the button with text: #{buttonText}")
-  end
-
-  # checkbox
-  def checkCheckbox(checkBoxName)
-    @@browser.checkbox(:name, checkBoxName).set
-  end
-
-  def uncheckCheckbox(checkBoxName)
-    @@browser.checkbox(:name, checkBoxName).clear
-  end
-
-  def assertCheckboxNotSelected(checkBoxName)
-    html_checkboxes.each { |checkbox|
-       if (checkbox.name == checkBoxName) then
-         assert(!checkbox.isSet?, "Checkbox #{checkBoxName} checked unexpected")
-       end
-    }
-  end
-
-  def assertCheckboxSelected(checkBoxName)
-    html_checkboxes.each { |checkbox|
-       if (checkbox.name == checkBoxName) then
-         assert(checkbox.isSet?, "Checkbox #{checkBoxName} not checked")
-       end
-    }
-  end
-
-  # combo box
-  def selectOption(selectName, option)
-    @@browser.select_from_combobox_with_name(selectName, option)
-  end
-
-  def assertOptionValueNotPresent(selectName, optionValue)
-    html_selects.each { |select|
-      continue unless select.name == selectName
-      select.o.each do |option| # items in the list
-        assert(!(option.value == optionValue), "unexpected select option: #{optionValue} for #{selectName} found")
-      end
-    }
-  end
-
-  def assertOptionNotPresent(selectName, optionLabel)
-    html_selects.each { |select|
-      next unless select.name == selectName
-      select.o.each do |option| # items in the list
-        assert(!(option.text == optionLabel), "unexpected select option: #{optionLabel} for #{selectName} found")
-      end
-    }
-  end
-
-
-  def assertOptionValuePresent(selectName, optionValue)
-    html_selects.each { |select|
-     next unless select.name == selectName
-     select.o.each do |option| # items in the list
-       return if option.value == optionValue
-      end
-    }
-    assert(false, "can't find the combob box with value: #{optionValue}")
-  end
-
-  def assertOptionPresent(selectName, optionLabel)
-    html_selects.each { |select|
-     next unless select.name == selectName
-     select.o.each do |option| # items in the list
-       return if option.text == optionLabel
-      end
-    }
-    assert(false, "can't find the combob box: #{selectName} with value: #{optionLabel}")
-  end
-
-  def assertOptionEquals(selectName, optionLabel)
-    html_selects.each { |select|
-      next unless select.name == selectName
-        select.o.each do |option| # items in the list
-          if (option.text == optionLabel) then
-            assert_equal(select.value, option.value, "Select #{selectName}'s value is not equal to expected option label: '#{optionLabel}'")
-          end
-        end
-    }
-  end
-
-
-  def assertOptionValueEquals(selectName, optionValue)
-    html_selects.each { |select|
-      next unless select.name == selectName
-      assert_equal(select.value, optionValue, "Select #{selectName}'s value is not equal to expected: '#{optionValue}'")
-    }
-  end
-
-
-  #radio
-
-  # radioGroup is the name field, radio options 'value' field
-  def assertRadioOptionNotPresent(radioGroup, radioOption)
-     html_radios.each { |radio|
-        if (radio.name == radioGroup) then
-          assert(!(radioOption == radio.value), "unexpected radio option: " + radioOption  + " found")
-        end
-     }
-  end
-
-  def assertRadioOptionPresent(radioGroup, radioOption)
-     html_radios.each { |radio|
-        return if (radio.name == radioGroup) and (radioOption == radio.value)
-     }
-     fail("can't find the radio option : '#{radioOption}'")
-  end
-
-  def assertRadioOptionSelected(radioGroup, radioOption)
-     html_radios.each { |radio|
-       if (radio.name == radioGroup and radioOption == radio.value) then
-         assert(radio.isSet?, "Radio button #{radioGroup}-[#{radioOption}] not checked")
-       end
-     }
-  end
-
-  def assertRadioOptionNotSelected(radioGroup, radioOption)
-     html_radios.each { |radio|
-       if (radio.name == radioGroup and radioOption == radio.value) then
-         assert(!radio.isSet?, "Radio button #{radioGroup}-[#{radioOption}] checked unexpected")
-       end
-     }
-  end
-
-  # the method is protected in JWebUnit
-  def clickRadioOption(radioGroup, radioOption)
-    html_radios.each { |radio|
-       if (radio.name == radioGroup and radioOption == radio.value) then
-         radio.set
-       end
-    }
-  end
-
-  #text
-  def assertTextPresent(text)
-    assert((html_body().include? text), 'expected text: ' + text + ' not found')
-  end
-
-  def assertTextNotPresent(text)
-    assert(!(html_body().include? text), 'expected text: ' + text + ' found')
-  end
-
-
-  def assertTextInTable(tableId, text)
-     elem = @@browser.document.getElementById(tableId)
-     assert_not_nil(elem, "tableId #{tableId} not exists")
-     assert_equal(elem.tagName, "TABLE")
-     puts elem.innerHTML if $DEBUG
-     assert(elem.innerHTML.include?(text), "the text #{text} not found in table #{tableId}")
-  end
-
-  def assertTextNotInTable(tableId, text)
-     elem = @@browser.document.getElementById(tableId)
-     assert_equal(elem.name.uppercase, "TABLE")
-     assert_not_nil(elem, "tableId #{tableId} not exists")
-     assert(!elem.innerHTML.include?(text), "unexpected text #{text} found in table #{tableId}")
-  end
-
-  def assertElementPresent(elementID)
-     elem = @@browser.document.getElementById(elementID)
-     assert_not_nil(elem)
-  end
-
-  def assertElementNotPresent(elementID)
-     elem = @@browser.document.getElementById(elementID)
-     assert_nil(elem)
-  end
-
-  def assertTextInElement(elementID, text)
-    elem = @@browser.document.getElementById(elementID)
-    assert_not_nil(elem.innerText)
-    assert(elem.innerText.include?(text))
-  end
-
-  def getElementValue(elementId)
-    elem = @@browser.document.getElementById(elementId)
-    return nil if elem == nil
-    elem_val = elem.invoke('innerText')
-    return elem_val
-  end
-
-  # ---
-  # For deubgging
-  # ---
-  def dumpResponse(stream = nil)
-    if stream.nil?
-      puts html_body # std out
-    else
-      stream.puts html_body
-    end
-  end
-
-private
-  def html_body
-    @@browser.html()
-  end
-
-  def html_title
-    @@browser.document.title
-  end
-
-  def html_links
-    @@browser.links
-  end
-
-  def html_buttons
-    @@browser.buttons
-  end
-
-  def html_selects
-    @@browser.select_lists
-  end
-
-  def html_checkboxes
-    @@browser.checkboxes
-  end
-
-  def html_radios
-    @@browser.radios
-  end
-
-  def assert_equals(expected, actual, msg=nil)
-    assert(expected == actual, (msg.nil?) ? "Expected: #{expected} diff from actual: #{actual}" : msg)
-  end
-  alias assert_equal assert_equals
-
-  def assert_nil(actual, msg="")
-    assert(actual.nil?, msg)
-  end
-
-  def assert_not_nil(actual, msg="")
-    assert(!actual.nil?, msg)
-  end
-
-  def fail(message)
-    assert(false, message)
-  end
+   ##
+   #  Wrapping WATIR and provide assertions
+   #
+   class WebTester
+      include Watir::Simple
+      include RUNIT::Assert
 
-end
+      attr_accessor :test_context
+
+      def initialize
+         @test_context = TestContext.new
+      end
+
+      def beginAt(relativeURL)
+         url = @test_context.base_url  + relativeURL
+         new_browser_at(url) # create @@browser
+      end
+
+      def closeBrowser
+         begin
+            close_browser
+         rescue
+         end
+      end
+
+      def browser_opened?
+         begin
+            @@browser != nil
+         rescue => e
+            return false
+         end
+      end
+
+      def goBack
+         go_back()
+      end
+
+      def goForward
+         go_forward()
+      end
+
+      def gotoPage(page)
+         navigate_to(page)
+      end
+
+      # assertions
+      def assertTitleEquals(title)
+         assert_equals(title, html_title())
+      end
+
+      # text fields
+      def setFormElement(elementName, elementValue)
+         enter_text_into_field_with_name(elementName, elementValue)
+      end
+      alias enterText setFormElement
+
+      def assertTextPresentInTextField(textfieldName, text, msg = nil)
+         assert_text_in_field(textfieldName, text, msg)
+      end
+
+      #links
+      def clickLink(linkId)
+         click_link_with_id(linkId)
+      end
+
+      def clickLinkWithText(linkText)
+         click_link_with_text(linkText)
+      end
+
+      def assertLinkPresentWithExactText(linkText)
+         html_links.each { |link|
+            return if linkText == link.text
+         }
+         fail( "can't find the link with text: #{linkText}")
+      end
+
+      def assertLinkNotPresentWithExactText(linkText)
+         html_links.each { |link|
+            assert(linkText != link.text, "unexpected link (exact): #{linkText} found")
+         }
+      end
+
+      def assertLinkPresentWithText(linkText)
+         html_links.each { |link|
+            return if link.text.include?(linkText)
+         }
+         fail( "can't find the link containing text: #{linkText}")
+      end
+
+      def assertLinkNotPresentWithText(linkText)
+         html_links.each { |link|
+            assert(!link.Text.include?(linkText), "unexpected link containing: #{linkText} found")
+         }
+      end
+
+
+      ##
+      # buttons
+
+      # submit first submit button
+      def submit(buttonName = nil)
+         if (buttonName.nil?) then
+            html_buttons.each { |button|
+               next if button.type != 'submit'
+               button.click
+               return
+            }
+         else
+            click_button_with_name(buttonName)
+         end
+      end
+
+      def clickButton(buttonId)
+         click_button_with_id(buttonId)
+      end
+
+      def clickButtonWithCaption(caption)
+         click_button_with_caption(caption)
+      end
+
+      def clickButtonWithValue(value)
+         click_button_with_value(value)
+      end
+
+      def assertButtonNotPresent(buttonId)
+         html_buttons.each { |button|
+            assert(button.id != buttonId, "unexpected button id: #{buttonId} found")
+         }
+      end
+
+      def assertButtonNotPresentWithText(text)
+         html_buttons.each { |button|
+            assert(button.value != text, "unexpected button id: #{text} found")
+         }
+      end
+
+      def assertButtonPresent(buttonID)
+         html_buttons.each { |button|
+            return if buttonID == button.id
+         }
+         assert(false, "can't find the button with id: #{buttonID}")
+      end
+
+      def assertButtonPresentWithText(buttonText)
+         html_buttons.each { |button|
+            return if buttonText == button.value
+         }
+         assert(false, "can't find the button with text: #{buttonText}")
+      end
+
+      # checkbox
+      def checkCheckbox(checkBoxName)
+         @@browser.checkbox(:name, checkBoxName).set
+      end
+
+      def uncheckCheckbox(checkBoxName)
+         @@browser.checkbox(:name, checkBoxName).clear
+      end
+
+      def assertCheckboxNotSelected(checkBoxName)
+         html_checkboxes.each { |checkbox|
+            if (checkbox.name == checkBoxName) then
+               assert(!checkbox.isSet?, "Checkbox #{checkBoxName} checked unexpected")
+            end
+         }
+      end
+
+      def assertCheckboxSelected(checkBoxName)
+         html_checkboxes.each { |checkbox|
+            if (checkbox.name == checkBoxName) then
+               assert(checkbox.isSet?, "Checkbox #{checkBoxName} not checked")
+            end
+         }
+      end
+
+      # combo box
+      def selectOption(selectName, option)
+         @@browser.select_from_combobox_with_name(selectName, option)
+      end
+
+      def assertOptionValueNotPresent(selectName, optionValue)
+         html_selects.each { |select|
+            continue unless select.name == selectName
+            select.o.each do |option| # items in the list
+               assert(!(option.value == optionValue), "unexpected select option: #{optionValue} for #{selectName} found")
+            end
+         }
+      end
+
+      def assertOptionNotPresent(selectName, optionLabel)
+         html_selects.each { |select|
+            next unless select.name == selectName
+            select.o.each do |option| # items in the list
+               assert(!(option.text == optionLabel), "unexpected select option: #{optionLabel} for #{selectName} found")
+            end
+         }
+      end
+
+
+      def assertOptionValuePresent(selectName, optionValue)
+         html_selects.each { |select|
+            next unless select.name == selectName
+            select.o.each do |option| # items in the list
+               return if option.value == optionValue
+            end
+         }
+         assert(false, "can't find the combob box with value: #{optionValue}")
+      end
 
-end
+      def assertOptionPresent(selectName, optionLabel)
+         html_selects.each { |select|
+            next unless select.name == selectName
+            select.o.each do |option| # items in the list
+               return if option.text == optionLabel
+            end
+         }
+         assert(false, "can't find the combob box: #{selectName} with value: #{optionLabel}")
+      end
+
+      def assertOptionEquals(selectName, optionLabel)
+         html_selects.each { |select|
+            next unless select.name == selectName
+            select.o.each do |option| # items in the list
+               if (option.text == optionLabel) then
+                  assert_equal(select.value, option.value, "Select #{selectName}'s value is not equal to expected option label: '#{optionLabel}'")
+               end
+            end
+         }
+      end
+
+
+      def assertOptionValueEquals(selectName, optionValue)
+         html_selects.each { |select|
+            next unless select.name == selectName
+            assert_equal(select.value, optionValue, "Select #{selectName}'s value is not equal to expected: '#{optionValue}'")
+         }
+      end
+
+
+      #radio
+
+      # radioGroup is the name field, radio options 'value' field
+      def assertRadioOptionNotPresent(radioGroup, radioOption)
+         html_radios.each { |radio|
+            if (radio.name == radioGroup) then
+               assert(!(radioOption == radio.value), "unexpected radio option: " + radioOption  + " found")
+            end
+         }
+      end
+
+      def assertRadioOptionPresent(radioGroup, radioOption)
+         html_radios.each { |radio|
+            return if (radio.name == radioGroup) and (radioOption == radio.value)
+         }
+         fail("can't find the radio option : '#{radioOption}'")
+      end
+
+      def assertRadioOptionSelected(radioGroup, radioOption)
+         html_radios.each { |radio|
+            if (radio.name == radioGroup and radioOption == radio.value) then
+               assert(radio.isSet?, "Radio button #{radioGroup}-[#{radioOption}] not checked")
+            end
+         }
+      end
+
+      def assertRadioOptionNotSelected(radioGroup, radioOption)
+         html_radios.each { |radio|
+            if (radio.name == radioGroup and radioOption == radio.value) then
+               assert(!radio.isSet?, "Radio button #{radioGroup}-[#{radioOption}] checked unexpected")
+            end
+         }
+      end
+
+      # the method is protected in JWebUnit
+      def clickRadioOption(radioGroup, radioOption)
+         html_radios.each { |radio|
+            if (radio.name == radioGroup and radioOption == radio.value) then
+               radio.set
+            end
+         }
+      end
+
+      #text
+      def assertTextPresent(text)
+         assert((html_body().include? text), 'expected text: ' + text + ' not found')
+      end
+
+      def assertTextNotPresent(text)
+         assert(!(html_body().include? text), 'expected text: ' + text + ' found')
+      end
+
+
+      def assertTextInTable(tableId, text)
+         elem = @@browser.document.getElementById(tableId)
+         assert_not_nil(elem, "tableId #{tableId} not exists")
+         assert_equal(elem.tagName, "TABLE")
+         puts elem.innerHTML if $DEBUG
+         assert(elem.innerHTML.include?(text), "the text #{text} not found in table #{tableId}")
+      end
+
+      def assertTextNotInTable(tableId, text)
+         elem = @@browser.document.getElementById(tableId)
+         assert_equal(elem.name.uppercase, "TABLE")
+         assert_not_nil(elem, "tableId #{tableId} not exists")
+         assert(!elem.innerHTML.include?(text), "unexpected text #{text} found in table #{tableId}")
+      end
+
+      def assertElementPresent(elementID)
+         assert_not_nil(@@browser.document.getElementById(elementID), "element with id #{elementID} not found")
+      end
+
+      def assertElementNotPresent(elementID)
+         assert_nil(@@browser.document.getElementById(elementID), "unexpected element with id #{elementID} found")
+      end
+
+      def assertTextInElement(elementID, text)
+         assertElementPresent(elementID)
+         elem = @@browser.document.getElementById(elementID)
+         assert_not_nil(elem.innerText, "element #{elementID} has no text")
+         assert(elem.innerText.include?(text), "the text #{text} not found in element #{elementID}")
+      end
+
+      def getElementValue(elementId)
+         assertElementPresent(elementId)
+         elem = @@browser.document.getElementById(elementId)
+         elem_val = elem.invoke('innerText')
+      end
+
+      # new API
+      def getHtmlInElement(elementId)
+         elem = @@browser.document.getElementById(elementId)
+         assert_not_nil(elem, "HTML element: #{elementId} not exists")
+         elem.innerHTML
+      end
+
+      def getElementById(elementId)
+         elem = @@browser.document.getElementById(elementId)
+      end
+
+
+      # ---
+      # For deubgging
+      # ---
+      def dumpResponse(stream = nil)
+         if stream.nil?
+            puts html_body # std out
+         else
+            stream.puts html_body
+         end
+      end
+
+      private
+      def html_body
+         @@browser.html()
+      end
+
+      def html_title
+         @@browser.document.title
+      end
+
+      def html_links
+         @@browser.links
+      end
+
+      def html_buttons
+         @@browser.buttons
+      end
+
+      def html_selects
+         @@browser.select_lists
+      end
+
+      def html_checkboxes
+         @@browser.checkboxes
+      end
+
+      def html_radios
+         @@browser.radios
+      end
+
+      def assert_equals(expected, actual, msg=nil)
+         assert(expected == actual, (msg.nil?) ? "Expected: #{expected} diff from actual: #{actual}" : msg)
+      end
+      alias assert_equal assert_equals
+
+      def assert_nil(actual, msg="")
+         assert(actual.nil?, msg)
+      end
+
+      def assert_not_nil(actual, msg="")
+         assert(!actual.nil?, msg)
+      end
+
+      def fail(message)
+         assert(false, message)
+      end
+
+   end
+
+end