Module: RWebUnit::Assert

Includes:

Test::Unit::Assertions

Included in:

AbstractWebPage, RSpecHelper, TestScript, WebTestCase

Defined in:

lib/rwebunit/assert.rb

Instance Method Summary

• #assert_button_not_present(button_id) ⇒ Object

  Button.

• #assert_button_not_present_with_text(text) ⇒ Object
• #assert_button_present(button_id) ⇒ Object
• #assert_button_present_with_text(button_text) ⇒ Object
• #assert_checkbox_not_selected(checkbox_name) ⇒ Object (also: #assert_checkbox_not_checked)

  Checkbox.

• #assert_checkbox_selected(checkbox_name) ⇒ Object (also: #assert_checkbox_checked)
• #assert_equals(expected, actual, msg = nil) ⇒ Object
• #assert_exists(tag, element_id) ⇒ Object (also: #assert_exists?, #assert_element_exists)

  Check a HTML element exists or not Example: assert_exists("label", "receipt_date") assert_exists(:span, :receipt_date).

• #assert_hidden(tag, element_id) ⇒ Object (also: #assert_not_visible)

  Assert tag with element id is hidden?, example assert_hidden(:div, "secret") assert_hidden(:span, "secret_span").

• #assert_link_not_present_with_exact(link_text) ⇒ Object
• #assert_link_not_present_with_text(link_text) ⇒ Object
• #assert_link_present_with_exact(link_text) ⇒ Object

  Assert a link with specified text (exact match) in the page.

• #assert_link_present_with_text(link_text) ⇒ Object

  Assert a link containing specified text in the page Click Me assert_link_present_with_text("Click ") # =>.

• #assert_nil(actual, msg = "") ⇒ Object
• #assert_not(condition, msg = "") ⇒ Object
• #assert_not_exists(tag, element_id) ⇒ Object (also: #assert_not_exists?, #assert_element_not_exists?)
• #assert_not_nil(actual, msg = "") ⇒ Object
• #assert_option_equals(select_name, option_label) ⇒ Object (also: #assert_select_label)
• #assert_option_not_present(select_name, option_label) ⇒ Object (also: #assert_select_label_not_present)
• #assert_option_present(select_name, option_label) ⇒ Object (also: #assert_select_label_present)
• #assert_option_value_equals(select_name, option_value) ⇒ Object (also: #assert_select_value)
• #assert_option_value_not_present(select_name, option_value) ⇒ Object (also: #assert_select_value_not_present)

  select.

• #assert_option_value_present(select_name, option_value) ⇒ Object (also: #assert_select_value_present)
• #assert_radio_option_not_present(radio_group, radio_option) ⇒ Object

  radio_group is the name field, radio options 'value' field.

• #assert_radio_option_not_selected(radio_group, radio_option) ⇒ Object (also: #assert_radio_button_not_checked, #assert_radio_option_not_checked)
• #assert_radio_option_present(radio_group, radio_option) ⇒ Object
• #assert_radio_option_selected(radio_group, radio_option) ⇒ Object (also: #assert_radio_button_checked, #assert_radio_option_checked)
• #assert_text_field_value(textfield_name, text) ⇒ Object

  Assert a text field (with given name) has the value.

• #assert_text_in_element(element_id, text) ⇒ Object

  -- Not tested -----.

