awetestlib 0.1.2 → 0.1.5

data/lib/awetestlib/regression/waits.rb

@@ -0,0 +1,391 @@
+module Awetestlib
+  module Regression
+    module Waits
+
+      def sleep_for(seconds, dbg = true, desc = '')
+        msg = "Sleeping for #{seconds} seconds."
+        msg << " #{desc}" if desc.length > 0
+        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
+  end
+end
+

data/lib/awetestlib/runner.rb

@@ -0,0 +1,16 @@
+module Awetestlib
+  class Runner
+    def initialize(options = {})
+      build_class = "Awetestlib::#{check_script_type(options[:script_type])}::Runner".constantize
+      build_class.new(options).start
+    end
+
+    def check_script_type(script_type)
+      case script_type
+        when "Regression" ; "Regression" #Should this be regression? possible rename
+        else              ; script_type
+      end
+    end
+  end
+end
+

data/lib/version.rb

@@ -1,4 +1,4 @@
 module Awetestlib
-  VERSION = "0.1.2"
-  VERSION_DATE = "2012-08-15"
+  VERSION = "0.1.5"
+  VERSION_DATE = "2012-08-23"
 end

data/setup_samples/sample_netbeans/demo.rb

@@ -0,0 +1,86 @@
+module Demo
+  def run
+    browser = open_browser
+    login(browser)
+    test_zoho(browser)
+  end
+
+  def test_account_lookup(browser)
+    mark_testlevel('Account Lookup', 1)
+    browser.image(:title, 'Account Name Lookup').click
+    sleep_for(5)
+    popup = attach_browser_by_url(browser, /Parent/)
+    # TODO: This should be transparent:
+    if @browserAbbrev == "FF"
+      popup = browser
+    end
+    set_textfield_by_name(popup, 'fldValue', 'test')
+    click_button_by_value(popup, 'Go')
+    popup.link(:text, /Test Account/).click
+    #browser = attach_browser_by_url(browser, /ShowHomePage/)
+    #validate_textfield_value_by_name(browser, /Parent Account/, 'Test Account #007')
+  end
+
+  def login(browser)
+    mark_testlevel('Zoho Login', 2)
+    user     = "joeklienwatir@gmail.com" #@zohologin.cell(2,2)
+    password = "watir001"                #@zohologin.cell(2,3)
+    go_to_url(browser, "https://accounts.zoho.com/login?serviceurl=https://www.zoho.com/&hide_signup=true&css=https://www.zoho.com/css/login.css")
+    #browser.goto("https://accounts.zoho.com/login?serviceurl=https://www.zoho.com/&hide_signup=true&css=https://www.zoho.com/css/login.css")
+    set_textfield_by_name(browser, 'lid', user)
+    set_textfield_by_name(browser, 'pwd', password)
+    click_button_by_value(browser, 'Sign In')
+    go_to_url(browser, url = 'https://crm.zoho.com/crm/ShowHomePage.do')
+    validate_text(browser, 'Welcome joeklienwatir at Software')
+    #click_text(browser, 'Old Version')
+
+  end
+
+  def navigate_to_crm(browser)
+    mark_testlevel('Navigate to CRM', 1)
+    click_text(browser, 'CRM')
+  end
+
+  def test_zoho(browser)
+    #get_variables("#{@myRoot}/zoho_variables.xls")
+    navigate_to_crm(browser) #In Project Util
+    create_account(browser)
+    #create_blank_new_account(browser)
+    #export_accounts(browser)
+    #import_accounts(browser)
+    #signout(browser)
+  end
+
+  def create_account(browser)
+    mark_testlevel('Create New Account', 3)
+    sleep_for(3)
+    click_link(browser, 'Accounts')
+    sleep_for(3)
+    click_button_by_value(browser, 'New Account')
+    sleep_for(5)
+    # Watir::Waiter::wait_until { browser.text_field(:name, /Account Name/).exist? }
+                                 # Watir::Waiter::wait_until { browser.text_field(:name, /Account Name/).visible? }
+    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_button_by_id(browser, 'copyAddress')
+    sleep_for(5)
+    click_button_by_value(browser, 'Save')
+
+    sleep_for(8)
+                                 #wait_until_by_text(browser, 'Test Account #1')
+    validate_text(browser, "Test Account #1")
+    validate_text(browser, "random")
+  end
+
+end