honey-do 0.5.0

data/test/checkbox_test.rb

@@ -0,0 +1,118 @@
+require 'test_master'
+
+class TestCheckboxFeatures < Test::Unit::TestCase
+  
+  # elements with no value are clicked
+  def test_checkbox_name_without_value_toggles
+    browser.set_form_values(:hackzall)
+    assert_equal("on", browser.get_form_values[:hackzall], "clicked: toggled 'on'")
+
+    browser.set_form_values(:hackzall)
+    assert_nil(browser.get_form_values[:hackzall], "clicked: toggled off")
+  end
+  
+  # elements with no value are clicked
+  def test_checkbox_name_with_nil_value_toggles
+    browser.set_form_values(:hackzall => nil)
+    assert_equal("on", browser.get_form_values[:hackzall], "clicked: toggled 'on'")
+
+    browser.set_form_values(:hackzall => nil)
+    assert_nil(browser.get_form_values[:hackzall], "clicked: toggled off")
+  end
+
+  def test_checkbox_in_group_needs_value
+    assert_raise(RuntimeError) do
+      browser.set_form_values(:extras, :retry_max => 0)
+    end
+    
+    browser.set_form_values(:extras => "printer")
+    assert(browser.get_form_values.has_key?(:extras), "grouped checkbox is set")
+  end
+
+  def test_nil_group_checkbox_value_is_first_item
+    test_input = "nil value sets first checkbox in group"
+    assert_nothing_raised(RuntimeError) do
+      browser.set_form_values(:extras => nil)
+    end
+    value_set_by_nil_input = browser.get_form_values[:extras]
+    assert_equal("burner", value_set_by_nil_input, test_input)
+    
+    browser.set_form_values([:resetButton, [:extras, 0]])
+    
+    assert_equal(value_set_by_nil_input, browser.get_form_values[:extras], test_input)
+  end
+  
+  def test_checkbox_in_group_can_be_set_by_index
+    assert_nothing_raised(RuntimeError) do
+      browser.set_form_values(:extras => 1)
+    end
+    
+    assert_equal("printer", browser.get_form_values[:extras])
+  end
+  
+  def test_true_false
+    browser.set_form_values(:hackzall => "true", "disk manager" => true)
+    verify_checked(["hackzall", "disk manager"], "'true' turns on 'checked'")
+
+    browser.set_form_values(:hackzall => false, "a-clock.exe" => :true)
+    verify_checked(["a-clock.exe", "disk manager"], "'false' turns off 'checked'")
+  end
+  
+  def test_check_uncheck
+    browser.set_form_values(:hackzall => :check, "disk manager" => "check")
+    verify_checked(["hackzall", "disk manager"], "'check' turns on 'checked'")
+
+    browser.set_form_values(:hackzall => :uncheck, "a-clock.exe" => :check)
+    verify_checked(["a-clock.exe", "disk manager"], "'uncheck' turns off 'checked'")
+  end
+
+  def test_on_off
+    browser.set_form_values(:hackzall => :on, "disk manager" => :on)
+    verify_checked(["hackzall", "disk manager"], "'on' turns on 'checked'")
+
+    browser.set_form_values(:hackzall => :off, "a-clock.exe" => :on)
+    verify_checked(["a-clock.exe", "disk manager"], "'off' turns off 'checked'")
+  end
+
+  def test_checkbox_set_all_clear_all
+    browser.set_all_checkboxes
+
+    verify_checked(["extras", "extras", "extras", "disk manager", "hackzall", "a-clock.exe", "version control client"], "all set")
+
+    browser.clear_checkboxes
+    verify_checked([], "none set")
+  end
+
+  def test_check_multiple_in_group
+    browser.set_form_values([[:extras, "burner"], [:extras, "printer"]])
+    
+    values_read_from_screen = browser.get_form_values
+    compound_values = values_read_from_screen.split_compound_values
+                     
+    assert_equal("burner|printer", values_read_from_screen[:extras])                    
+    assert_equal("burner", compound_values[:extras])
+    assert_equal("printer", compound_values[:extras_1])
+  end
+
+  def test_check_multiple_independents
+    checkboxes = ["hackzall", "a-clock.exe"]
+    browser.set_form_values(checkboxes)
+                     
+    test_intent = "submitted same as checked"
+    verify_checked(checkboxes, test_intent)
+    assert_equal("on", browser.get_form_values[:hackzall], test_intent)
+    assert_equal("on", browser.get_form_values[:"a-clock.exe"], test_intent)
+  end
+
+  protected
+  
+  def setup
+    super
+    browser.open("everything.html")
+  end
+  
+  def verify_checked(expected_checkboxes, test_intent)
+    assert_equal(expected_checkboxes.sort, browser.get_all_checked.sort, test_intent)
+  end
+  
+end

