rwebspec-webdriver 0.1.1 → 0.1.2

data/Rakefile

@@ -7,7 +7,6 @@ gem 'darkfish-rdoc'
 # require 'darkfish-rdoc'
 
 $:.unshift(File.dirname(__FILE__) + "/lib")
-#require 'rwebspec'
 
 desc "Default task"
 task :default => [ :clean, :spec, :rdoc, :chm, :gem]
@@ -36,17 +35,17 @@ end
 #   rdoc.template = "#{ENV['template']}.rb" if ENV['template']
 #   rdoc.rdoc_files.include('README')
 #   rdoc.rdoc_files.include('lib/rwebspec.rb')
-#   rdoc.rdoc_files.include('lib/rwebspec/*.rb')
+#   rdoc.rdoc_files.include('lib/rwebspec-webdriver/*.rb')
 # }
 
 # using DarkFish - http://deveiate.org/projects/Darkfish-Rdoc/
 Rake::RDocTask.new do |rdoc|
   rdoc.rdoc_dir = 'doc'
   rdoc.title = 'RWebSpec'
-  rdoc.rdoc_files.include('lib/rwebspec.rb')
-  rdoc.rdoc_files.include('lib/rwebspec/*.rb')  
-  rdoc.rdoc_files.delete("lib/rwebspec/web_testcase.rb")
-  rdoc.rdoc_files.delete("lib/rwebspec/checkJSDialog.rb")
+  rdoc.rdoc_files.include('lib/rwebspec-webdriver.rb')
+  rdoc.rdoc_files.include('lib/rwebspec-webdriver/*.rb')  
+  rdoc.rdoc_files.delete("lib/rwebspec-webdriver/web_testcase.rb")
+  rdoc.rdoc_files.delete("lib/rwebspec-webdriver/checkJSDialog.rb")
   rdoc.options += [
         '-SHN',
         '-f', 'darkfish',  # This is the important bit
@@ -56,10 +55,10 @@ end
 Rake::RDocTask.new("chm") do |rdoc|
   rdoc.rdoc_dir = 'chm'
   rdoc.title = 'RWebSpec'
-  rdoc.rdoc_files.include('lib/rwebspec.rb')
-  rdoc.rdoc_files.include('lib/rwebspec/*.rb')
-  rdoc.rdoc_files.delete("lib/rwebspec/web_testcase.rb")
-  rdoc.rdoc_files.delete("lib/rwebspec/checkJSDialog.rb")
+  rdoc.rdoc_files.include('lib/rwebspec-webdriver.rb')
+  rdoc.rdoc_files.include('lib/rwebspec-webdriver/*.rb')
+  rdoc.rdoc_files.delete("lib/rwebspec-webdriver/web_testcase.rb")
+  rdoc.rdoc_files.delete("lib/rwebspec-webdriver/checkJSDialog.rb")
     rdoc.options += [
         '-SHN',
         '-f', 'chm',  # This is the important bit
@@ -70,14 +69,14 @@ end
 spec = Gem::Specification.new do |s|
   s.platform= Gem::Platform::RUBY
   s.name = "rwebspec-webdriver"
-  s.version = "0.1.1"
+  s.version = "0.1.2"
   s.summary = "Executable functional specification for web applications in RSpec syntax and Selenium-WebDriver"
   # s.description = ""
 
   s.author  = "Zhimin Zhan"
   s.email   = "zhimin@agileway.net"
   s.homepage= "http://github.com/zhimin/rwebspec-webdriver/tree/master"
-  s.rubyforge_project = "rwebspec-webdrive"
+  s.rubyforge_project = "rwebspec-webdriver"
 
   s.has_rdoc    = true
   s.requirements << 'none'

data/lib/rwebspec-webdriver/assert.rb

@@ -0,0 +1,445 @@
+require 'test/unit/assertions'
+
+# http://selenium.googlecode.com/svn/trunk/docs/api/rb/Selenium/WebDriver/SearchContext.html#find_element-instance_method
+
+module RWebSpec
+  module WebDriver
+    module Assert
+      include Test::Unit::Assertions
+
+      def assert_not(condition, msg = "")
+        perform_assertion { assert(!condition, msg) }
+      end
+
+      def assert_nil(actual, msg="")
+        perform_assertion { assert(actual.nil?, msg) }
+      end
+
+      def assert_not_nil(actual, msg="")
+        perform_assertion { assert(!actual.nil?, msg) }
+      end
+
+      def fail(message)
+        perform_assertion { assert(false, message) }
+      end
+
+      # assertions
+      def assert_title_equals(title)
+        assert_equals(title, @web_browser.page_title)
+      end
+
+      alias assert_title assert_title_equals
+
+      # Assert text present in page source (html)
+      #   assert_text_in_page_source("<b>iTest2</b>  Cool") # <b>iTest2</b>  Cool
+      def assert_text_in_page_source(text)
+        perform_assertion { assert((@web_browser.page_source.include? text), 'expected html: ' + text + ' not found') }
+      end
+
+      # Assert text not present in page source (html)
+      #   assert_text_not_in_page_source("<b>iTest2</b>  Cool") # <b>iTest2</b>  Cool
+      def assert_text_not_in_page_source(text)
+        perform_assertion { assert(!(@web_browser.page_source.include? text), 'expected html: ' + text + ' found') }
+      end
+
+      # Assert text present in page source (html)
+      #   assert_text_present("iTest2 Cool") # <b>iTest2</b>  Cool
+      def assert_text_present(text)
+        perform_assertion { assert((@web_browser.text.include? text), 'expected text: ' + text + ' not found') }
+      end
+
+      # Assert text not present in page source (html)
+      #   assert_text_not_present("iTest2 Cool") # <b>iTest2</b>  Cool
+      def assert_text_not_present(text)
+        perform_assertion { assert(!(@web_browser.text.include? text), 'expected text: ' + text + ' found') }
+      end
+
+
+      ##
+      # Link
+      # @NOTE: this is different from Watir version
+
+      # Assert a link containing specified text in the page
+      #
+      #  <a href="">Click Me</a>
+      #  assert_link_present_with_text("Click ") # =>
+      #
+      def assert_link_present_with_text(link_text, opts = {})
+        begin
+          if opts && opts[:partial]
+            elem = @web_browser.find_element(:partial_link_text, link_text)
+          else
+            elem = @web_browser.find_element(:link_text, link_text)
+          end
+        rescue => e
+          puts "Failed to find the link text :#{e}"
+        end
+
+        if elem
+          return true
+        else
+          fail("can't find the link with text: #{link_text}")
+        end
+      end
+
+      def assert_link_not_present_with_text(link_text, opts = {})
+        begin
+          if opts && opts[:partial]
+            elem = @web_browser.find_element(:partial_link_text, link_text)
+          else
+            elem = @web_browser.find_element(:link_text, link_text)
+          end
+        rescue => e
+          puts "Failed to find the link text :#{e}"
+        end
+        if elem
+          fail("unexpected link (exact): #{link_text} found")
+        else
+          return true
+        end
+      end
+
+
+      ##
+      # Checkbox
+      def assert_checkbox_not_selected(checkbox_name)
+        elem = find_element(:name, checkbox_name)
+        fail "Checkbox with name:#{checkbox_name} not found" unless elem.tag_name == "input"
+        assert !elem.selected?
+      end
+
+      alias assert_checkbox_not_checked assert_checkbox_not_selected
+
+      def assert_checkbox_selected(checkbox_name)
+        elem = find_element(:name, checkbox_name)
+        fail "Checkbox with name:#{checkbox_name} not found" unless elem.tag_name == "input"
+        assert elem.selected?
+      end
+
+      alias assert_checkbox_checked assert_checkbox_selected
+
+      ##
+      # select
+      def assert_option_value_not_present(select_name, option_value)
+        select_element = find_element(:name, select_name)
+        options = select_element.find_elements(:xpath, ".//option")
+        option_values = options.collect { |x| x.attribute('value') }
+        if option_values.include?(option_value)
+          fail "Unexpected select option value #{option_value}"
+        else
+          return true
+        end
+      end
+
+      alias assert_select_value_not_present assert_option_value_not_present
+
+      def assert_option_not_present(select_name, option_label)
+        select_element = find_element(:name, select_name)
+        options = select_element.find_elements(:xpath, ".//option")
+        option_labels= options.collect { |x| x.attribute('value') }
+        if option_labels.include?(option_label)
+          fail "Unexpected select option label #{option_label}"
+        else
+          return true
+        end
+      end
+
+      alias assert_select_label_not_present assert_option_not_present
+
+      def assert_option_value_present(select_name, option_value)
+        select_element = find_element(:name, select_name)
+        options = select_element.find_elements(:xpath, ".//option")
+        option_values = options.collect { |x| x.attribute('value') }
+        if option_values.include?(option_value)
+          return true
+        else
+          fail "Unexpected select option value #{option_value}"
+        end
+      end
+
+      alias assert_select_value_present assert_option_value_present
+      alias assert_menu_value_present assert_option_value_present
+
+      def assert_option_present(select_name, option_label)
+        select_element = find_element(:name, select_name)
+        options = select_element.find_elements(:xpath, ".//option")
+        option_labels = options.collect { |x| x.text }
+        if option_labels.include?(option_label)
+          return true
+        else
+          fail "Unexpected select option label #{option_label}"
+        end
+      end
+
+      alias assert_select_label_present assert_option_present
+      alias assert_menu_label_present assert_option_present
+
+      def assert_option_equals(select_name, option_label)
+        select_element = find_element(:name, select_name)
+        options = select_element.find_elements(:xpath, ".//option")
+        selected_label_list = []
+        options.each do |op|
+          selected_label_list << op.text if op.selected?
+        end
+        assert selected_label_list.join(",").to_s == option_label
+      end
+
+      alias assert_select_label assert_option_equals
+      alias assert_menu_label assert_option_equals
+
+      def assert_option_value_equals(select_name, option_value)
+        select_element = find_element(:name, select_name)
+        options = select_element.find_elements(:xpath, ".//option")
+        selected_value_list = []
+        options.each do |op|
+          selected_value_list << op.attribute('value') if op.selected?
+        end
+        assert selected_value_list.join(",").to_s == option_value
+      end
+
+      alias assert_select_value assert_option_value_equals
+      alias assert_menu_value assert_option_value_equals
+
+      ##
+      # radio
+
+      # radio_group is the name field, radio options 'value' field
+      def assert_radio_option_not_present(radio_group, radio_option)
+        begin
+          elem = find_element(:xpath, "//input[@type='radio' and @name='#{radio_group}' and @value='#{radio_option}']")
+        rescue => e
+        end
+
+        if elem
+          fail("unexpected radio option: " + radio_option + " found")
+        else
+          return true
+        end
+      end
+
+      def assert_radio_option_present(radio_group, radio_option)
+        elem = find_element(:xpath, "//input[@type='radio' and @name='#{radio_group}' and @value='#{radio_option}']")
+        if elem
+          return true
+        else
+          fail("can't find the radio option : '#{radio_option}'")
+        end
+      end
+
+      def assert_radio_option_selected(radio_group, radio_option)
+        elem = find_element(:xpath, "//input[@type='radio' and @name='#{radio_group}' and @value='#{radio_option}']")
+        assert elem.selected?
+      end
+
+      alias assert_radio_button_checked assert_radio_option_selected
+      alias assert_radio_option_checked assert_radio_option_selected
+
+      def assert_radio_option_not_selected(radio_group, radio_option)
+        elem = find_element(:xpath, "//input[@type='radio' and @name='#{radio_group}' and @value='#{radio_option}']")
+        assert !elem.selected?
+      end
+
+      alias assert_radio_button_not_checked assert_radio_option_not_selected
+      alias assert_radio_option_not_checked assert_radio_option_not_selected
+
+      ##
+      # Button
+
+      def assert_button_present(button_id)
+        find_element(:id, button_id)
+      end
+
+      def assert_button_not_present(button_id)
+        elem = safe_find_element_by_id(button_id)
+        if elem && elem.tag_name == "button" then
+          fail("Unexpected button with this id: #{button_id}")
+        end
+        return true
+      end
+
+      def assert_button_present_with_text(button_text)
+        input_buttons = find_elements(:xpath, "//input[@type = 'button' or @type = 'submit']")
+        input_button_values = input_buttons.collect { |x| x.attribute('value') }
+        if input_button_values.include?(button_text)
+          return true
+        else
+          #TODO check for just <button tag
+          fail("can't find the button with text: #{button_text}")
+        end
+      end
+
+      def assert_button_not_present_with_text(button_text)
+        input_buttons = find_elements(:xpath, "//input[@type = 'button' or @type = 'submit']")
+        input_button_values = input_buttons.collect { |x| x.attribute('value') }
+        if input_button_values.include?(button_text)
+          fail("can't find the button with text: #{button_text}")
+        else
+          #TODO check for just <button tag
+          return true
+        end
+      end
+
+      ## General
+      #
+
+      def assert_equals(expected, actual, msg=nil)
+        perform_assertion { assert(expected == actual, (msg.nil?) ? "Expected: #{expected} diff from actual: #{actual}" : msg) }
+      end
+
+
+      # Check a HTML element exists or not
+      # Example:
+      #  assert_exists("label", "receipt_date")
+      #  assert_exists(:span, :receipt_date)
+      def assert_exists(tag, element_id)
+        elem = find_element(:id, element_id)
+        if elem
+          return true
+        else
+          fail("Element '#{tag}' with id: '#{element_id}' not found")
+        end
+      end
+
+      alias assert_exists? assert_exists
+      alias assert_element_exists assert_exists
+
+      def assert_not_exists(tag, element_id)
+        elem = find_element(:id, element_id)
+        if elem
+          fail("#{tag} with #{element_id} not expected there, but exists")
+        else
+          return true
+        end
+      end
+
+      alias assert_not_exists? assert_not_exists
+      alias assert_element_not_exists? assert_not_exists
+
+
+      # Assert tag with element id is visible?, eg.
+      #   assert_visible(:div, "public_notice")
+      #   assert_visible(:span, "public_span")
+      def assert_visible(tag, element_id)
+        element = find_element(:id, element_id)
+        perform_assertion { assert(element.displayed?, "Element '#{tag}' with id: '#{element_id}' not visible") }
+      end
+
+      # Assert tag with element id is hidden?, example
+      #   assert_hidden(:div, "secret")
+      #   assert_hidden(:span, "secret_span")
+      def assert_hidden(tag, element_id)
+        element = find_element(:id, element_id)
+        perform_assertion { assert(!element.displayed?, "Element '#{tag}' with id: '#{element_id}' is visible") }
+      end
+
+      alias assert_not_visible assert_hidden
+
+      def assert_disabled(tag, element_id)
+        element = find_element(:id, element_id)
+        assert !element.enabled?
+      end
+
+      def assert_enabled(tag, element_id)
+        element = find_element(:id, element_id)
+        puts "XXX :#{element.tag_name}"
+        assert element.enabled?
+      end
+
+
+      # Assert given text appear inside a table (inside <table> tag like below)
+      #
+      # <table id="t1">
+      #
+      # <tbody>
+      #   <tr id="row_1">
+      #     <td id="cell_1_1">A</td>
+      #     <td id="cell_1_2">B</td>
+      #   </tr>
+      #   <tr id="row_2">
+      #     <td id="cell_2_1">a</td>
+      #     <td id="cell_2_2">b</td>
+      #   </tr>
+      # </tbody>
+      #
+      # </table>
+      #
+      # The plain text view of above table
+      #  A B a b
+      #
+      # Examples
+      #  assert_text_present_in_table("t1", ">A<")  # => true
+      #  assert_text_present_in_table("t1", ">A<", :just_plain_text => true)  # => false
+      def assert_text_present_in_table(table_id, text, options = {:just_plain_text => false})
+        perform_assertion { assert(table_source(table_id, options).include?(text), "the text #{text} not found in table #{table_id}") }
+      end
+
+      alias assert_text_in_table assert_text_present_in_table
+
+      def assert_text_not_present_in_table(table_id, text, options = {:just_plain_text => false})
+        perform_assertion { assert_not(table_source(table_id, options).include?(text), "the text #{text} not found in table #{table_id}") }
+      end
+
+      alias assert_text_not_in_table assert_text_not_present_in_table
+
+      # Assert a text field (with given name) has the value
+      #
+      # <input id="tid" name="text1" value="text already there" type="text">
+      #
+      # assert_text_field_value("text1", "text already there") => true
+      #
+      def assert_text_field_value(textfield_name, text)
+        perform_assertion { assert_equal(text, text_field(:name, textfield_name).attribute('value') ) }
+      end
+
+
+      #-- Not tested
+      # -----
+
+      def assert_text_in_element(element_id, text)
+        elem = element_by_id(element_id)
+        assert_not_nil(elem.innerText, "element #{element_id} has no text")
+        perform_assertion { assert(elem.innerText.include?(text), "the text #{text} not found in element #{element_id}") }
+      end
+
+      # Use
+      #
+
+      #TODO for drag-n-drop, check the postion in list
+      #    def assert_position_in_list(list_element_id)
+      #      raise "not implemented"
+      #    end
+
+      private
+      def table_source(table_id, options)
+        elem_table = table(:id, table_id.to_s)
+        elem_table_text = elem_table.text
+        elem_table_html = is_firefox? ? elem_table.innerHTML : elem_table.html
+        table_source = options[:just_plain_text] ? elem_table_text : elem_table_html
+      end
+
+
+      def perform_assertion(&block)
+        begin
+          yield
+          return true
+        rescue StandardError => e
+          # puts "[DEBUG] Assertion error: #{e}"
+          take_screenshot
+          raise e
+        end
+      end
+
+      #
+      def safe_find_element_by_id(an_id)
+        begin
+          find_element(:id, an_id)
+        rescue => e
+          puts "Not found, but not throwing an error"
+          nil
+        end
+      end
+
+    end
+
+  end
+end