awetestlib 0.1.3-x86-mingw32 → 0.1.5-x86-mingw32

data/lib/awetestlib/regression/find.rb

@@ -0,0 +1,431 @@
+module Awetestlib
+  module Regression
+    module Find
+
+      def get_select_list(browser, how, what, desc = '')
+        list = browser.select_list(how, what)
+        if validate(browser, @myName, __LINE__)
+          passed_to_log("Select list #{how}='#{what}' found and returned.")
+          return list
+        end
+      rescue
+        failed_to_log("Unable to return select list #{how}='#{what}': '#{$!}' (#{__LINE__})")
+      end
+
+      def get_select_options(browser, how, what, dump = false)
+        list = browser.select_list(how, what)
+        dump_select_list_options(list) if dump
+        list.options
+      rescue
+        failed_to_log("Unable to get select options for #{how}=>#{what}.  '#{$!}'")
+      end
+
+      def get_select_options_by_id(browser, strg, dump = false)
+        get_select_options(browser, :id, strg, dump)
+      end
+
+      def get_select_options_by_name(browser, strg, dump = false)
+        get_select_options(browser, :name, strg, dump)
+      end
+
+      def get_selected_options(browser, how, what)
+        begin
+          list = browser.select_list(how, what)
+        rescue => e
+          if not rescue_me(e, __method__, "browser.select_list(#{how}, '#{what}')", "#{browser.class}")
+            raise e
+          end
+        end
+        list.selected_options
+      end
+
+      def get_selected_options_by_id(browser, strg)
+        get_selected_options(browser, :id, strg)
+      end
+
+      alias get_selected_option_by_id get_selected_options_by_id
+
+      def get_selected_options_by_name(browser, strg)
+        get_selected_options(browser, :name, strg)
+      end
+
+      alias get_selected_option_by_name get_selected_options_by_name
+
+=begin rdoc
+  :category: A_rdoc_test
+Returns a reference to a division element.  Used to assign a div element to a variable
+which can then be passed to methods that require a *browser* parameter.
+
+_Parameters_::
+
+*browser* - a reference to the browser window or container element to be tested
+
+*how* - the element attribute used to identify the specific element. Valid values depend on the kind of element.
+Common values: :text, :id, :title, :name, :class, :href (:link only)
+
+*what* - a string or a regular expression to be found in the *how* attribute that uniquely identifies the element.
+
+*desc* - a string containing a message or description intended to appear in the log and/or report output
+
+_Example_
+
+  mainwindow = open_browser('www.myapp.com')  # open a browser to www.google.com
+  click(mainwindow, :button, :id, 'an id string')  # click a button that opens another browser window
+  popup = attach_browser(mainwindow, :url, '[url of new window]') *or*
+  popup = attach_browser(mainwindow, :title, '[title of new window]')
+
+=end
+
+      def get_div(browser, how, what, desc = '', dbg = false)
+        msg = "Get division #{how}=>#{what}."
+        msg << " #{desc}" if desc.length > 0
+        Watir::Wait.until { browser.div(how, what).exists? }
+        div = browser.div(how, what)
+        debug_to_log(div.inspect) if dbg
+        if validate(browser, @myName, __LINE__)
+          if div
+            passed_to_log(msg)
+            return div
+          else
+            failed_to_log(msg)
+          end
+        end
+      rescue
+        failed_to_log("Unable to '#{msg}' '#{$!}'")
+      end
+
+      def get_div_by_id(browser, strg, desc = '', dbg = false)
+        get_div(browser, :id, strg, desc, dbg)
+      end
+
+=begin rdoc
+  :category: A_rdoc_test
+Returns a reference to a division element identified by the value in its class attribute. Calls get_div()
+
+_Parameters_::
+
+*browser* - a reference to the browser window or container element to be tested
+
+*strg* - a string or a regular expression to be found in the *how* attribute that uniquely identifies the element.
+
+*desc* - a string containing a message or description intended to appear in the log and/or report output
+
+_Example_
+
+  mainwindow = open_browser('www.myapp.com')  # open a browser to www.google.com
+  click(mainwindow, :button, :id, 'an id string')  # click a button that opens another browser window
+  popup = attach_browser(mainwindow, :url, '[url of new window]') *or*
+  popup = attach_browser(mainwindow, :title, '[title of new window]')
+
+=end
+
+      def get_div_by_class(browser, strg, desc = '', dbg = false)
+        get_div(browser, :class, strg, desc, dbg)
+      end
+
+      def get_div_by_text(browser, strg, desc = '', dbg = false)
+        get_div(browser, :text, strg, desc, dbg)
+      end
+
+      def get_form(browser, how, strg)
+        begin
+          #       Watir::Wait.until( browser.form(how, strg).exists? )  # fails in wait_until
+        rescue => e
+          if not rescue_me(e, __method__, "browser.form(#{how}, '#{strg}').exists?", "#{browser.class}")
+            raise e
+          end
+        end
+        myForm = browser.form(how, strg)
+        if validate(browser, @myName, __LINE__)
+          passed_to_log("Form #{how}='#{strg}' found and returned.")
+          return myForm
+        end
+      rescue
+        failed_to_log("Unable to return form #{how}='#{strg}': '#{$!}' (#{__LINE__})")
+      end
+
+      def get_form_by_id(browser, strg)
+        get_form(browser, :id, strg)
+      end
+
+      def get_frame(browser, how, strg, desc = '')
+        #    begin
+        #      Watir::Wait.until(browser.frame(how, strg).exists?) # fails in wait_until
+        #    rescue => e
+        #      if not rescue_me(e, __method__, "browser.frame(#{how}, '#{strg}').exists?", "#{browser.class}")
+        #        raise e
+        #      end
+        #    end
+        begin
+          frame = browser.frame(how, strg)
+        rescue => e
+          if not rescue_me(e, __method__, "browser.frame(#{how}, '#{strg}').exists?", "#{browser.class}")
+            raise e
+          end
+        end
+        if validate(browser, @myName, __LINE__)
+          passed_to_log("Frame #{how}='#{strg}' found and returned. #{desc}")
+          return frame
+        end
+      rescue
+        failed_to_log("Unable to return frame #{how}='#{strg}'. #{desc}: '#{$!}' (#{__LINE__})")
+      end
+
+      def get_frame_by_id(browser, strg, desc = '')
+        get_frame(browser, :id, strg, desc)
+      end
+
+      def get_frame_by_index(browser, index, desc = '')
+        get_frame(browser, :index, index, desc)
+      end
+
+      def get_frame_by_name(browser, strg, desc = '')
+        get_frame(browser, :name, strg, desc)
+      end
+
+      def get_span(browser, how, strg, desc = '')
+        begin
+          #TODO: use LegacyExtensions#wait_until
+          Watir::Wait.until { browser.span(how, strg).exists? }
+        rescue => e
+          if not rescue_me(e, __method__, "browser.span(#{how}, '#{strg}').exists?", "#{browser.class}")
+            raise e
+          end
+        end
+        begin
+          span = browser.span(how, strg)
+        rescue => e
+          if not rescue_me(e, __method__, "browser.span(#{how}, '#{strg}').exists?", "#{browser.class}")
+            raise e
+          end
+        end
+        if validate(browser, @myName, __LINE__)
+          passed_to_log("Span #{how}='#{strg}' found and returned. #{desc}")
+          return span
+        end
+      rescue
+        failed_to_log("Unable to return span #{how}='#{strg}'. #{desc}: '#{$!}' (#{__LINE__})")
+      end
+
+      def get_span_by_id(browser, strg, desc = '')
+        get_span(browser, :id, strg, desc)
+      end
+
+=begin rdoc
+  :category: A_rdoc_test
+Returns a reference to a table element.  Used to assign a table element to a variable
+which can then be used directly or passed to methods that require a *browser* or *table* parameter.
+
+_Parameters_::
+
+*browser* - a reference to the browser window or container element to be tested
+
+*how* - the element attribute used to identify the specific element. Valid values depend on the kind of element.
+Common values: :text, :id, :title, :name, :class, :href (:link only)
+
+*what* - a string or a regular expression to be found in the *how* attribute that uniquely identifies the element.
+
+*desc* - a string containing a message or description intended to appear in the log and/or report output
+
+_Example_
+
+  a_table = get_table(browser, :id, 'table1')
+  a_table_cell = a_table[2][1]   # The cell in the first column of the second row of the table
+
+=end
+
+      def get_table(browser, how, what, desc = '')
+        msg = "Return table :#{how}='#{what}'. #{desc}"
+        tbl = browser.table(how, what)
+        if validate(browser, @myName, __LINE__)
+          passed_to_log(msg)
+          tbl
+        end
+      rescue
+        failed_to_log("#{msg}': '#{$!}'")
+      end
+
+      def get_table_by_id(browser, strg, desc = '')
+        get_table(browser, :id, strg, desc)
+      end
+
+      def get_table_by_index(browser, idx)
+        get_table(browser, :index, idx, desc)
+      end
+
+      def get_table_by_text(browser, strg)
+        get_table(browser, :text, strg, desc)
+      end
+
+      def get_table_headers(table, header_index = 1)
+        headers          = Hash.new
+        headers['index'] = Hash.new
+        headers['name']  = Hash.new
+        count            = 1
+        table[header_index].each do |cell|
+          if cell.text.length > 0
+            name                    = cell.text.gsub(/\s+/, ' ')
+            headers['index'][count] = name
+            headers['name'][name]   = count
+          end
+          count += 1
+        end
+        #debug_to_log("#{__method__}:****** headers:\n#{headers.to_yaml}")
+        headers
+      rescue
+        failed_to_log("Unable to get content headers. '#{$!}'")
+      end
+
+      def get_element(browser, element, how, what, value = nil)
+        target = nil
+        what = Regexp.new(Regexp.escape(what)) unless how == :index or what.is_a?(Regexp)
+        case element
+          when :link
+            target = browser.link(how, what)
+          when :button
+            target = browser.button(how, what)
+          when :div
+            target = browser.div(how, what)
+          when :checkbox
+            target = browser.checkbox(how, what, value)
+          when :text_field, :textfield
+            target = browser.text_field(how, what)
+          when :image
+            target = browser.image(how, what)
+          when :file_field, :filefield
+            target = browser.file_field(how, what)
+          when :form
+            target = browser.form(how, what)
+          when :frame
+            target = browser.frame(how, what)
+          when :radio
+            target = browser.radio(how, what, value)
+          when :span
+            target = browser.span(how, what)
+          when :table
+            target = browser.table(how, what)
+          when :li
+            target = browser.li(how, what)
+          when :select_list, :selectlist
+            target = browser.select_list(how, what)
+          when :hidden
+            target = browser.hidden(how, what)
+          when :area
+            target = browser.area(how, what)
+        end
+        if target.exists?
+          target
+        else
+          nil
+        end
+      rescue => e
+        if not rescue_me(e, __method__, "browser.#{element}(#{how}, '#{what}')", "#{browser.class}", target)
+          raise e
+        end
+      end
+
+      def get_objects(browser, which, dbg=false)
+        cnt = 0
+        case which
+          when :links
+            list = browser.links
+            sleep(1)
+          when :tables
+            list = browser.tables
+          when :divs
+            list = browser.divs
+          when :buttons
+            list = browser.buttons
+          when :checkboxes
+            list = browser.checkboxes
+          when :radios
+            list = browser.radios
+          when :selectlists
+            list = browser.selectlists
+          when :textfields
+            list = browser.textfields
+          when :lis
+            list = browser.lis
+          else
+            debug_to_log("Unrecognized dom object '#{which}'")
+        end
+        if dbg
+          list.each do |obj|
+            cnt += 1
+            debug_to_log("\n==========#{which}:\nindex:     #{cnt}\n#{obj}\n#{obj.to_yaml}")
+          end
+        end
+        list
+      end
+
+      def get_ole(element)
+        ole = element.ole_object
+        if ole
+          passed_to_log("Found ole_object for #{element}.")
+          ole
+        else
+          failed_to_log("Did not find ole_object for #{element}.")
+        end
+      rescue
+        failed_to_log("Unable to find ole_object for #{element}.  #{$!}")
+      end
+
+      def find_all_links_with_exact_href(browser, href)
+        links = browser.links
+        hash  = Hash.new
+        idx   = 0
+        links.each do |l|
+          idx     += 1
+          an_href = href
+          my_href = l.href
+          if my_href == an_href
+            hash[idx] = l
+            debug_to_log("#{__method__}:#{idx}\n********\n#{l.to_s}\n\n#{l.to_yaml}")
+          end
+        end
+        hash
+      end
+
+      def find_link_with_exact_href(browser, href)
+        links = browser.links
+        link  = nil
+        index = 0
+        links.each do |l|
+          index   += 1
+          an_href = href
+          my_href = l.href
+          if my_href == an_href
+            link = l
+    #        debug_to_log("#{__method__}:#{__LINE__}\n********\n#{l.to_s}\n\n#{l.to_yaml}")
+            break
+          end
+        end
+        link
+      end
+
+      def find_index_for_object(browser, obj, how, ord, strg)
+        obj_sym = (obj.to_s.pluralize).to_sym
+        how_str = how.to_s
+        ptrn    = /#{how}:\s+#{strg}/i
+        list    = get_objects(browser, obj_sym, true)
+        cnt     = 0
+        idx     = 0
+        list.each do |nty|
+          s = nty.to_s
+          #      a    = nty.to_a
+          if s =~ ptrn
+            cnt += 1
+            if cnt == ord
+              break
+            end
+          end
+          idx += 1
+        end
+        idx
+      end
+
+
+    end
+  end
+end
+