data/test/events_test.rb

@@ -0,0 +1,75 @@
+require 'test_master'
+
+class TestEvents < Test::Unit::TestCase
+
+  def test_any_element_and_reset_events
+    # click or set a value on one of the elements
+    element_count = browser.get_form_elements.split(',').size
+    any_old_element_index = rand(element_count)
+
+    # clickable and checkable types will ignore the value
+    browser.set_form_values(any_old_element_index => 1)
+
+    assert_not_nil(browser.get_form_values[:event_reports_area], "element index: #{any_old_element_index}\nsomething was captured in the trace in the event log textarea")
+  
+    browser.set_form_values(:resetButton)
+    assert_match(":resetButton (Reset)", browser.get_form_values[:event_reports_area], "only 'Reset' events in the trace")
+  end
+
+  def test_clear_and_submit_events
+    browser.set_form_values(:username => @method_name)
+    verify_event_trace(":username (#@method_name)", :username)
+
+    browser.set_form_values(:clearButton)
+    verify_event_trace(':clearButton (Clear)', :clearButton)
+    
+    browser.set_form_values(:submitButton)
+    verify_event_trace(':submitButton (Submit)',:submitButton)
+  end
+
+  def test_single_select_events
+    # select by option text
+    browser.set_form_values(:color => "Blue" )
+    verify_event_trace(":color (blue )", :color)
+  end
+
+  def test_multi_select_events
+    # input by array: allow repeated 'name' for multi-select
+    browser.set_form_values([[:hobbies, 0],              # option index
+                     [:hobbies, "Surfing the"],  # displayed label text (pattern anchored to ^)
+                     [:hobbies, "Annoying my friends"]]) 
+
+    verify_event_trace(/:hobbies \(programming \)[\w\W]*:hobbies \(programming surfing \)[\w\W]*:hobbies \(programming surfing annoying \)/, :hobbies)
+  end
+
+  def test_checkbox_events
+    # independent checkbox
+    browser.set_form_values("version control client" )
+    verify_event_trace("version control client (on)", "version control client")
+
+    # group item -- use a hash if you just want one
+    browser.set_form_values(:extras => "printer" )
+    verify_event_trace(":extras (printer)", :extras)
+
+    # group item -- use an array if you just want more than one; also, the order will guaranteed
+    browser.set_form_values([[:extras, "burner"], [:extras, "card"]])
+
+    verify_event_trace(/:extras \(burner\)[\w\W]*:extras \(card\)/, :extras)
+  end
+
+  def test_radio_button_events
+    browser.set_form_values(:browser => "ff")
+    verify_event_trace(":browser (ff)",:browser)
+    
+    browser.set_form_values(:browser => "ie")
+    verify_event_trace(":browser (ie)", :browser)
+  end
+
+  protected
+  
+  def setup
+    super
+    browser.open("everything.html")
+    browser.set_form_values(:enableEventsButton, :form_name_or_index => "events_button_form")
+  end
+end

data/test/fast_and_pretty_test.rb

