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

data/lib/awetestlib/regression/date_and_time.rb

@@ -0,0 +1,280 @@
+module Awetestlib
+
+  module Regression
+
+    module DateAndTime
+
+      def get_date_names(date = Date.today, language = 'English')
+        this_month = date.month
+        next_month = this_month == 12 ? 1 : this_month + 1
+        prev_month = this_month == 1 ? 12 : this_month - 1
+
+        month_arr = get_months(language)
+
+        this_month_name = month_arr[this_month]
+        next_month_name = month_arr[next_month]
+        prev_month_name = month_arr[prev_month]
+
+        arr = [date.year.to_s, date.day.to_s, this_month_name, next_month_name, prev_month_name]
+        debug_to_log("#{__method__} #{nice_array(arr)}")
+        arr
+      end
+
+      def get_days(language = 'English', abbrev = 0)
+        case language
+          when /english/i
+            full_arr = Date::DAYNAMES
+
+          # TODO: commented words with diacriticals until we can fix encoding confusion with mac/safari
+          when /french/i, /francais/i #, /fran�ais/i
+            full_arr = ["Lundi", "Mardi", "Mercredi", "Jeudi", "Vendredi", "Samedi", "Dimanche"]
+
+          else
+            failed_to_log(with_caller("Language #{language} not yet supported."))
+            full_arr = nil
+        end
+
+        if abbrev > 0
+          rtrn_arr = []
+          full_arr.each do |m|
+            rtrn_arr << m.slice(0, abbrev)
+          end
+        else
+          rtrn_arr = full_arr
+        end
+
+        rtrn_arr
+      rescue
+        failed_to_log(unable_to)
+      end
+
+      def next_day(yr, mo, dy, diff = 1)
+        tdy = DateTime.new(yr.to_i, mo.to_i, dy.to_i, 0, 0, 0)
+        tdy.advance(:days => diff).strftime("%Y-%m-%d")
+      end
+
+      def next_month(this)
+        unless this.is_a?(Fixnum)
+          this = this.to_i
+        end
+        nxt = this == 12 ? 1 : this + 1
+        nxt.to_s.rjust(2, '0')
+      end
+
+      def next_month_name(this, language = 'English')
+        unless this.is_a?(Fixnum)
+          this = get_months(language).index(this)
+        end
+        nxt = this == 12 ? 1 : this + 1
+        get_months(language)[nxt]
+      end
+
+      def prev_day(yr, mo, dy, diff = -1)
+        diff = diff > 0 ? -diff : diff
+        tdy  = DateTime.new(yr.to_i, mo.to_i, dy.to_i, 0, 0, 0)
+        tdy.advance(:days => diff).strftime("%Y-%m-%d")
+      end
+
+      def prev_month(this)
+        prev = this.to_i == 1 ? 12 : this.to_i - 1
+        prev.to_s.rjust(2, '0')
+      end
+
+      def prev_month_name(this, language = 'English')
+        unless this.is_a?(Fixnum)
+          this = get_months(language).index(this)
+        end
+        prev = this == 1 ? 12 : this - 1
+        get_months(language)[prev]
+      end
+
+      def get_mdyy(t = Time.now)
+        "#{t.month}/#{t.day}/#{t.year}"
+      end
+
+      def get_month_name(this, language = 'English')
+        unless this.is_a?(Fixnum)
+          this = get_months(language).index(this)
+        end
+        get_months(language)[this]
+      end
+
+      def get_month_names(date = Date.today)
+        this_month = date.month
+        if this_month == 12
+          next_month = 1
+        else
+          next_month = this_month + 1
+        end
+        if this_month == 1
+          prev_month = 12
+        else
+          prev_month = this_month - 1
+        end
+
+        month_arr = Date::MONTHNAMES
+
+        this_month_name = month_arr[this_month]
+        next_month_name = month_arr[next_month]
+        prev_month_name = month_arr[prev_month]
+
+        arr = [date.year, date.day, this_month_name, next_month_name, prev_month_name]
+        debug_to_log("#{__method__} #{nice_array(arr)}")
+        arr
+
+      end
+
+      def get_months(language = 'English', abbrev = 0)
+        case language
+          when /english/i
+            full_arr = Date::MONTHNAMES
+
+          # TODO: commented words with diacriticals until we can fix encoding confusion with mac/safari
+          when /french/i, /francais/i #, /fran�ais/i
+            full_arr = [nil, 'janvier', 'fevrier', 'mars', 'avril', 'mai', 'juin',
+                        'juillet', 'aout', 'septembre', 'octobre', 'novembre', 'decembre']
+          # full_arr = [nil, 'janvier', 'f�vrier', 'mars', 'avril', 'mai', 'juin',
+          #             'juillet', 'ao�t', 'septembre', 'octobre', 'novembre', 'd�cembre']
+          else
+            failed_to_log(with_caller("Language #{language} not yet supported."))
+            full_arr = nil
+        end
+
+        if abbrev > 0
+          rtrn_arr = []
+          full_arr.each do |m|
+            if m
+              rtrn_arr << m.slice(0, abbrev)
+            else
+              rtrn_arr << nil
+            end
+          end
+        else
+          rtrn_arr = full_arr
+        end
+
+        rtrn_arr
+      rescue
+        failed_to_log(unable_to(language))
+      end
+
+      def translate_month_name(name, to, from = 'English')
+        get_months(from).index(name)
+        get_months(to)[get_months(from).index(name)]
+      end
+
+      def get_timestamp(format = 'long', offset = nil, offset_unit = :years)
+        t = DateTime.now
+        if offset
+          t = t.advance(offset_unit => offset)
+        end
+        case format
+          when 'dateonly'
+            t.strftime("%m/%d/%Y")
+          when 'condensed'
+            t.strftime("%Y%m%d%H%M")
+          when 'condensed_seconds'
+            t.strftime("%Y%m%d%H%M%S")
+          when 'long'
+            t.strftime("%m/%d/%Y %I:%M %p")
+          when 'mdyy'
+            get_mdyy(t)
+          when 'm/d/y'
+            get_mdyy(t)
+          else
+            Time.now.strftime("%m/%d/%Y %H:%M:%S")
+        end
+      end
+
+      def tic(new = false)
+        now = Time.now.utc
+        if new
+          @tic_tic = now
+        else
+          debug_to_log(with_caller("#{now.to_f - @tic_tic.to_f}", "#{get_call_array(2)[1]}"))
+          @tic_tic = now
+        end
+      end
+
+      def tic_m(msg = '')
+        now = Time.now.utc
+        debug_to_log(with_caller("#{now.to_f - @tic_tic.to_f}", "#{get_call_array(2)[1]}", msg))
+        @tic_tic = now
+      end
+
+      def time_it(container, desc, timeout = 3, &block)
+        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/
+            debug_to_log("#{desc} '#{$!}'")
+            return Time.now.to_f - start
+          elsif not rescue_me(e, __method__, "#{block.to_s}", "#{container.class}")
+            raise e
+          end
+        end
+        duration = Time.now.to_f - start
+        debug_to_report(with_caller(desc, duration.to_s))
+        duration
+      rescue
+        failed_to_log(unable_to(desc))
+      end
+
+      def sec2hms(s)
+        Time.at(s.to_i).gmtime.strftime('%H:%M:%S')
+      end
+
+      def pad_date(dt)
+        if dt and dt.length > 0
+          a, d1, b, d2, c = dt.split(/([\/\.-])/)
+          a = a.rjust(2, '0') unless a and a.length > 1
+          b = b.rjust(2, '0') unless b and b.length > 1
+          c = c.rjust(2, '0') unless c and c.length > 1
+          a + d1 + b + d2 + c
+        else
+          ''
+        end
+      end
+
+      def convert_y_m_d_to_ymd(yrs, mos, dys, fmt_out = '%Y-%m-%d', alt_fmt = '%Y-%m')
+        dys = [dys] unless dys.is_a?(Array)
+        mos = [mos] unless mos.is_a?(Array)
+        yrs = [yrs] unless yrs.is_a?(Array)
+        arr = []
+        if dys.size > 0
+          dys.each do |dy|
+            mo = mos[dys.index(dy)] ? mos[dys.index(dy)] : mos[0]
+            yr = yrs[dys.index(dy)] ? yrs[dys.index(dy)] : yrs[0]
+            arr << DateTime::parse("#{dy}/#{mo}/#{yr}").strftime(fmt_out).sub(/^0/, '')
+          end
+        else
+          mos.each do |mo|
+            yr = yrs[mos.index(mo)] ? yrs[mos.index(mo)] : yrs[0]
+            arr << DateTime::parse("1/#{mo}/#{yr}").strftime(alt_fmt).sub(/^0/, '')
+          end
+        end
+        arr
+      rescue
+        failed_to_log(unable_to("y:#{yrs}, m:#{mos}, d:#{dys}"))
+      end
+
+      def parse_mdy_to_datetime(mdy)
+        if mdy and mdy.length > 0
+          m, d1, d, d2, y = mdy.split(/([\/\.-])/)
+          y = "20#{y}" unless y.length == 4
+          ymd = "#{y}#{d1}#{m}#{d1}#{d}"
+          DateTime.parse(ymd)
+        end
+      rescue
+        failed_to_log(unable_to)
+      end
+
+      def diff_datetimes_in_days(beg_dt, end_dt)
+        (end_dt - beg_dt).to_i
+      end
+
+
+    end
+  end
+end

