awetestlib 0.0.3-x86-mingw32 → 0.1.0-x86-mingw32

data/lib/regression/waits.rb

@@ -0,0 +1,387 @@
+module Waits
+
+  def sleep_for(seconds, dbg = true, desc = '')
+    msg = "Sleeping for #{seconds} seconds."
+    msg << " #{desc}" if desc.length > 0
+    msg << "\n#{get_debug_list}" if dbg
+    info_to_log(msg)
+    sleep(seconds)
+  end
+
+# howLong is integer, whatFor is a browser object
+=begin rdoc
+:tags:wait
+howLong is the number of seconds, text is a string to be found, threshold is the number of seconds
+after which a fail message is generated even though the text was detected within the howLong limit.
+Use this in place of wait_until_by_text when the wait time needs to be longer than the test automation default.
+=end
+  def hold_for_text(browser, howLong, text, desc = '', threshold = 20, interval = 0.25)
+    countdown = howLong
+    while ((not browser.contains_text(text)) and countdown > 0)
+      sleep(interval)
+      countdown = countdown - interval
+    end
+    if countdown < howLong
+      waittime = howLong - countdown
+      passed_tolog("#{__method__}  '#{text}' found after #{waittime} second(s) #{desc}")
+      if waittime > threshold
+        failed_tolog("#{__method__}  '#{text}' took #{waittime} second(s). (threshold: #{threshold} seconds) #{desc}")
+      end
+      true
+    else
+      failed_tolog("#{__method__}  '#{text}' not found after #{howLong} second(s) #{desc}")
+      false
+    end
+  rescue
+    failed_tolog("Unable to #{__method__} '#{text}'. '#{$!}' #{desc}")
+  end
+
+  alias wait_for_text hold_for_text
+
+  # howLong is integer, whatFor is a browser object
+  def wait_for_text(browser, howLong, text)
+    countdown = howLong
+    while ((not browser.contains_text(text)) and countdown > 0)
+      sleep(1)
+      countdown = countdown - 1
+    end
+    if countdown
+      passed_tolog("wait_for_text '#{text}' found after #{howLong} second(s)")
+    else
+      failed_tolog("wait_for_text '#{text}' not foundafter #{howLong} second(s)")
+    end
+    countdown
+  end
+
+  def wait_for_element_to_reappear(browser, how, what, desc = '', timeout = 20)
+    msg = "Element #{how}=#{what} exists. #{desc}"
+    wait_while(browser, "While: #{msg}", timeout) { browser.element(how, what).exists? }
+    wait_until(browser, "Until: #{msg}", timeout) { browser.element(how, what).exists? }
+  end
+
+  # howLong is integer, whatFor is a browser object
+  def wait_for_exists(howLong, whatFor)
+    wait_for(howLong, whatFor)
+  end
+
+  def wait_for(howLong, whatFor)
+    countdown = howLong
+    while ((not whatFor.exists?) and countdown > 0)
+      sleep(1)
+      puts whatFor.inspect+':'+countdown.to_s
+      countdown = countdown - 1
+    end
+    if countdown
+      puts 'found '+whatFor.inspect
+      passed_tolog("wait_for (#{howLong} found "+whatFor.inspect)
+    else
+      puts 'Did not find '+whatFor.inspect
+      failed_tolog("wait_for (#{howLong} did not find "+whatFor.inspect)
+    end
+    countdown
+  end
+
+  def wait_the_hard_way(browser, how, what, wait = 6, intvl = 0.25)
+    count = (wait / intvl).to_i + 1
+    tally = 0
+    ok    = (1 / intvl).to_i + 1
+    debug_to_log("#{__method__}: wait: #{wait} secs; intvl: #{intvl} secs; count; #{count}; thresh: #{ok}")
+    (1..count).each do |x|
+      begin
+        if browser.element(how, what).exists?
+          tally += 1
+          debug_to_log("#{x}: #{(x - 1) * intvl}: #{what} exists.")
+        else
+          tally = 0
+          debug_to_log("#{x}: #{(x - 1) * intvl}: #{what} does not exist.")
+        end
+      rescue
+        tally = 0
+        debug_to_log("#{x}: #{(x - 1) * intvl}: #{what} rescue: #{$!}")
+      end
+      if tally >= ok
+        return true
+      end
+      sleep(intvl)
+    end
+  end
+
+  def wait_until_exists(browser, element, how, what, desc = '')
+    msg = "Wait until (#{element} :#{how}=>#{what}) exists."
+    msg << " #{desc}" if desc.length > 0
+    start = Time.now.to_f
+    # TODO: try Watir::Wait.until { browser.element(how, what).exists? } instead of this (cumbersome) case statement
+    # TODO: above fails on frame
+    begin
+      case element
+        when :link
+          Watir::Wait.until { browser.link(how, what).exists? }
+        when :button
+          Watir::Wait.until { browser.button(how, what).exists? }
+        when :radio
+          Watir::Wait.until { browser.radio(how, what).exists? }
+        when :checkbox
+          Watir::Wait.until { browser.checkbox(how, what).exists? }
+        when :div
+          Watir::Wait.until { browser.div(how, what).exists? }
+        when :select_list
+          Watir::Wait.until { browser.select_list(how, what).exists? }
+        when :text_field
+          Watir::Wait.until { browser.text_field(how, what).exists? }
+        when :frame
+          Watir::Wait.until { browser.frame(how, what).exists? }
+        when :form
+          Watir::Wait.until { browser.form(how, what).exists? }
+        when :cell
+          Watir::Wait.until { browser.cell(how, what).exists? }
+        when :image
+          Watir::Wait.until { browser.image(how, what).exists? }
+        else
+          Watir::Wait.until { browser.element(how, what).exists? }
+      end
+    rescue => e
+      if e.class.to_s =~ /TimeOutException/
+        failed_to_log("#{msg}: '#{$!}'")
+        return false
+      elsif not rescue_me(e, __method__, "#{block.to_s}", "#{browser.class}")
+        raise e
+      end
+    end
+    stop = Time.now.to_f
+    #debug_to_log("#{__method__}: start:#{start} stop:#{stop}")
+    #    sleep 1
+    if validate(browser, @myName, __LINE__)
+      passed_to_log("#{msg} (#{stop - start} seconds)")
+      true
+    end
+  rescue
+    failed_to_log("Unable to complete #{msg}: '#{$!}'")
+  end
+
+  def wait_while(browser, desc, timeout = 45, &block)
+    #TODO: Would like to be able to see the block code in the log message instead of the identification
+    msg   = "Wait while #{desc}:"
+    start = Time.now.to_f
+    begin
+      #Watir::Wait.until(timeout) { block.call(nil) }
+      if block.call(nil)
+        Watir::Wait.while(timeout) { block.call(nil) }
+      end
+    rescue => e
+      if e.class.to_s =~ /TimeOutException/ or e.message =~ /timed out/
+        failed_to_log("#{msg}: '#{$!}' ")
+        return false
+      elsif not rescue_me(e, __method__, "#{block.to_s}", "#{browser.class}")
+        raise e
+      end
+    end
+    stop = Time.now.to_f
+    #debug_to_log("#{__method__}: start:#{start} stop:#{stop} block: #{block.to_s}")
+    #    sleep 1
+    if validate(browser, @myName, __LINE__)
+      passed_to_log("#{msg} (#{"%.5f" % (stop - start)} seconds)") #  {#{block.to_s}}")
+      true
+    end
+  rescue
+    failed_to_log("Unable to complete #{msg}. '#{$!}'")
+  end
+
+  alias wait_while_true wait_while
+
+  def wait_until(browser, desc, timeout = 45, skip_pass = false, &block)
+    #TODO: Would like to be able to see the block code in the log message instead of the identification
+    msg   = "Wait until #{desc}"
+    start = Time.now.to_f
+    begin
+      Watir::Wait.until(timeout) { block.call(nil) }
+    rescue => e
+      if e.class.to_s =~ /TimeOutException/ or e.message =~ /timed out/
+        failed_to_log("#{msg} '#{$!}'")
+        return false
+      elsif not rescue_me(e, __method__, "#{block.to_s}", "#{browser.class}")
+        raise e
+      end
+    end
+    stop = Time.now.to_f
+    #debug_to_log("#{__method__}: start:#{start} stop:#{stop} block: #{block.to_s}")
+    #    sleep 1
+    if validate(browser, @myName, __LINE__)
+      passed_to_log("#{msg} (#{"%.5f" % (stop - start)} seconds)") unless skip_pass #  {#{block.to_s}}")
+      true
+    end
+  rescue
+    failed_to_log("Unable to complete #{msg}  '#{$!}'")
+  end
+
+  alias wait_until_true wait_until
+
+  def wait_until_by_radio_value(browser, strg, desc = '')
+    wait_until_exists(browser, :radio, :value, strg, desc)
+  end
+
+  def wait_until_ready(browser, how, what, desc = '', timeout = 90, verbose = false)
+    msg = "#{__method__.to_s.titleize}: element: #{how}='#{what}'"
+    msg << " #{desc}" if desc.length > 0
+    proc_exists  = Proc.new { browser.element(how, what).exists? }
+    proc_enabled = Proc.new { browser.element(how, what).enabled? }
+    case how
+      when :href
+        proc_exists  = Proc.new { browser.link(how, what).exists? }
+        proc_enabled = Proc.new { browser.link(how, what).enabled? }
+    end
+    if verbose
+      if wait_until(browser, "#{msg} Element exists.", timeout) { proc_exists.call(nil) }
+        if wait_until(browser, "#{msg} Element enabled.", timeout) { proc_enabled.call(nil) }
+          passed_to_log(msg)
+          true
+        else
+          failed_to_log(msg)
+        end
+      else
+        failed_to_log(msg)
+      end
+    else
+      start = Time.now.to_f
+      if Watir::Wait.until(timeout) { proc_exists.call(nil) }
+        if Watir::Wait.until(timeout) { proc_enabled.call(nil) }
+          stop = Time.now.to_f
+          #debug_to_log("#{__method__}: start:#{"%.5f" % start} stop:#{"%.5f" % stop}")
+          passed_to_log("#{msg} (#{"%.5f" % (stop - start)} seconds)")
+          true
+        else
+          failed_to_log(msg)
+        end
+      else
+        failed_to_log(msg)
+      end
+    end
+  rescue
+    failed_to_log("Unable to #{msg}. '#{$!}'")
+  end
+
+  def wait_until_ready_quiet(browser, how, what, desc = '', timeout = 45, quiet = true)
+    msg = "#{__method__.to_s.titleize}: element: #{how}='#{what}'"
+    msg << " #{desc}" if desc.length > 0
+    proc_exists  = Proc.new { browser.element(how, what).exists? }
+    proc_enabled = Proc.new { browser.element(how, what).enabled? }
+    case how
+      when :href
+        proc_exists  = Proc.new { browser.link(how, what).exists? }
+        proc_enabled = Proc.new { browser.link(how, what).enabled? }
+    end
+    start = Time.now.to_f
+    if Watir::Wait.until(timeout) { proc_exists.call(nil) }
+      if Watir::Wait.until(timeout) { proc_enabled.call(nil) }
+        stop = Time.now.to_f
+        #debug_to_log("#{msg}: start:#{"%.5f" % start} stop:#{"%.5f" % stop}")
+        passed_to_log("#{msg} (#{"%.5f" % (stop - start)} seconds)") unless quiet
+        true
+      else
+        failed_to_log(msg)
+      end
+    else
+      failed_to_log(msg)
+    end
+  rescue
+    failed_to_log("Unable to #{msg}. '#{$!}'")
+  end
+
+  def wait_until_text(browser, strg, desc = '', timeout = 60)
+    if not strg.class.to_s.match('String')
+      raise "#{__method__} requires String for search target. #{strg.class} is not supported."
+    end
+    wait_until(browser, "'#{strg}' #{desc}", timeout) { browser.text.include? strg }
+  end
+
+  alias wait_until_by_text wait_until_text
+
+  def wait_until_by_link_text(browser, strg, desc = '')
+    wait_until_exists(browser, :link, :text, strg, desc)
+  end
+
+  def wait_until_enabled(browser, what, how, value, desc = '')
+    # TODO: This can be simplified
+    start = Time.now.to_f
+    begin
+      case what
+        when :link
+          Watir::Wait.until { browser.link(how, value).enabled? }
+        when :button
+          Watir::Wait.until { browser.button(how, value).enabled? }
+        when :radio
+          Watir::Wait.until { browser.radio(how, value).enabled? }
+        when :checkbox
+          Watir::Wait.until { browser.checkbox(how, value).enabled? }
+        when :div
+          Watir::Wait.until { browser.div(how, value).enabled? }
+        when :select_list
+          Watir::Wait.until { browser.select_list(how, value).enabled? }
+        when :text_field
+          Watir::Wait.until { browser.text_field(how, value).enabled? }
+        when :table
+          Watir::Wait.until { browser.table(how, value).enabled? }
+        else
+          raise "#{__method__}: Element #{what} not supported."
+      end
+    rescue => e
+      if e.class.to_s =~ /TimeOutException/
+        failed_to_log("Wait until (#{what} :#{how}=>#{value}) enabled. #{desc}: '#{$!}' #{desc}")
+        return false
+      elsif not rescue_me(e, __method__, "#{block.to_s}", "#{browser.class}")
+        raise e
+      end
+    end
+    stop = Time.now.to_f
+    #debug_to_log("#{__method__}: start:#{start} stop:#{stop}")
+    #    sleep 1
+    if validate(browser, @myName, __LINE__)
+      passed_to_log("Wait until (#{what} :#{how}=>#{value}) enabled. #{desc} (#{stop - start} seconds)")
+      true
+    end
+  rescue
+    failed_to_log("Unable to complete wait until (#{what} :#{how}=>#{value}) enabled. #{desc}: '#{$!}'")
+  end
+
+  def wait_until_visible(browser, element, how, what, desc = '')
+    start = Time.now.to_f
+    Watir::Wait.until(20) { browser.element(how, what).exists? }
+    begin
+      case element
+        when :link
+          Watir::Wait.until { browser.link(how, what).visible? }
+        when :button
+          Watir::Wait.until { browser.button(how, what).visible? }
+        when :radio
+          Watir::Wait.until { browser.radio(how, what).visible? }
+        when :checkbox
+          Watir::Wait.until { browser.checkbox(how, what).visible? }
+        when :div
+          Watir::Wait.until { browser.div(how, what).visible? }
+        when :select_list
+          Watir::Wait.until { browser.select_list(how, what).visible? }
+        when :text_field
+          Watir::Wait.until { browser.text_field(how, what).visible? }
+        else
+          Watir::Wait.until { browser.element(how, what).visible? }
+#          raise "#{__method__}: Element #{what} not supported."
+      end
+    rescue => e
+      if e.class.to_s =~ /TimeOutException/
+        failed_to_log("Wait until (#{what} :#{how}=>#{what}) visible. #{desc}: '#{$!}' #{desc}")
+        return false
+      elsif not rescue_me(e, __method__, '', "#{browser.class}")
+        raise e
+      end
+    end
+    stop = Time.now.to_f
+    #debug_to_log("#{__method__}: start:#{start} stop:#{stop}")
+    #    sleep 1
+    if validate(browser, @myName, __LINE__)
+      passed_to_log("Wait until (#{element} :#{how}=>#{what}) visible. #{desc} (#{stop - start} seconds)")
+      true
+    end
+  rescue
+    failed_to_log("Unable to complete wait until (#{element} :#{how}=>#{what}) visible. #{desc}: '#{$!}'")
+  end
+
+end