@@ -0,0 +1,66 @@
+require 'test_master'
+require 'benchmark'
+
+class TestFastAndPretty < Test::Unit::TestCase
+  include Benchmark
+  
+  def test_one_field_at_a_time_honey_do_time
+    report_time(:one_field_at_a_time_input)
+  end
+
+  def test_honey_do_time
+    report_time(:honey_do_input)
+  end
+
+  def test_selenium_time
+    report_time(:selenium_input)
+  end
+
+  protected
+  
+  def report_time(input_method_name)
+    n = 10
+    time = realtime() do 
+      n.times do
+        browser.set_form_values(:resetButton)
+        send(input_method_name)
+      end
+    end
+    @@print_buffer << "*** *** #{@method_name.upcase} *** ***"
+    @@print_buffer << "#{input_method_name}, setting whole form #{n} times: #{time}\n\n"
+  end
+  
+  INPUT_DATA = {:username => "yes_dear", 
+                :password => "crypto",
+                :extras => "printer", 
+                :browser => "ff",
+                :hobbies => "Surfing the Web", 
+                :color => "Yellow",
+                :event_reports_area => "blah " * 400, 
+                :hackzall => "on"}
+
+  def honey_do_input
+    browser.set_form_values(INPUT_DATA)
+  end
+
+  def one_field_at_a_time_input
+    browser.set_form_values(INPUT_DATA, :one_field_at_a_time => true)
+  end
+  
+  def selenium_input
+    browser.type("dom=document.everything.username", INPUT_DATA[:username])
+    browser.type("dom=document.everything.password", INPUT_DATA[:password])
+    browser.check("name=extras #{INPUT_DATA[:extras]}")
+    browser.check("name=browser #{INPUT_DATA[:browser]}")
+    browser.select("dom=document.everything.hobbies", INPUT_DATA[:hobbies])
+    browser.select("dom=document.everything.color", INPUT_DATA[:color])
+    browser.type("dom=document.everything.event_reports_area", INPUT_DATA[:event_reports_area])
+    browser.check("dom=document.everything.hackzall")
+  end
+  
+  def setup
+    super
+    browser.open("everything.html")
+  end
+  
+end

data/test/file_upload_test.rb

@@ -0,0 +1,34 @@
+require 'test_master'
+
+class TestFileUpload < Test::Unit::TestCase
+
+  # due to "same origin" policy, probably
+  def test_file_upload_by_selenium_not_permitted_by_firefox
+    return if ie?   
+    navigate
+    assert_raise(SeleniumCommandError) do
+      browser.type("dom=document.everything.file", "foo.txt")
+    end
+  end
+
+  def test_file_upload_not_implemented
+    navigate
+    assert_nothing_raised(RuntimeError) do
+      # no error because nothing happens
+      browser.set_form_values(:file => "foo.txt")
+    end
+    
+    assert_nil(browser.get_form_values[:file])
+  end
+
+  protected
+
+  def ie?
+    browser.inspect.include?("explore")
+  end
+  
+  def navigate
+    browser.open("everything.html")
+  end
+
+end

data/test/general_form_test.rb