data/lib/awetestlib/regression/drag_and_drop.rb

@@ -7,6 +7,30 @@ module Awetestlib
     #   Rdoc is work in progress
     module DragAndDrop
 
+      def viewport_size(browser)
+        if @targetBrowser.abbrev == 'IE' and  get_browser_version(browser).to_i < 9
+          insert_viewport_div(browser)
+        else
+          x = browser.execute_script("return window.innerWidth")
+          y = browser.execute_script("return window.innerHeight")
+          [x, y]
+        end
+      end
+
+      def insert_viewport_div(browser)
+        browser.execute_script(
+            'var test = document.createElement( "div" );' +
+                'test.style.cssText = "position: fixed;top: 0;left: 0;bottom: 0;right: 0;"; ' +
+                'test.id = "awetest-temp-viewport"; ' +
+                'document.documentElement.insertBefore( test, document.documentElement.firstChild ); '
+        )
+        viewport = browser.div(:id, 'awetest-temp-viewport')
+        x = browser.execute_script("return arguments[0].offsetWidth", viewport)
+        y = browser.execute_script("return arguments[0].offsetHeight", viewport)
+        browser.execute_script("document.documentElement.removeChild( arguments[0] )", viewport)
+        [x, y]
+      end
+
       # Verify that specified *inner_element* is fully enclosed by *outer_element*.
       # @param [Watir::Element] inner_element A reference to a DOM element
       # @param [Watir::Element] outer_element A reference to a DOM element

