rwebunit 0.2.0 → 0.7.2

data/CHANGELOG

@@ -1,35 +1,110 @@
-CHANGELOG
-=========
-
-== 0.2.0
-
-Added wait_ajax
-?Reuse IE instance cross testcases
-
-== 0.1.1
-
-New jWebUnit API methods implemented:
-  assertOptionEquals(selectName, optionLabel)
-  assertOptionValueEquals(selectName, optionValue)
-  assertCheckboxNotSelected(checkBoxName)
-  assertCheckboxSelected(checkBoxName)
-  assertLinkPresentWithExactText(linkText)
-  assertLinkNotPresentWithExactText(linkText)
-  assertRadioOptionNotPresent(radioGroup, radioOption)
-  assertRadioOptionPresent(radioGroup, radioOption)
-  assertRadioOptionSelected(radioGroup, radioOption)
-  assertRadioOptionNotSelected(radioGroup, radioOption)
-  assertTextInTable(tableId, text)
-  assertTextNotInTable(tableId, text)
-
-API methods modified:
-  assertLinkPresentWithText(linkText):
-  assertLinkNotPresentWithText(linkText):
-
-New rWebUnit API :
-  clickRadioOption(radioGroup, radioOption): this method is protected in jWebUnit
-
-== 0.1.0
-
-* Initial release.
-* Most common web actions and assertions implemented.
+CHANGELOG
+=========
+
+== 0.7.2 (2007-12-31)
+ - Change dependency from Watir => Watir or FireWatir
+   Now can run on Mac or Linux
+
+== 0.7.1 (2007-12-24)
+ - Fixes error when firefox is not available
+
+== 0.7 (2007-12-18)
+ - support Firefox using FireWatir
+
+== 0.6.9
+ - add shall_not_allow
+ - more watir wrapper methods
+
+== 0.6.4 (2007-11-30)
+ - updated rwebunit 0.6.4
+ - support javascript window
+ - support watir td, tr...
+
+== 0.6.0 (2007-11-18)
+ - support watir convenient methods
+
+== 0.5.4 (2007-11-12)
+ - fixed element_by_id 
+
+== 0.5.3 (2007-11-07)
+ - fixed ajax_wait_element with web_tester changes
+ - added wait_for_element
+ 
+== 0.5.2 (2007-09-27)
+ - added element_text
+ 
+== 0.5.1 (2007-09-21)
+ - add wrap of Watir methods, such as buttons, button(...)
+ - expose Watir low level methods to test/spec through Driver.rb
+ - removed old way using array and comparision to access individual control
+ - renamed html_title to page_title
+ - add method contains_text
+ - make faster checkbox operations
+ - make faster radio operations
+ - added radio opration in driver.rb
+ - renamed ajax_wait_for_element 
+ - added some comments
+
+== 0.5.0
+ - Support Watir 1.5.2
+ 
+== 0.4.5
+  - support checkboxes with same name
+
+== 0.4.2
+
+New Features
+  - Drop support for java syntax methods
+  - remove assert helper methods in web_tester
+  - improve support for RSpecs
+
+== 0.4.0 (2007-05-29)
+
+New features
+  - Support RSpec
+  
+== 0.3.1 (2007-04-18)
+
+Bug fix reelase
+
+== 0.3.0 (2007-02-16)
+
+New features
+  - Deprecated Java like method name, use ruby naming convention instead, beginAt => begin_at
+  - More ajax related calls: ajax_wait_for_element_show, ajax_wait_for_element_hide, assert_position_in_list
+
+== 0.2.0 (2006-11-28)
+
+New features:
+  - wait_ajax_udpate(elem_id, seconds) - use indicator image id to determine whether the ajax request is completed or not
+  - browser_opened?
+
+A number of general fixes and code improvements.
+
+== 0.1.1
+
+New jWebUnit API methods implemented:
+  assertOptionEquals(selectName, optionLabel)
+  assertOptionValueEquals(selectName, optionValue)
+  assertCheckboxNotSelected(checkBoxName)
+  assertCheckboxSelected(checkBoxName)
+  assertLinkPresentWithExactText(linkText)
+  assertLinkNotPresentWithExactText(linkText)
+  assertRadioOptionNotPresent(radioGroup, radioOption)
+  assertRadioOptionPresent(radioGroup, radioOption)
+  assertRadioOptionSelected(radioGroup, radioOption)
+  assertRadioOptionNotSelected(radioGroup, radioOption)
+  assertTextInTable(tableId, text)
+  assertTextNotInTable(tableId, text)
+
+API methods modified:
+  assertLinkPresentWithText(linkText):
+  assertLinkNotPresentWithText(linkText):
+
+New rWebUnit API :
+  clickRadioOption(radioGroup, radioOption): this method is protected in jWebUnit
+
+== 0.1.0
+
+* Initial release.
+* Most common web actions and assertions implemented.