@@ -0,0 +1,205 @@
+require 'test_master'
+
+#====There are 50+ tests
+#in the classes starting "<tt>Test</tt>" (files ending <i>_test.rb</i>)
+class TestGeneralInputOptions < Test::Unit::TestCase
+  
+  ONE_OF_EACH = {:username => "yes_dear", 
+                 :password => "crypto",
+                 :extras => "printer", 
+                 :browser => "ff",
+                 :hobbies => "Surfing the Web", 
+                 :color => "Yellow",
+                 :event_reports_area => "You call this a textarea?", 
+                 :hackzall => "on"}
+  
+  # The "*_normal_*" way?
+  #
+  # use this when input order doesn't matter but readability does. 
+  #
+  # see also #TestSubmitForm
+  def test_input_list_can_be_hash
+    browser.set_form_values(ONE_OF_EACH)
+     
+    values_that_were_set = browser.get_form_values
+
+    assert_equal(ONE_OF_EACH, values_that_were_set, "input values are same as those read")
+
+    assert_nothing_raised(RuntimeError, "hash items as method arguments are fine, too") do
+      browser.set_form_values(:color => 8,                         # see also select_list_test.rb
+                      :hobbies => "hacking",               # see also select_list_test.rb
+                      :username => "ernie",  
+                      :password => "bert",  
+                      :event_reports_area => "blah " * 4,  # see also textarea_test.rb
+                      :extras => 1,                        # see also checkbox_test.rb
+                      :hackzall => true,                   # see also checkbox_test.rb
+                      :browser => "safari")                # see also radio_button_test.rb
+    end
+  end
+  
+  def test_input_list_can_have_single_item
+    assert_nothing_raised(RuntimeError, "item can be a symbol, array, or string") do
+      browser.set_form_values(:clearButton)
+      browser.set_form_values([:hackzall])
+      browser.set_form_values("resetButton")
+    end
+  end
+  
+  # see also #TestSubmitForm
+  def test_input_list_can_be_array
+    assert_nothing_raised(RuntimeError, "array list of names without values") do
+      browser.set_form_values([:clearButton, :hackzall, "resetButton", "a-clock.exe"])
+    end
+    
+    assert_equal("on", browser.get_form_values[:"a-clock.exe"])
+
+    reset
+
+    input_array = [[:username, @method_name], [:password, "snooks"], :hackzall, [:color, "Green"]]
+    assert_nothing_raised(RuntimeError, "array list of names with values, or just names") do
+      browser.set_form_values(input_array)
+    end
+    
+    hashmap_from_screen = browser.get_form_values
+    assert_equal(input_array.size, hashmap_from_screen.size)
+    assert_equal(@method_name, hashmap_from_screen[:username])
+    assert_equal("snooks", hashmap_from_screen[:password])
+    assert_equal("on", hashmap_from_screen[:hackzall])
+    assert_equal("Green", hashmap_from_screen[:color])
+  end
+  
+  # see also #TestTextareaInput
+  #
+  # If we allow this, we can't allow punctuation in text or textarea input without a lot of extra code.
+  # A nice implementation could be done, but only at the cost of further complexity.
+  #
+  # There are already plenty of options with hashes and arrays
+  def test_input_list_as_delimited_string_is_not_supported
+    assert_raise(RuntimeError, "comma delimited string treated as one big string") do
+      browser.set_form_values("clearButton,hackzall,resetButton,a-clock.exe", :retry_max => 0)
+    end
+    
+    pair_delimiter = HoneyDo::PAIR_DELIMITER
+    assert_nothing_raised(RuntimeError, SeleniumCommandError, "this works but is so ugly that you wouldn't bother") do
+      browser.set_form_values("clearButton#{pair_delimiter}hackzall#{pair_delimiter}resetButton#{pair_delimiter}a-clock.exe")
+    end
+  end
+  
+  # this a 'test' test, not a demo test: there were issues with the listbox
+  def test_ok_to_read_form_values_with_nothing_set
+    assert_nothing_raised(RuntimeError) do
+      browser.get_form_values
+    end
+  end
+
+  def test_read_element_info_from_multiple_forms
+    test_name_header = "*** *** #{@method_name.upcase} *** ***"
+    @@print_buffer << "\n#{test_name_header}"
+
+    read_element_info(0)
+
+    @@print_buffer << "\n"
+
+    read_element_info(1)
+
+    @@print_buffer << "#{test_name_header}\n\n"
+  end
+  
+  # by default we raise an error when the element name isn't found, but you can override that with '<tt>:ok_if_not_found => true</tt>'
+  def test_element_not_found
+    bad_input = ONE_OF_EACH.merge(:foo => "bar")
+    assert_raise(RuntimeError, "element name 'foo' not found, so we get an error") do
+      browser.set_form_values(bad_input, :retry_max => 0)
+    end
+    
+    reset
+    
+    assert_nothing_raised(RuntimeError, "bad element 'foo' ignored") do
+      browser.set_form_values(bad_input, :ok_if_not_found => true)
+    end
+    
+    assert_equal(ONE_OF_EACH, browser.get_form_values, "input values besides the bad one were actually set")
+  end
+  
+  # sometimes the form element name is not unique.
+  # js 'elements' collection is a js associative array, and so can use names or indices for keys
+  def test_identify_element_by_index_or_name
+    field_name_1 = "color"
+    field_name_2 = "hobbies"
+    field_index_1 = field_index_2 = ""
+    
+    browser.get_form_element_indexes.each do |item| 
+      field_index_1 = item[1].to_i if item[0] == field_name_1
+      field_index_2 = item[1]      if item[0] == field_name_2
+    end
+    
+    assert_kind_of(Integer, field_index_1)
+    assert_nothing_raised(RuntimeError, SeleniumCommandError, "index as Ruby int") do
+      browser.set_form_values( field_index_1 => :last)
+    end
+
+    assert_kind_of(String, field_index_2)
+    assert_nothing_raised(RuntimeError, SeleniumCommandError, "index as Ruby string") do
+      browser.set_form_values( field_index_2 => :last)
+    end
+
+    values_as_set_with_indexes = browser.get_form_values
+
+    reset    
+
+    browser.set_form_values( field_name_1 => :last, field_name_2 => :last)
+    values_as_set_with_names = browser.get_form_values
+    assert_equal(values_as_set_with_indexes, values_as_set_with_names)
+  end
+  
+  # A contrived example to show a technique which is handy when you need a generic solution to always click the first (or whatever-eth) thing without knowing its name.
+  # An example would be when 2 or more different warning screens are possible in a given context, each with a differently named 'dismiss' button
+  #
+  # *Note* that value-less names are only clicked if they are of a "<i>clickable</i>" type (button, radio, checkbox)
+  def test_input_list_can_be_lone_integer
+    # click 'Enable Handlers' (events_button_form.enableEventsButton) by index
+    input_list = 0
+    processing_params = {:form_name_or_index => :events_button_form}
+    assert_nothing_raised(RuntimeError, SeleniumCommandError, "element '0' is clicked without incident") do
+      browser.set_form_values(input_list, processing_params)
+    end
+    
+    # processing_params[:form_name_or_index] arg included for demo purposes: it would default to 0 anyway
+    browser.set_form_values({:color => "Blue"}, :form_name_or_index => :everything )  
+    verify_event_trace(":color (blue )", :color)
+    
+    # click 'Disable Handlers' (events_button_form.disableEventsButton) by index
+    browser.set_form_values(1, :form_name_or_index => 1)
+    
+    # clear out everything, including the textarea "event_reports_area"
+    reset
+    
+    browser.set_form_values({:hobbies => 1})  
+    assert_nil(browser.get_form_values[:event_reports_area], "no longer firing events")
+  end
+
+  protected
+  
+  def setup
+    super
+    browser.open("everything.html")
+  end
+  
+  # demonstrates some of the form reading capability and addressing a form by its index within the <tt>forms</tt> collection
+  def read_element_info(form_index)
+    @@print_buffer << "Reading Form:\n'#{browser.get_all_form_names.split(',')[form_index]}'"
+
+    @@print_buffer << "\nAll Element Names:"
+    @@print_buffer << browser.get_form_elements(form_index).split(',')
+
+    @@print_buffer << "\nAll Element Indices:"
+    @@print_buffer << browser.get_form_element_indexes(form_index).inspect
+    
+    @@print_buffer << "\nAll Checkbox Names:"
+    @@print_buffer << browser.get_all_checkbox_names(form_index).inspect
+    
+    @@print_buffer << "\nAll Button Names:"
+    @@print_buffer << browser.get_all_button_names(form_index)
+  end
+  
+end