data/lib/version.rb

@@ -1,4 +1,4 @@
 module Awetestlib
-  VERSION = "0.0.3"
-  VERSION_DATE = "2012-07-19"
+  VERSION = "0.1.0"
+  VERSION_DATE = "2012-08-14"
 end

data/rdoc_test.bat

@@ -0,0 +1 @@
+rdoc --force-update -o c:/docs/rdoc_test --force-output lib/regression

data/test/create_zoho.rb

@@ -0,0 +1,65 @@
+module CreateZohoAccount1
+
+  def run_test(browser)
+    create_account_scenario_1(browser)
+    create_account_scenario_2(browser)
+  end
+
+  def create_account_scenario_1(browser)
+    create_account(browser)
+    create_blank_new_account(browser)
+    export_accounts(browser)
+    import_accounts(browser)
+    signout(browser)
+  end
+
+  def create_account_scenario_2(browser)
+    create_blank_new_account(browser)
+    reports(browser)
+    clone_account(browser)
+    pagination(browser)
+    verify_accounts(browser)
+    search_accounts(browser)
+    signout(browser)
+  end
+
+  def create_account(browser)
+    mark_testlevel('Create New Account', 1)
+    sleep_for(3)
+    click_text(browser, 'New Account')
+    wait_until_ready(browser, :name, /Account Name/)
+    set_textfield_by_name(browser, /Account Name/, "Test Account #1")
+    set_textfield_by_name(browser, /Phone/, "415-333-2311")
+
+    test_account_lookup(browser) #In Project Util
+    browser = attach_browser_by_url(browser, /ShowHomePage/)
+    select_option_by_name_and_option_text(browser, /Account Type/, "Analyst")
+    select_option_by_name_and_option_text(browser, /Industry/, "ASP")
+    set_textfield_by_name(browser, /Billing Street/, "201 Main St")
+    set_textfield_by_name(browser, /Billing City/, "San Francisco")
+    set_textfield_by_name(browser, /Billing State/, "CA")
+    set_textfield_by_name(browser, /Billing Code/, "94102")
+    set_textfield_by_name(browser, /Billing Country/, "USA")
+    #browser.cell(:text, 'Billing to Shipping').click
+    click(browser, :cell, :text, 'Billing to Shipping')
+    click_button_by_value(browser, 'Save')
+
+    wait_until_by_text(browser, 'Test Account #1')
+    validate_text(browser, "Test Account #1")
+    validate_text(browser, "random")
+  end
+
+  def test_account_lookup(browser)
+    mark_testlevel('Account Lookup', 1)
+    click(browser, :image, :title, 'Account Name Lookup')
+    sleep_for(5)
+    popup = attach_browser_by_url(browser, /Parent Account/)
+    set_textfield_by_name(popup, 'fldValue', 'test account #00')
+    click_button_by_value(popup, 'Go')
+    click(popup, :link, :text, 'Test Account #007')
+    browser = attach_browser_by_url(browser, /ShowHomePage/)
+    validate_textfield_value_by_name(browser, /Parent Account/, 'Test Account #007')
+  end
+
+
+end