data/Rakefile

@@ -9,7 +9,7 @@ $:.unshift(File.dirname(__FILE__) + "/lib")
 require 'rwebunit'
 
 desc "Default task"
-task :default => [ :clean, :test , :gem]
+task :default => [ :clean, :test, :doc, :gem]
 
 desc "Clean generated files"
 task :clean do
@@ -36,13 +36,13 @@ Rake::RDocTask.new { |rdoc|
 spec = Gem::Specification.new do |s|
   s.platform= Gem::Platform::RUBY
   s.name = "rwebunit"
-  s.version = "0.2.0"
-  s.summary = "An wrap of WATIR for functional testing of web applications"
+  s.version = "0.7.2"
+  s.summary = "An wrap of WATIR/FireWatir for functional testing of web applications"
 # s.description = ""
 
   s.author  = "Zhimin Zhan"
   s.email   = "zhimin@zhimin.com"
-  s.homepage= "http://www.zhimin.com/software/rwebunit/"
+  s.homepage= "http://code.google.com/p/rwebunit/"
 #  s.rubyforge_project = ""
 
   s.has_rdoc    = true
@@ -57,7 +57,8 @@ spec = Gem::Specification.new do |s|
   s.files = s.files + Dir.glob( "sample/**/*" ).delete_if { |item| item.include?( "\.svn" ) }
   s.files = s.files + Dir.glob( "docs/**/*" ).delete_if { |item| item.include?( "\.svn" ) }
 
-  s.add_dependency("watir", ">= 1.4.1")
+#  s.add_dependency("watir", ">= 1.5.3")
+#  s.add_dependency("firewatir", ">= 1.1")
 end
 
 Rake::GemPackageTask.new(spec) do |pkg|

data/lib/rwebunit/assert.rb

@@ -0,0 +1,249 @@
+require 'runit/assert'
+
+module RWebUnit
+  module Assert
+
+    include RUNIT::Assert
+
+    #TODO for drag-n-drop, check the postion in list
+    #    def assert_position_in_list(list_element_id)
+    #      raise "not implemented"
+    #    end
+
+    ##
+    # text
+    def assert_text_present(text)
+      assert((@web_tester.page_source.include? text), 'expected text: ' + text + ' not found')
+    end
+
+    def assert_text_not_present(text)
+      assert(!(@web_tester.page_source.include? text), 'expected text: ' + text + ' found')
+    end
+
+    def assert_text_in_table(tableId, text)
+      elem = element_by_id(tableId)
+      assert_not_nil(elem, "tableId #{tableId} not exists")
+      assert_equal(elem.tagName.upcase, "TABLE")
+      puts elem.innerHTML if $DEBUG
+      assert(elem.innerHTML.include?(text), "the text #{text} not found in table #{tableId}")
+    end
+
+    def assert_text_not_in_table(tableId, text)
+      elem = element_by_id(tableId)
+      assert_equal(elem.tagName.upcase, "TABLE")
+      assert_not_nil(elem, "tableId #{tableId} not exists")            
+      assert(!elem.innerHTML.include?(text), "unexpected text #{text} found in table #{tableId}")
+    end
+
+    def assert_element_present(elementID)
+      assert_not_nil(element_by_id(elementID), "element with id #{elementID} not found")
+    end
+
+    def assert_element_not_present(elementID)
+      assert_nil(element_by_id(elementID), "unexpected element with id #{elementID} found")
+    end
+
+    def assert_text_in_element(elementID, text)
+      elem = element_by_id(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
+
+    ##
+    # Checkbox
+    def assert_checkbox_not_selected(checkBoxName)
+      @web_tester.checkboxes.each { |checkbox|
+        if (checkbox.name == checkBoxName) then
+          assert(!checkbox.isSet?, "Checkbox #{checkBoxName} checked unexpected")
+        end
+      }
+    end
+
+    def assert_checkbox_selected(checkBoxName)
+      @web_tester.checkboxes.each { |checkbox|
+        if (checkbox.name == checkBoxName) then
+          assert(checkbox.isSet?, "Checkbox #{checkBoxName} not checked")
+        end
+      }
+    end
+
+    ##
+    # select
+    def assert_option_value_not_present(selectName, optionValue)
+      @web_tester.select_lists.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 assert_option_not_present(selectName, optionLabel)
+      @web_tester.select_lists.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 assert_option_value_present(selectName, optionValue)
+      @web_tester.select_lists.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 assert_option_present(selectName, optionLabel)
+      @web_tester.select_lists.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 assert_option_equals(selectName, optionLabel)
+      @web_tester.select_lists.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 assert_option_value_equals(selectName, optionValue)
+      @web_tester.select_lists.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 assert_radio_option_not_present(radioGroup, radioOption)
+      @web_tester.radios.each { |radio|
+        if (radio.name == radioGroup) then
+          assert(!(radioOption == radio.value), "unexpected radio option: " + radioOption  + " found")
+        end
+      }
+    end
+
+    def assert_radio_option_present(radioGroup, radioOption)
+      @web_tester.radios.each { |radio|
+        return if (radio.name == radioGroup) and (radioOption == radio.value)
+      }
+      fail("can't find the radio option : '#{radioOption}'")
+    end
+
+    def assert_radio_option_selected(radioGroup, radioOption)
+      @web_tester.radios.each { |radio|
+        if (radio.name == radioGroup and radioOption == radio.value) then
+          assert(radio.isSet?, "Radio button #{radioGroup}-[#{radioOption}] not checked")
+        end
+      }
+    end
+
+    def assert_radio_option_not_selected(radioGroup, radioOption)
+      @web_tester.radios.each { |radio|
+        if (radio.name == radioGroup and radioOption == radio.value) then
+          assert(!radio.isSet?, "Radio button #{radioGroup}-[#{radioOption}] checked unexpected")
+        end
+      }
+    end
+
+    ##
+    # Button
+    def assert_button_not_present(buttonId)
+      @web_tester.buttons.each { |button|
+        assert(button.id != buttonId, "unexpected button id: #{buttonId} found")
+      }
+    end
+
+    def assert_button_not_present_with_text(text)
+      @web_tester.buttons.each { |button|
+        assert(button.value != text, "unexpected button id: #{text} found")
+      }
+    end
+
+    def assert_button_present(buttonID)
+      @web_tester.buttons.each { |button|
+        return if buttonID == button.id
+      }
+      assert(false, "can't find the button with id: #{buttonID}")
+    end
+
+    def assert_button_present_with_text(buttonText)
+      @web_tester.buttons.each { |button|
+        return if buttonText == button.value
+      }
+      assert(false, "can't find the button with text: #{buttonText}")
+    end
+
+    ##
+    # Link
+    def assert_link_present_with_exact(linkText)
+      @web_tester.links.each { |link|
+        return if linkText == link.text
+      }
+      fail( "can't find the link with text: #{linkText}")
+    end
+
+    def assert_link_not_present_with_exact(linkText)
+      @web_tester.links.each { |link|
+        assert(linkText != link.text, "unexpected link (exact): #{linkText} found")
+      }
+    end
+
+    def assert_link_present_with_text(linkText)
+      @web_tester.links.each { |link|
+        return if link.text.include?(linkText)
+      }
+      fail( "can't find the link containing text: #{linkText}")
+    end
+
+    def assert_link_not_present_with_text(linkText)
+      @web_tester.links.each { |link|
+        assert(!link.Text.include?(linkText), "unexpected link containing: #{linkText} found")
+      }
+    end
+
+    def assert_text_present_in_text_field(textfieldName, text, msg = nil)
+      @web_tester.textfields.each { |textfield|
+        if (textfield.name == textfieldName) then
+          assert(text_field.value.include?(text), "text: #{text} not in text field: " + textfieldName)
+        end
+      }
+    end
+
+    # assertions
+    def assert_title_equals(title)
+      assert_equals(title, @web_tester.page_title)
+    end
+
+    def assert_equals(expected, actual, msg=nil)
+      assert(expected == actual, (msg.nil?) ? "Expected: #{expected} diff from actual: #{actual}" : msg)
+    end
+
+    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