data/test/hidden_and_disabled_field_test.rb

@@ -0,0 +1,51 @@
+require 'test_master'
+
+class TestHiddenAndDisabled < Test::Unit::TestCase
+
+  # setting hidden values hasn't proved necessary
+  def test_set_hidden_not_implemented
+    new_hidden_value = "whatever!"
+    assert_nothing_raised(RuntimeError, SeleniumCommandError) do
+      browser.set_form_values({:justHiding => new_hidden_value}.to_a.push(:submitButton))
+    end
+    
+    page_load_wait
+    
+    value_displayed_on_next_page = browser.get_cell_ids_and_text[:justHiding]
+    
+    assert(value_displayed_on_next_page, "hidden value got submitted")
+    assert_not_equal(new_hidden_value, value_displayed_on_next_page, "default hidden value was submitted, not the one we tried to set")
+  end
+  
+  HIDDEN_FIELD = "justHiding"
+  
+  # reading hidden values hasn't proved necessary
+  def test_read_hidden_not_implemented
+    assert_equal(false, browser.get_form_elements.split(',').include?(HIDDEN_FIELD), "hidden elements ignored by get_form_elements()")
+    assert_equal(false, browser.get_enabled_form_elements.split(',').include?(HIDDEN_FIELD), "hidden elements ignored by get_enabled_form_elements()")
+    assert_nil(browser.get_form_values[:justHiding], "hidden elements ignored by browser.get_form_values()")
+  end
+  
+  # we need to include all fields to have an accurate mapping of names to indexes
+  def test_hidden_fields_included_with_indexes
+    hidden_field = browser.get_form_element_indexes.select {|item| item[0] == HIDDEN_FIELD}.flatten
+    assert(hidden_field[1].to_i > -1, "hidden field index is present")
+  end
+  
+  # this is good for verifying form state
+  def test_can_exclude_disabled_fields
+    field_name = "hobbies"
+    assert(browser.get_enabled_form_elements.split(',').include?(field_name), "enabled elements returned by get_enabled_form_elements()")
+
+    browser.get_eval("dom=new Form_(this).form.#{field_name}.disabled = true;")
+    
+    assert_equal(false, browser.get_enabled_form_elements.split(',').include?(field_name), "disabled elements ignored by get_enabled_form_elements()")
+  end
+  
+  protected
+
+  def setup
+    super
+    browser.open("everything.html")
+  end
+end

