awetestlib 0.1.30-x86-mingw32 → 1.2.4-x86-mingw32

data/lib/awetestlib/regression/test_data.rb

@@ -0,0 +1,354 @@
+module Awetestlib
+
+  module Regression
+
+    module TestData
+
+      def load_variables(file, key_type = :role, enabled_only = true, dbg = true, scripts = nil)
+        mark_test_level(build_message(file, "key:'#{key_type}'"))
+
+        # ok = true
+
+        debug_to_log("#{__method__}: file = #{file}")
+        debug_to_log("#{__method__}: key  = #{key_type}")
+
+        workbook = file =~ /\.xlsx$/ ? Roo::Excelx.new(file) : Roo::Excel.new(file)
+
+        if @myName =~ /appium/i
+          ok = script_found_in_data = script_found_in_login = true
+        else
+          script_found_in_data      = load_data_variables(workbook, dbg)
+          ok, script_found_in_login = load_login_variables(workbook, enabled_only, file, key_type, scripts, dbg)
+        end
+
+        unless @env_name =~ /^gen/
+          unless ok and script_found_in_login and script_found_in_data
+            ok = false
+            failed_to_log("Script found: in Login = #{script_found_in_login}; in Data = #{script_found_in_data}")
+          end
+        end
+
+        workbook.close
+
+        ok
+      rescue
+        failed_to_log(unable_to)
+      end
+
+      alias get_variables load_variables
+
+      def load_login_variables(workbook, enabled_only, file, key_type, scripts, dbg = nil)
+
+        ok                    = true
+        script_found_in_login = false
+        @login                = Hash.new
+        enabled_cnt           = 0
+        script_col            = 0
+        role_col              = 0
+        userid_col            = 0
+        company_col           = 0
+        password_col          = 0
+        url_col               = 0
+        env_col               = 0
+        name_col              = 0
+        appid_col             = 0
+        ref_col               = 0
+        node_col              = 0
+        login_index           = find_sheet_with_name(workbook, 'Login')
+        if login_index and login_index >= 0
+          workbook.default_sheet = workbook.sheets[login_index]
+
+          1.upto(workbook.last_column) do |col|
+            column_name = workbook.cell(1, col).downcase
+            case column_name
+              when @myName.downcase
+                script_col            = col
+                script_found_in_login = true
+                if scripts.is_a?(Array)
+                  scripts << column_name
+                else
+                  break
+                end
+              when 'role'
+                role_col = col
+              when 'userid', 'user_id'
+                userid_col = col
+              when 'companyid', 'company_id'
+                company_col = col
+              when 'password'
+                password_col = col
+              when 'url'
+                url_col = col
+              when 'environment'
+                env_col = col
+              when /reference/i
+                ref_col = col
+              when 'nodename'
+                node_col = col
+              when 'name'
+                name_col = col
+              when 'appid', 'app_id'
+                appid_col = col
+              else
+                scripts << column_name if scripts.is_a?(Array)
+            end
+          end
+
+          2.upto(workbook.last_row) do |line|
+            role      = workbook.cell(line, role_col)
+            userid    = workbook.cell(line, userid_col)
+            password  = workbook.cell(line, password_col)
+            url       = workbook.cell(line, url_col)
+            env       = workbook.cell(line, env_col)
+            username  = workbook.cell(line, name_col)
+            nodename  = workbook.cell(line, node_col)
+            companyid = workbook.cell(line, company_col)
+            appid     = workbook.cell(line, appid_col)
+            enabled   = workbook.cell(line, script_col).to_s
+            refs      = workbook.cell(line, ref_col)
+
+            case key_type
+              when :id, :userid
+                key = userid
+              when :environment
+                key = env
+              when :role
+                key = role
+              else
+                key = userid
+            end
+
+            if enabled_only and enabled.length == 0
+              next
+            end
+
+            @login[key]                = Hash.new
+            @login[key]['role']        = role
+            @login[key]['userid']      = userid
+            @login[key]['companyid']   = companyid
+            @login[key]['password']    = password
+            @login[key]['url']         = url
+            @login[key]['name']        = username
+            @login[key]['nodename']    = nodename
+            @login[key]['enabled']     = enabled
+            @login[key]['environment'] = env
+            @login[key]['appid']       = appid
+            @login[key]['references']  = refs
+
+            if enabled =~ /^y$/i
+              case key_type
+                when :environment
+                  case env
+                    when /^gen/i
+                      enabled_cnt += 1
+                    else
+                      enabled_cnt += 1 if @env_name =~ /#{env}/
+                  end
+                else
+                  enabled_cnt += 1
+              end
+            end
+
+          end
+
+          @login.keys.sort.each do |key|
+            message_to_log("@login (by #{key_type}): #{key}='#{@login[key].to_yaml}'")
+          end if dbg
+
+        else
+          fail "'Login' worksheet not found in #{file}"
+        end
+
+        unless enabled_cnt > 0
+          ok = false
+          case key_type
+            when :environment
+              err_msg = "No enabled 'Login' entries for rows matching :#{key_type} => '#{@env_name}'"
+            else
+              err_msg = "No enabled 'Login' entries for rows matching :#{key_type}"
+          end
+          fail err_msg
+        end
+
+        return ok, script_found_in_login
+      rescue
+        failed_to_log(unable_to)
+      end
+
+      def load_data_variables(workbook, dbg = nil)
+
+        script_found_in_data = false
+
+        @var                   = Hash.new
+        data_index             = find_sheet_with_name(workbook, 'Data')
+        workbook.default_sheet = workbook.sheets[data_index]
+        var_col                = 0
+        default_col            = 2
+
+        2.upto(workbook.last_column) do |col|
+          script_name = workbook.cell(1, col)
+          if script_name == 'default'
+            default_col = col
+          end
+          if script_name == @myName
+            var_col              = col
+            script_found_in_data = true
+            break
+          end
+        end
+
+        defaults = {}
+        2.upto(workbook.last_row) do |line|
+          name           = workbook.cell(line, 'A')
+          value          = workbook.cell(line, default_col).to_s.strip
+          defaults[name] = value
+        end
+
+        2.upto(workbook.last_row) do |line|
+          name  = workbook.cell(line, 'A')
+          value = workbook.cell(line, var_col).to_s.strip
+          if value and value.length > 0
+            @var[name] = value
+          else
+            @var[name] = defaults[name]
+          end
+        end
+
+        @var.keys.sort.each do |name|
+          message_to_log("@var #{name}: '#{@var[name]}'")
+        end if dbg
+
+        script_found_in_data
+      rescue
+        failed_to_log(unable_to)
+      end
+
+      def load_html_validation_filters(file = @refs_spec)
+        sheet         = 'HTML Validation Filters'
+        workbook      = file =~ /\.xlsx$/ ? Roo::Excelx.new(file) : Roo::Excel.new(file)
+        @html_filters = Hash.new
+
+        sheet_index = find_sheet_with_name(workbook, "#{sheet}")
+        if sheet_index > -1
+          debug_to_log("Loading worksheet '#{sheet}'.")
+          workbook.default_sheet = workbook.sheets[sheet_index]
+
+          columns = Hash.new
+
+          1.upto(workbook.last_column) do |col|
+            columns[workbook.cell(1, col).to_sym] = col
+          end
+
+          2.upto(workbook.last_row) do |line|
+            identifier               = workbook.cell(line, columns[:identifier])
+            validator                = workbook.cell(line, columns[:validator])
+            pattern                  = workbook.cell(line, columns[:pattern])
+            action                   = workbook.cell(line, columns[:action])
+            alt_pattern              = workbook.cell(line, columns[:alt_pattern])
+            alt_action               = workbook.cell(line, columns[:alt_action])
+            script                   = workbook.cell(line, columns[:script])
+            head                     = workbook.cell(line, columns[:head])
+            meta                     = workbook.cell(line, columns[:meta])
+            body                     = workbook.cell(line, columns[:body])
+            frame                    = workbook.cell(line, columns[:frame])
+            fragment                 = workbook.cell(line, columns[:fragment])
+            report_more              = workbook.cell(line, columns[:report_more])
+            description              = workbook.cell(line, columns[:description])
+
+            # pattern = pattern ? Regexp.escape(pattern) : nil
+            # alt_pattern = alt_pattern ? Regexp.escape(alt_pattern) : nil
+
+            @html_filters[validator] = Hash.new unless @html_filters[validator]
+
+            @html_filters[validator][identifier] = {
+                :validator   => validator,
+                :pattern     => pattern,
+                :action      => action,
+                :alt_pattern => alt_pattern,
+                :alt_action  => alt_action,
+                :script      => script,
+                :head        => head,
+                :meta        => meta,
+                :body        => body,
+                :frame       => frame,
+                :fragment    => fragment,
+                :report_more => report_more,
+                :description => description }
+          end
+        else
+          failed_to_log("Worksheet '#{sheet}' not found #{file}")
+        end
+
+        @html_error_references = Hash.new
+
+        sheet       = 'HTML Error References'
+        sheet_index = find_sheet_with_name(workbook, "#{sheet}")
+        if sheet_index > -1
+          debug_to_log("Loading worksheet '#{sheet}'.")
+          workbook.default_sheet = workbook.sheets[sheet_index]
+
+          columns = Hash.new
+
+          1.upto(workbook.last_column) do |col|
+            columns[workbook.cell(1, col).to_sym] = col
+          end
+
+          2.upto(workbook.last_row) do |line|
+            validator                       = workbook.cell(line, columns[:validator])
+            pattern                         = workbook.cell(line, columns[:pattern])
+            reference                       = workbook.cell(line, columns[:reference])
+            component                       = workbook.cell(line, columns[:component])
+            alm_df                          = workbook.cell(line, columns[:alm_df])
+            jira_ref                        = workbook.cell(line, columns[:jira_ref])
+            description                     = workbook.cell(line, columns[:description])
+
+            # pattern                         = pattern ? Regexp.escape(pattern) : nil
+
+            @html_error_references[pattern] = {
+                :validator   => validator,
+                :reference   => reference,
+                :component   => component,
+                :alm_df      => alm_df,
+                :jira_ref    => jira_ref,
+                :description => description }
+          end
+        else
+          failed_to_log("Worksheet '#{sheet}' not found #{file}")
+        end
+
+        workbook.close
+
+        [@html_filters, @html_error_references]
+      rescue
+        failed_to_log(unable_to)
+      end
+
+      def parse_test_flag(string)
+        test    = false
+        refs    = nil
+        arr     = string.is_a?(Array) ? string : string.to_s.split(/,\s*/)
+        ref_arr = []
+        arr.each { |r| ref_arr << format_reference(r) }
+        if string
+          if string == true or string == false
+            test = string
+          else
+            if string.length > 0
+              unless string =~ /^no$|^false$/i
+                test = true
+                unless string =~ /^yes$|^true$/i
+                  refs = format_refs(string)
+                end
+              end
+            end
+          end
+        end
+        [test, refs, ref_arr]
+      rescue
+        failed_to_log(unable_to)
+      end
+
+
+    end
+  end
+end