data/lib/awetestlib/regression/find.rb

@@ -19,47 +19,12 @@ module Awetestlib
       # @param [String, Regexp] what A string or a regular expression to be found in the *how* attribute that uniquely identifies the element.
       # @param [String, Regexp] value A string or a regular expression to be found in the *:value* attribute that uniquely identifies the element.
       # @param [String] desc Contains a message or description intended to appear in the log and/or report output
-      def get_element(browser, element, how, what, value = nil, desc = '')
-        msg    = build_message("Return #{element} with :#{how}=#{what}", value, desc)
-        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)
-          else
-            target = browser.element(how, what)
-        end
-        if target.exists?
+      def get_element(container, element, how, what, value = nil, desc = '', options = {})
+        value, desc, options = capture_value_desc(value, desc, options) # for backwards compatibility
+        msg    = build_message("Return #{element} with :#{how}=>'#{what}'", value, desc)
+        code   = build_webdriver_fetch(element, how, what, options)
+        target = eval(code)
+        if target and target.exists?
           passed_to_log(msg)
           target
         else
@@ -67,12 +32,13 @@ module Awetestlib
           nil
         end
       rescue => e
-        unless rescue_me(e, __method__, rescue_me_command(target, how, what), "#{browser.class}", target)
+        unless rescue_me(e, __method__, rescue_me_command(target, how, what), "#{container.class}", target)
           raise e
         end
       end
 
       def get_attribute_value(browser, element, how, what, attribute, desc = '')
+        #TODO: eliminate case statement by using eval with build_webdriver_fetch
         msg = build_message("Value of #{attribute} in #{element} #{how}=>#{what}.", desc)
         case element
           when :link
@@ -80,7 +46,7 @@ module Awetestlib
           when :button
             value = browser.button(how => what).attribute_value attribute
           else
-            if browser.element(how => what).responds_to('attribute_value')
+            if browser.element(how => what).responds_to?('attribute_value')
               value = browser.element(how => what).attribute_value attribute
             end
         end
@@ -89,6 +55,67 @@ module Awetestlib
         failed_to_log(" Unable to #{msg}: '#{$!}'")
       end
 
+      def get_directory(path)
+        if File.directory?(path)
+          debug_to_log("Directory already exists, '#{path}'.")
+        else
+          Dir::mkdir(path)
+          debug_to_log("Directory was created, '#{path}'.")
+        end
+        path
+      end
+
+      def get_ancestor(descendant, element, how, what, desc = '')
+        found = false
+        how = 'class_name' if how.to_s == 'class'
+        tag = element.to_s.downcase
+        debug_to_log("target: #{descendant.tag_name} :id=>#{descendant.id}")
+        debug_to_log("goal:   #{element} :#{how}=>#{what}   #{desc}")
+        ancestor = target.parent
+        debug_to_log("#{ancestor.tag_name}: :class=>'#{ancestor.class_name}'")
+        code = "ancestor.#{how}"
+        what.is_a?(Regexp) ? code << " =~ /#{what.source}/" : code << " == '#{what}'"
+        debug_to_log("#{code}")
+        until found do
+          debug_to_log("#{ancestor.tag_name}: :class=>'#{ancestor.class_name}'")
+          if ancestor.tag_name == tag
+            if eval(code)
+              found = true
+              break
+            end
+          end
+          break unless ancestor
+          ancestor = ancestor.parent
+        end
+        ancestor
+      rescue
+        failed_to_log(unable_to)
+      end
+
+      def capture_value_desc(value, desc, options = nil)
+        opt = options.dup if options
+        unless opt.kind_of?(Hash)
+          opt = Hash.new
+        end
+        if value
+          vlu = value.dup
+          if opt[:value]
+            vlu = nil
+          else
+            opt[:value] = vlu
+          end
+        end
+        if desc
+          dsc = desc.dup
+          unless opt[:desc]
+            opt[:desc] = dsc
+          end
+        end
+        [vlu, dsc, opt]
+      rescue
+        failed_to_log(unable_to)
+      end
+
       # Return an array containing the options available for selection in a select_list identifified by
       # its attribute *how*, and the contents of that attribute *what*.
       # @param [Watir::Browser] browser A reference to the browser window or container element to be tested.