data/lib/awetestlib/regression/legacy.rb

@@ -0,0 +1,45 @@
+module Awetestlib
+  module Regression
+    module Legacy
+
+      #--
+      ##def open_log
+      #  start = Time.now.to_f.to_s
+      #
+      #  logTS = Time.at(@myRun.launched.to_f).strftime("%Y%m%d%H%M%S")
+      #  xls = @myAppEnv.xls_name.gsub('.xls', '') + '_' if  @myAppEnv.xls_name.length > 0
+      #  @logFileSpec = "#{@myRoot}/#{logdir}/#{@myName}_#{@targetBrowser.abbrev}_#{xls}#{logTS}.log"
+      #  init_logger(@logFileSpec, @myName)
+      #
+      #                                                  #    message_tolog( self.inspect )
+      #  message_to_log("#{@myName} launched at [#{@myRun.launched.to_f.to_s}][#{@myScript.id}][#{@myRun.id}][#{@myChild.id}]")
+      #  debug_to_log("pid: #{$$}")
+      #  message_to_log("#{@myName} begin at [#{start}]")
+      #  message_to_log("#{@myName} environment [#{@myAppEnv.name}]")
+      #  message_to_log("#{@myName} xls_name [#{@myAppEnv.xls_name}]") if  @myAppEnv.xls_name.length > 0
+      #  message_to_log("#{@myName} rootDir [#{@myRoot}]")
+      #  message_to_log("#{@myName} Target Browser [#{@targetBrowser.name}]")
+      #  mark_testlevel(@myParent.name, @myParent.level) # Module
+      #  mark_testlevel(@myChild.name, @myChild.level) # SubModule
+      #
+      #end
+      #++
+
+      #def find_me(where, how, what)
+      #  me = where.element(how, what)
+      #  puts me.inspect
+      #rescue
+      #  error_to_log("#{where.inspect} doesn't seem to respond to element() #{$!}")
+      #end
+
+    #  def click_me(element)
+    #    element.click
+    #  rescue
+    #    error_to_log("#{element.inspect} doesn't seem to respond to click() #{$!}")
+    #  end
+
+
+    end
+  end
+end
+