data/lib/awetestlib/regression/user_input.rb

@@ -22,42 +22,73 @@ module Awetestlib
       # @param [String] desc Contains a message or description intended to appear in the log and/or report output
       # @return [Boolean] True if the Watir or Watir-webdriver function does not throw an exception.
       #
-      def click(browser, element, how, what, desc = '')
-        #debug_to_log("#{__method__}: #{element}, #{how}, #{what}")
-        msg = build_message("#{__method__.to_s.humanize} :#{element} :#{how}=>'#{what}'", desc)
-        case element
-          when :link
-            browser.link(how, what).click
-          when :button
-            browser.button(how, what).click
-          when :image
-            browser.image(how, what).click
-          when :radio
-            case how
-              when :index
-                set_radio_by_index(browser, what, desc)
-              else
-                browser.radio(how, what).set
-            end
-          when :span
-            browser.span(how, what).click
-          when :div
-            browser.div(how, what).click
-          when :cell
-            browser.cell(how, what).click
-          else
-            browser.element(how, what).click
+      def click(container, element, how, what, desc = '', wait = 10)
+        msg  = build_message("#{__method__.to_s.humanize} :#{element} :#{how}=>'#{what}'", desc, wait.to_s)
+        code = build_webdriver_fetch(element, how, what)
+        begin
+          eval("#{code}.when_present(#{wait}).click")
+        rescue => e
+          unless rescue_me(e, __method__, rescue_me_command(element, how, what, __method__.to_s), "#{container.class}")
+            raise e
+          end
         end
         passed_to_log(msg)
         true
       rescue