• #assert_text_not_present(text) ⇒ Object

  Assert text not present in page source (html) assert_text_not_present("

  iTest2

  ").

• #assert_text_not_present_in_table(table_id, text, options = { :just_plain_text => false }) ⇒ Object (also: #assert_text_not_in_table)
• #assert_text_present(text) ⇒ Object

  Assert text present in page source (html) assert_text_present("

  iTest2

  ").

• #assert_text_present_in_table(table_id, text, options = { :just_plain_text => false }) ⇒ Object (also: #assert_text_in_table)

  Assert given text appear inside a table (inside

  tag like below) .

  #assert_title_equals(title) ⇒ Object (also: #assert_title)

  assertions.

  #assert_visible(tag, element_id) ⇒ Object

  Assert tag with element id is visible?, eg.

  #fail(message) ⇒ Object

  Instance Method Details

  #assert_button_not_present(button_id) ⇒ Object

  Button

  # File 'lib/rwebunit/assert.rb', line 209
  
  def assert_button_not_present(button_id)
    @web_browser.buttons.each { |button|
      assert(button.id != button_id, "unexpected button id: #{button_id} found")
    }
  end

  #assert_button_not_present_with_text(text) ⇒ Object

  # File 'lib/rwebunit/assert.rb', line 215
  
  def assert_button_not_present_with_text(text)
    @web_browser.buttons.each { |button|
      assert(button.value != text, "unexpected button id: #{text} found")
    }
  end

  #assert_button_present(button_id) ⇒ Object

  # File 'lib/rwebunit/assert.rb', line 221
  
  def assert_button_present(button_id)
    @web_browser.buttons.each { |button|
      return if button_id == button.id
    }
    assert(false, "can't find the button with id: #{button_id}")
  end

  #assert_button_present_with_text(button_text) ⇒ Object

  # File 'lib/rwebunit/assert.rb', line 228
  
  def assert_button_present_with_text(button_text)
    @web_browser.buttons.each { |button|
      return if button_text == button.value
    }
    assert(false, "can't find the button with text: #{button_text}")
  end

  #assert_checkbox_not_selected(checkbox_name) ⇒ Object Also known as: assert_checkbox_not_checked

  Checkbox

  # File 'lib/rwebunit/assert.rb', line 86
  
  def assert_checkbox_not_selected(checkbox_name)
    @web_browser.checkboxes.each { |checkbox|
      if (checkbox.name == checkbox_name) then
        assert(!checkbox.isSet?, "Checkbox #{checkbox_name} is checked unexpectly")
      end
    }
  end

  #assert_checkbox_selected(checkbox_name) ⇒ Object Also known as: assert_checkbox_checked

  # File 'lib/rwebunit/assert.rb', line 95
  
  def assert_checkbox_selected(checkbox_name)
    @web_browser.checkboxes.each { |checkbox|
      if (checkbox.name == checkbox_name) then
        assert(checkbox.isSet?, "Checkbox #{checkbox_name} not checked")
      end
    }
  end

  #assert_equals(expected, actual, msg = nil) ⇒ Object

  # File 'lib/rwebunit/assert.rb', line 236
  
  def assert_equals(expected, actual, msg=nil)
    assert(expected == actual, (msg.nil?) ? "Expected: #{expected} diff from actual: #{actual}" : msg)
  end

  #assert_exists(tag, element_id) ⇒ Object Also known as: assert_exists?, assert_element_exists

  Check a HTML element exists or not Example: assert_exists("label", "receipt_date") assert_exists(:span, :receipt_date)

  # File 'lib/rwebunit/assert.rb', line 246
  
  def assert_exists(tag, element_id) {}
    begin
      assert eval("#{tag}(:id, '#{element_id.to_s}').exists?")
    rescue => e
      raise "Element '#{tag}' with id: '#{element_id}' not found, #{e}"
    end
  end

  #assert_hidden(tag, element_id) ⇒ Object Also known as: assert_not_visible

  Assert tag with element id is hidden?, example assert_hidden(:div, "secret") assert_hidden(:span, "secret_span")

  # File 'lib/rwebunit/assert.rb', line 281
  
  def assert_hidden(tag, element_id)
    begin
      assert(!eval("#{tag}(:id, '#{element_id.to_s}').visible?"))
    rescue => e
      raise "Element '#{tag}' with id: '#{element_id}' is visible, #{e}"
    end
  end

  #assert_link_not_present_with_exact(link_text) ⇒ Object

  # File 'lib/rwebunit/assert.rb', line 59
  
  def assert_link_not_present_with_exact(link_text)
    @web_browser.links.each { |link|
      assert(link_text != link.text, "unexpected link (exact): #{link_text} found")
    }
  end

  #assert_link_not_present_with_text(link_text) ⇒ Object

  # File 'lib/rwebunit/assert.rb', line 77
  
  def assert_link_not_present_with_text(link_text)
    @web_browser.links.each { |link|
      assert(!link.text.include?(link_text), "unexpected link containing: #{link_text} found")
    }
  end

  #assert_link_present_with_exact(link_text) ⇒ Object

  Assert a link with specified text (exact match) in the page

  Click Me assert_link_present_with_exact("Click Me") => true assert_link_present_with_exact("Click") => false

  # File 'lib/rwebunit/assert.rb', line 52
  
  def assert_link_present_with_exact(link_text)
    @web_browser.links.each { |link|
      return if link_text == link.text
    }
    fail( "can't find the link with text: #{link_text}")
  end

  #assert_link_present_with_text(link_text) ⇒ Object

  Assert a link containing specified text in the page

  Click Me assert_link_present_with_text("Click ") # =>

  # File 'lib/rwebunit/assert.rb', line 70
  
  def assert_link_present_with_text(link_text)
    @web_browser.links.each { |link|
      return if link.text.include?(link_text)
    }
    fail( "can't find the link containing text: #{link_text}")
  end

  #assert_nil(actual, msg = "") ⇒ Object

  # File 'lib/rwebunit/assert.rb', line 12
  
  def assert_nil(actual, msg="")
    assert(actual.nil?, msg)
  end

  #assert_not(condition, msg = "") ⇒ Object

  # File 'lib/rwebunit/assert.rb', line 8
  
  def assert_not(condition, msg = "")
    assert(!condition, msg)
  end

  #assert_not_exists(tag, element_id) ⇒ Object Also known as: assert_not_exists?, assert_element_not_exists?

  # File 'lib/rwebunit/assert.rb', line 256
  
  def assert_not_exists(tag, element_id) {}
    begin
      assert_not eval("#{tag}(:id, '#{element_id.to_s}').exists?")
      raise "Unexpected element'#{tag}' + with id: '#{element_id}' found"
    rescue => e
    end
  end

  #assert_not_nil(actual, msg = "") ⇒ Object

  # File 'lib/rwebunit/assert.rb', line 16
  
  def assert_not_nil(actual, msg="")
    assert(!actual.nil?, msg)
  end

  #assert_option_equals(select_name, option_label) ⇒ Object Also known as: assert_select_label

  # File 'lib/rwebunit/assert.rb', line 148
  
  def assert_option_equals(select_name, option_label)
    @web_browser.select_lists.each { |select|
      next unless select.name == select_name
      select.o.each do |option| # items in the list
        if (option.text == option_label) then
          assert_equal(select.value, option.value, "Select #{select_name}'s value is not equal to expected option label: '#{option_label}'")
        end
      end
    }
  end

  #assert_option_not_present(select_name, option_label) ⇒ Object Also known as: assert_select_label_not_present

  # File 'lib/rwebunit/assert.rb', line 116
  
  def assert_option_not_present(select_name, option_label)
    @web_browser.select_lists.each { |select|
      next unless select.name == select_name
      select.o.each do |option| # items in the list
        assert(!(option.text == option_label), "unexpected select option: #{option_label} for #{select_name} found")
      end
    }
  end

  #assert_option_present(select_name, option_label) ⇒ Object Also known as: assert_select_label_present

  # File 'lib/rwebunit/assert.rb', line 137
  
  def assert_option_present(select_name, option_label)
    @web_browser.select_lists.each { |select|
      next unless select.name == select_name
      select.o.each do |option| # items in the list
        return if option.text == option_label
      end
    }
    assert(false, "can't find the combob box: #{select_name} with value: #{option_label}")
  end

  #assert_option_value_equals(select_name, option_value) ⇒ Object Also known as: assert_select_value

  # File 'lib/rwebunit/assert.rb', line 160
  
  def assert_option_value_equals(select_name, option_value)
    @web_browser.select_lists.each { |select|
      next unless select.name == select_name
      assert_equal(select.value, option_value, "Select #{select_name}'s value is not equal to expected: '#{option_value}'")
    }
  end

  #assert_option_value_not_present(select_name, option_value) ⇒ Object Also known as: assert_select_value_not_present

  select

  # File 'lib/rwebunit/assert.rb', line 106
  
  def assert_option_value_not_present(select_name, option_value)
    @web_browser.select_lists.each { |select|
      continue unless select.name == select_name
      select.o.each do |option| # items in the list
        assert(!(option.value == option_value), "unexpected select option: #{option_value} for #{select_name} found")
      end
    }
  end

  #assert_option_value_present(select_name, option_value) ⇒ Object Also known as: assert_select_value_present

  # File 'lib/rwebunit/assert.rb', line 126
  
  def assert_option_value_present(select_name, option_value)
    @web_browser.select_lists.each { |select|
      next unless select.name == select_name
      select.o.each do |option| # items in the list
        return if option.value == option_value
      end
    }
    assert(false, "can't find the combob box with value: #{option_value}")
  end

  #assert_radio_option_not_present(radio_group, radio_option) ⇒ Object

  radio_group is the name field, radio options 'value' field

  # File 'lib/rwebunit/assert.rb', line 172
  
  def assert_radio_option_not_present(radio_group, radio_option)
    @web_browser.radios.each { |radio|
      if (radio.name == radio_group) then
        assert(!(radio_option == radio.value), "unexpected radio option: " + radio_option  + " found")
      end
    }
  end

  #assert_radio_option_not_selected(radio_group, radio_option) ⇒ Object Also known as: assert_radio_button_not_checked, assert_radio_option_not_checked

  # File 'lib/rwebunit/assert.rb', line 197
  
  def assert_radio_option_not_selected(radio_group, radio_option)
    @web_browser.radios.each { |radio|
      if (radio.name == radio_group and radio_option == radio.value) then
        assert(!radio.isSet?, "Radio button #{radio_group}-[#{radio_option}] checked unexpected")
      end
    }
  end

  #assert_radio_option_present(radio_group, radio_option) ⇒ Object

  # File 'lib/rwebunit/assert.rb', line 180
  
  def assert_radio_option_present(radio_group, radio_option)
    @web_browser.radios.each { |radio|
      return if (radio.name == radio_group) and (radio_option == radio.value)
    }
    fail("can't find the radio option : '#{radio_option}'")
  end

  #assert_radio_option_selected(radio_group, radio_option) ⇒ Object Also known as: assert_radio_button_checked, assert_radio_option_checked

  # File 'lib/rwebunit/assert.rb', line 187
  
  def assert_radio_option_selected(radio_group, radio_option)
    @web_browser.radios.each { |radio|
      if (radio.name == radio_group and radio_option == radio.value) then
        assert(radio.isSet?, "Radio button #{radio_group}-[#{radio_option}] not checked")
      end
    }
  end

  #assert_text_field_value(textfield_name, text) ⇒ Object

  Assert a text field (with given name) has the value

  assert_text_field_value("text1", "text already there") => true

  # File 'lib/rwebunit/assert.rb', line 330
  
  def assert_text_field_value(textfield_name, text)
    assert_equal(text, text_field(:name, textfield_name).value)
  end

  #assert_text_in_element(element_id, text) ⇒ Object

  -- Not tested

  # File 'lib/rwebunit/assert.rb', line 338
  
  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")
    assert(elem.innerText.include?(text), "the text #{text} not found in element #{element_id}")
  end

  #assert_text_not_present(text) ⇒ Object

  Assert text not present in page source (html) assert_text_not_present("

  iTest2

  ")

  # File 'lib/rwebunit/assert.rb', line 38
  
  def assert_text_not_present(text)
    assert(!(@web_browser.page_source.include? text), 'expected text: ' + text + ' found')
  end

  #assert_text_not_present_in_table(table_id, text, options = { :just_plain_text => false }) ⇒ Object Also known as: assert_text_not_in_table

  # File 'lib/rwebunit/assert.rb', line 319
  
  def assert_text_not_present_in_table(table_id, text, options = { :just_plain_text => false })
    assert_not(table_source(table_id, options).include?(text),  "the text #{text} not found in table #{table_id}")
  end

  #assert_text_present(text) ⇒ Object

  Assert text present in page source (html) assert_text_present("

  iTest2

  ")

  # File 'lib/rwebunit/assert.rb', line 32
  
  def assert_text_present(text)
    assert((@web_browser.page_source.include? text), 'expected text: ' + text + ' not found')
  end

  #assert_text_present_in_table(table_id, text, options = { :just_plain_text => false }) ⇒ Object Also known as: assert_text_in_table

  Assert given text appear inside a table (inside

  tag like below)

  A	B
  a	b

  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

  # File 'lib/rwebunit/assert.rb', line 314
  
  def assert_text_present_in_table(table_id, text, options = { :just_plain_text => false })
    assert(table_source(table_id, options).include?(text),  "the text #{text} not found in table #{table_id}")
  end

  #assert_title_equals(title) ⇒ Object Also known as: assert_title

  assertions

  # File 'lib/rwebunit/assert.rb', line 25
  
  def assert_title_equals(title)
    assert_equals(title, @web_browser.page_title)
  end

  #assert_visible(tag, element_id) ⇒ Object

  Assert tag with element id is visible?, eg. assert_visible(:div, "public_notice") assert_visible(:span, "public_span")

  # File 'lib/rwebunit/assert.rb', line 270
  
  def assert_visible(tag, element_id)
    begin
      assert(eval("#{tag}(:id, '#{element_id.to_s}').visible?"))
    rescue => e
      raise "Element '#{tag}' with id: '#{element_id}' not visible, #{e}"
    end
  end

  #fail(message) ⇒ Object

  # File 'lib/rwebunit/assert.rb', line 20
  
  def fail(message)
    assert(false, message)
  end