data/test/radio_button_test.rb

@@ -0,0 +1,42 @@
+require 'test_master'
+
+class TestRadioButtonFeatures < Test::Unit::TestCase
+  
+  def test_set_radio_button_by_value_property
+    browser.set_form_values(:browser => "ff")
+    assert_equal("ff", browser.get_form_values[:browser])
+  end
+  
+  def test_value_is_read_not_label_text
+    browser.set_form_values(:browser => "ie")
+    assert_not_equal("Internet Explorer", browser.get_form_values[:browser])
+  end
+  
+  def test_set_radio_button_by_index
+    browser.set_form_values(:browser => 0)
+    assert_equal("ff", browser.get_form_values[:browser])
+
+    browser.set_form_values(:browser => 3)
+    assert_equal("opera", browser.get_form_values[:browser])
+  end
+  
+  def test_spaces_ok_in_radio_button_value
+    radio_button_value = "other browser"
+    assert_nothing_raised(RuntimeError, SeleniumCommandError) do
+      browser.set_form_values(:browser => radio_button_value)
+    end
+    assert_equal(radio_button_value, browser.get_form_values[:browser])
+  end
+  
+  def test_only_one_radio_button_remains_selected
+    browser.set_form_values([[:browser, 0], [:browser, "ff"],[:browser,"safari"],[:browser,"ie"]])
+    assert_equal("ie", browser.get_form_values[:browser])
+  end
+
+  protected
+  
+  def setup
+    super
+    browser.open("everything.html")
+  end
+end