-        failed_to_log("Unable to #{msg}. '#{$!}'")
+        if desc =~ /second try/i
+          passed_to_log(unable_to(msg))
+        else
+          failed_to_log(unable_to(msg))
+        end
+      end
+
+      alias click_js click
+
+      def click_as_needed(browser, target_container, target_elem, target_how, target_what, confirm_container, confirm_elem, confirm_how, confirm_what, desc = '', neg = false)
+        rtrn = true
+        nope = neg ? 'not ' : ''
+        debug_to_log("#{__method__.to_s.titleize}: Target:  :#{target_elem} :#{target_how}=>'#{target_what}' in #{target_container}")
+        debug_to_log("#{__method__.to_s.titleize}: Confirm: :#{confirm_elem} :#{confirm_how}=>'#{confirm_what}' in #{confirm_container}")
+        windows_to_log(browser)
+        click(target_container, target_elem, target_how, target_what, desc)
+
+        if confirm_elem == :window
+          query = 'current?'
+        else
+          query = 'present?'
+        end
+
+        if confirm_what.is_a?(Regexp)
+          code = "#{nope}confirm_container.#{confirm_elem.to_s}(:#{confirm_how}, /#{confirm_what}/).#{query}"
+        else
+          code = "#{nope}confirm_container.#{confirm_elem.to_s}(:#{confirm_how}, '#{confirm_what}').#{query}"
+        end
+        debug_to_log("#{__method__}: code=[#{code}]")
+        limit = 30.0
+        increment = 0.5
+        seconds = 0.0
+        until eval(code) do
+          debug_to_log("#{__method__}: seconds=[#{seconds}] [#{code}]")
+          sleep(increment)
+          seconds += increment
+          if seconds.modulo(3.0) == 0.0
+            click(target_container, target_elem, target_how, target_what, "#{desc} (#{seconds} seconds)")
+          end
+          if seconds > limit
+            rtrn = false
+            break
+          end
+        end
+        rtrn
+      rescue
+        failed_to_log(unable_to)
       end
 
       # Click a specific DOM element by one of its attributes (*how) and that attribute's value (*what) and
       # do not wait for the browser to finish reloading.  Used when a modal popup or alert is expected. Allows the script
       # to keep running so the popup can be handled.