data/lib/awetestlib/regression/page_data.rb

@@ -0,0 +1,190 @@
+module Awetestlib
+  module Regression
+    module PageData
+
+=begin rdoc
+:category: Page Data
+:tags: data, DOM, page
+
+_Parameters_::
+
+*browser* is any container element, usually the browser window or a div within it.  Best to use is the smallest that contains the desired data.
+
+*types* is an array that defaults to all of: :text, :textarea, :select_list, :span, :hidden, :checkbox, and :radio.
+Set types to an array of a subset of these if fewer elements are desired.
+
+No positive validations are reported but failure is rescued and reported.
+=end
+      def capture_page_data(browser, types = [:text, :textarea, :select_list, :span, :hidden, :checkbox, :radio])
+        start = Time.now
+        debug_to_log("Begin #{__method__}")
+        data         = Hash.new
+        data[:id]    = Hash.new
+        data[:name]  = Hash.new
+        data[:index] = Hash.new
+        types.each do |type|
+          #debug_to_log("#{__method__}: #{type}. . .")
+          data[:id][type], data[:name][type], data[:index][type] = parse_elements(browser, type)
+        end
+        data
+      rescue
+        failed_to_log("#{__method__}: '#{$!}'")
+      ensure
+        stop = Time.now
+        passed_to_log("#{__method__.to_s.titleize} finished. (#{"%.5f" % (stop - start)} secs)")
+        #debug_to_log("End #{__method__}")
+      end
+
+      def compare_page_data(before, after, how, desc = '')
+        [:text, :textarea, :select_list, :span, :checkbox, :radio].each do |type|
+          before[how][type].each_key do |what|
+            msg = "#{desc} #{type} #{how}=#{what}: Expected '#{before[how][type][what]}'."
+            if after[how][type][what] == before[how][type][what]
+              passed_to_log(msg)
+            else
+              failed_to_log("#{msg} Found '#{after[how][type][what]}'")
+            end
+          end
+        end
+      rescue
+        failed_to_log("Unable to compare before and after page data. '#{$!}'")
+      end
+
+=begin rdoc
+:category: Page Data
+:tags:data, DOM
+
+*data* is the hash returned by capture_page_data().
+
+*how* is one of :id, :name, :index
+
+*what* is the target value for how. It can be a string or a regular expression
+
+*type* is one of :text,:textarea,:select_list,:span,:hidden,:checkbox,:radio
+
+*get_text* determines whether selected option's text or value is returned. Default is true, i.e., return the selected text.
+This only applies when the *type* is :select_list.
+
+=end
+      def fetch_page_data(data, how, what, type, get_text = true)
+        rslt = data[how][type][what]
+        if type == :select_list
+          value, text = rslt.split('::')
+          if get_text
+            rslt = text
+          else
+            rslt = value
+          end
+        end
+        rslt
+      end
+
+=begin rdoc
+:category: Page Data
+:tags:data, DOM
+
+*browser* is any container element.  best to use is the smallest that contains the desired data.
+
+*type* is one of these symbols: :text,:textarea,:select_list,:span,:hidden,:checkbox,:radio
+
+Returns three hashes: id[type][id] = value, name[type][id] = value, index[type][id] = value
+
+A given element appears once in the set of hashes depending on how is is found: id first
+then name, then index.
+
+Select list value is in the form 'value::text'. parse with x.split('::')
+
+No positive validations are reported but failure is rescued and reported.
+=end
+      def parse_elements(browser, type)
+        id    = Hash.new
+        name  = Hash.new
+        index = Hash.new
+        idx   = 0
+        #debug_to_log("#{__method__}: #{type}")
+        case type
+          when :span
+            collection = browser.spans
+          when :select_list
+            collection = browser.select_lists
+          when :radio
+            collection = browser.radios
+          when :checkbox
+            collection = browser.checkboxes
+          else
+            collection = browser.elements(:type, type.to_s)
+        end
+        #debug_to_log("#{__method__}: collection: #{collection.inspect}")
+        collection.each do |e|
+          case type
+            when :span
+              vlu = e.text
+            when :select_list
+              vlu = "#{e.value}::#{e.selected_options[0]}"
+            when :radio
+              vlu = e.set?
+            when :checkbox
+              vlu = e.set?
+            else
+              vlu = e.value
+          end
+          idx += 1
+          if e.id.length > 0 and not e.id =~ /^__[A-Z]/
+            id[e.id] = vlu
+          elsif e.name.length > 0 and not e.name =~ /^__[A-Z]/
+            name[e.name] = vlu
+          else
+            index[idx] = vlu if not type == :hidden
+          end
+        end
+        [id, name, index]
+
+      rescue
+        failed_to_log("#{__method__}: '#{$!}'")
+      end
+
+      def get_textfield_value(browser, how, what, desc = '')
+        msg = "Return value in textfield #{how}='#{what}'"
+        msg << " #{desc}" if desc.length > 0
+        tf = browser.text_field(how, what)
+        if validate(browser, @myName, __LINE__)
+          if tf
+            debug_to_log("#{tf.inspect}")
+            vlu = tf.value
+            passed_to_log("#{msg} Value='#{vlu}'")
+            vlu
+          else
+            failed_to_log("#{msg}")
+          end
+        end
+      rescue
+        failed_to_log("Unable to #{msg}: '#{$!}'")
+      end
+
+      def get_textfield_value_by_name(browser, strg, desc = '')
+        get_textfield_value(browser, :name, strg, desc)
+      end
+
+      def get_textfield_value_by_id(browser, strg)
+        get_textfield_value(browser, :id, strg)
+      end
+
+      def get_element_text(browser, element, how, what, desc = '')
+        msg = "Return text in #{element} #{how}='#{what}'"
+        msg << " #{desc}" if desc.length > 0
+        text = browser.element(how, what).text
+        if validate(browser, @myName, __LINE__)
+          passed_to_log("#{msg} text='#{text}'")
+          text
+        end
+      rescue
+        failed_to_log("Unable to #{msg}: '#{$!}'")
+      end
+
+
+
+
+    end
+  end
+end
+