-      # @todo handle using Watir Webdriver which does not need no_wait.
+      #
+      # Call is passed to click() if using watir-webdriver as it does not recognize click_no_wait.
       #
       # @example
       #  # html for a link element:
@@ -71,40 +102,44 @@ module Awetestlib
       # @return (see #click)
       #
       def click_no_wait(browser, element, how, what, desc = '')
-        msg = build_message("#{__method__.to_s.humanize} :#{element} :#{how}=>'#{what}'", desc)
-        begin
-          case element
-            when :link
-              browser.link(how, what).click_no_wait
-            when :button
-              browser.button(how, what).click_no_wait
-            when :image
-              browser.image(how, what).click_no_wait
-            when :radio
-              case how
-                when :index
-                  set_radio_no_wait_by_index(browser, what, desc)
-                else
-                  browser.radio(how, what).click_no_wait
-              end
-            when :span
-              browser.span(how, what).click_no_wait
-            when :div
-              browser.div(how, what).click_no_wait
-            when :checkbox
-              browser.checkbox(how, what).click_no_wait
-            when :cell
-              browser.cell(how, what).click_no_wait
-            else
-              browser.element(how, what).click_no_wait
-          end
-        rescue => e
-          unless rescue_me(e, __method__, rescue_me_command(element, how, what, :click_no_wait), "#{browser.class}")
-            raise e
+        if $using_webdriver
+          click(browser, element, how, what, "#{desc} (called from click_no_wait)") # [#50300875]
+        else
+          msg = build_message("#{__method__.to_s.humanize} :#{element} :#{how}=>'#{what}'", desc)
+          begin
+            case element
+              when :link
+                browser.link(how, what).click_no_wait
+              when :button
+                browser.button(how, what).click_no_wait
+              when :image
+                browser.image(how, what).click_no_wait
+              when :radio
+                case how
+                  when :index
+                    set_radio_no_wait_by_index(browser, what, desc)
+                  else
+                    browser.radio(how, what).click_no_wait
+                end
+              when :span
+                browser.span(how, what).click_no_wait
+              when :div
+                browser.div(how, what).click_no_wait
+              when :checkbox
+                browser.checkbox(how, what).click_no_wait
+              when :cell
+                browser.cell(how, what).click_no_wait
+              else
+                browser.element(how, what).click_no_wait
+            end
+          rescue => e
+            unless rescue_me(e, __method__, rescue_me_command(element, how, what, :click_no_wait), "#{browser.class}")
+              raise e
+            end
           end
+          passed_to_log(msg)
+          true
         end
-        passed_to_log(msg)
-        true
       rescue
         failed_to_log("Unable to #{msg}  '#{$!}'")
         sleep_for(1)
@@ -270,9 +305,11 @@ module Awetestlib
       # @param [Boolean] nofail If true do not log a failed message if the option is not found in the select list.
       # @return (see #click)
       def select_option(browser, how, what, which, option, desc = '', nofail = false)
-        list = browser.select_list(how, what)
+        list = browser.select_list(how, what).when_present
         msg  = build_message("from list with :#{how}=>'#{what}", desc)
         select_option_from_list(list, which, option, msg, nofail)
+      rescue
+        failed_to_log(unable_to)
       end
 
       # Set radio button or checkbox to selected.
@@ -410,26 +447,21 @@ module Awetestlib
       def set_text_field(browser, how, what, value, desc = '', skip_value_check = false)
         #TODO: fix this to handle Safari password field
         msg = build_message("#{__method__.to_s.humanize} #{how}='#{what}' to '#{value}'", desc)
-        msg << " (Skip value check)" if skip_value_check
-        if browser.text_field(how, what).exists?
-          tf = browser.text_field(how, what)
-          tf.set(value)
-          if skip_value_check
+        msg << ' (Skip value check)' if skip_value_check
+        browser.text_field(how, what).when_present.set(value)
+        if skip_value_check
+          passed_to_log(msg)
+          true
+        else
+          if browser.text_field(how, what).value == value
             passed_to_log(msg)
             true
           else
-            if tf.value == value
-              passed_to_log(msg)
-              true
-            else
-              failed_to_log("#{msg}: Found:'#{tf.value}'.")
-            end
+            failed_to_log("#{msg}: Found:'#{browser.text_field(how, what).value}'.")
           end
-        else
-          failed_to_log("#{msg}: Textfield not found")
         end
       rescue
-        failed_to_log("Unable to '#{msg}': '#{$!}'")
+        failed_to_log(unable_to(msg))
       end
 
       alias set_textfield set_text_field
@@ -542,33 +574,87 @@ module Awetestlib
       # @param [String] desc Contains a message or description intended to appear in the log and/or report output
       # @return (see #click)
       #
-      def fire_event(browser, element, how, what, event, desc = '')
-        msg = build_message("#{element.to_s.titlecase}: #{how}=>'#{what}' event:'#{event}'", desc)
+      def fire_event(container, element, how, what, event, desc = '', wait = 10)
+        msg  = build_message("#{element.to_s.titlecase}: #{how}=>'#{what}' event:'#{event}'", desc)
+        code = build_webdriver_fetch(element, how, what)
         begin
-          case element
-            when :link
-              browser.link(how, what).fire_event(event)
-            when :button
-              browser.button(how, what).fire_event(event)
-            when :image
-              browser.image(how, what).fire_event(event)
-            when :span
-              browser.span(how, what).fire_event(event)
-            when :div
-              browser.div(how, what).fire_event(event)
-            else
-              browser.element(how, what).fire_event(event)
-          end
+          eval("#{code}.when_present(#{wait}).fire_event('#{event}')")
         rescue => e
-          unless rescue_me(e, __method__, rescue_me_command(element, how, what, __method__.to_s, event), "#{browser.class}")
+          unless rescue_me(e, __method__, rescue_me_command(element, how, what, __method__.to_s, event), "#{container.class}")
             raise e
           end
         end
-        passed_to_log("Fire event: #{msg}. #{desc}")
+        passed_to_log(msg)
         true
       rescue
-        failed_to_log("Unable to fire event: #{msg}. '#{$!}' #{desc}")
+        failed_to_log(unable_to(msg))
+      end
+
+      def resize_browser_window(browser, width, height, move_to_origin = true)
+        browser.driver.manage.window.resize_to(width, height)
+        message_to_report("Browser window resized to (#{width}, #{height}).")
+        sleep_for(0.5)
+        if move_to_origin
+          browser.driver.manage.window.move_to(0, 0)
+          message_to_report('Browser window moved to origin (0, 0).')
+        end
+        scroll_to_top(browser)
+      rescue
+        failed_to_log(unable_to)
+      end
+      alias resize_window resize_browser_window
+
+      #TODO: does this really scroll all the way to the bottom?
+      def send_page_down(browser)
+        browser.send_keys :page_down
+        debug_to_log('Sent page down')
+      end
+      alias scroll_to_bottom send_page_down
+      alias press_page_down send_page_down
+
+      #TODO: does this really scroll all the way to the top?
+      def sent_page_up(browser)
+        browser.send_keys :page_up
+        debug_to_log('Sent page up')
+      end
+      alias scroll_to_top sent_page_up
+      alias press_page_up sent_page_up
+
+      def send_spacebar(browser)
+        browser.send_keys :space
+        debug_to_log('Sent space')
+      end
+      alias press_spacebar send_spacebar
+
+      def send_enter(browser)
+        browser.send_keys :enter
+        debug_to_log('Sent enter')
+      end
+      alias press_enter send_enter
+
+      def send_tab(browser)
+        browser.send_keys :tab
+        debug_to_log('Sent tab')
+      end
+      alias press_tab send_tab
+
+      def send_right_arrow(browser)
+        browser.send_keys :arrow_right
+        debug_to_log('Sent right arrow')
+      end
+      alias press_right_arrow send_right_arrow
+
+      def send_left_arrow(browser)
+        browser.send_keys :arrow_left
+        debug_to_log('Sent left arrow')
+      end
+      alias press_left_arrow send_left_arrow
+
+      def send_escape(browser)
+        browser.send_keys :escape
+        debug_to_log('Sent Esc key')
       end
+      alias press_escape send_escape
 
     end
   end