awetestlib 0.1.2 → 0.1.5

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
+

data/lib/awetestlib/regression/runner.rb

@@ -0,0 +1,307 @@
+require 'awetestlib/regression/browser'
+require 'awetestlib/regression/find'
+require 'awetestlib/regression/user_input'
+require 'awetestlib/regression/waits'
+require 'awetestlib/regression/tables'
+require 'awetestlib/regression/page_data'
+require 'awetestlib/regression/drag_and_drop'
+require 'awetestlib/regression/utilities'
+require 'awetestlib/logging'
+require 'awetestlib/regression/validations'
+require 'awetestlib/html_report'
+#require 'rbconfig'
+require 'ostruct'
+require 'active_support'
+require 'active_support/inflector'
+
+module Awetestlib
+  module Regression
+    class Runner < Awetestlib::Runner
+
+    # order matters here
+      include Awetestlib::Logging
+      include Awetestlib::Regression::Browser
+      include Awetestlib::Regression::Find
+      include Awetestlib::Regression::UserInput
+      include Awetestlib::Regression::Waits
+      include Awetestlib::Regression::Tables
+      include Awetestlib::Regression::PageData
+      include Awetestlib::Regression::DragAndDrop
+      include Awetestlib::Regression::Utilities
+      include Awetestlib::Regression::Validations
+
+      ::DEBUG   = 0
+      ::INFO    = 1
+      ::WARN    = 2
+      ::ERROR   = 3
+      ::FATAL   = 4
+      ::UNKNOWN = 5
+
+      ::TOP_LEVEL    = 7
+      ::SECOND_LEVEL = ::TOP_LEVEL - 1
+
+      ::WAIT = 20
+      ::PASS = '-PASS'
+      ::FAIL = '-FAIL'
+
+      attr_accessor :browser, :browser_abbrev, :version, :env,
+                    :library, :script_type, :script_file,
+                    :log_properties, :log_queue, :log_class,
+                    :notify_queue, :notify_class, :notify_id,
+                    :screencap_path, :xls_path, :script_path, :user_token, :root_path,
+                    :debug_on_fail,
+                    :environment, :environment_name, :environment_url, :environment_nodename,
+                    :cycle, :browser_sequence,
+                    :output_to_log, :log_path_subdir, :report_all_test_refs,
+                    :timeout
+
+      #def self.build(options)
+      #  #build_class = "Awetestlib::#{script_module_for options[:script_type]}::Runner".constantize
+      #  build_class = "Awetestlib::Runner".constantize
+      #  #options     = options.merge(:script_file => options[:script_file])
+      #  #if build_class.respond_to?(:runner_class)
+      #  #  build_class.runner_class(options)
+      #  #else
+      #    build_class.new(options)
+      #  #end
+      #end
+
+      # TODO: Encapsulate in some kind of config
+      ###################################
+      def setup_global_test_vars(options)
+        @my_failed_count = 0
+        @my_passed_count = 0
+        @my_error_references         = Hash.new
+        @my_error_hits     = Hash.new
+
+        @report_all_refs  = options[:report_all_test_refs]
+
+        if options[:environment]
+          @myAppEnv = OpenStruct.new(
+              :name     => options[:environment]['name'],
+              :url      => options[:environment]['url'],
+              :nodename => options[:environment]['nodename']
+          )
+          @runenv   = options[:environment]['nodename'] || options[:environment]['name']
+          @myURL    = options[:environment]['url']
+        else
+          @runenv = options[:environment_name]
+        end
+
+        @targetBrowser  = browser_to_use(options[:browser], options[:version])
+        @targetVersion  = @targetBrowser.version
+        @browserAbbrev  = @targetBrowser.abbrev
+        @myRoot         = options[:root_path]
+        @myName         = File.basename(options[:script_file]).sub(/\.rb$/, '')
+
+        if options[:output_to_log]
+          log_path = "#{@myRoot}/"
+          log_path << "#{options[:log_path_subdir]}/" if options[:log_path_subdir]
+          log_spec = File.join log_path, "#{@myName}_#{Time.now.strftime("%Y%m%d%H%M%S")}.log"
+          @myLog = init_logger(log_spec, @myName)
+          #@start_timestamp   = Time.now
+          #start_to_log(@start_timestamp)
+        end
+
+        if options[:xls_path]
+          @xls_path = options[:xls_path]
+        end
+
+        #TODO need to find way to calculate these on the fly
+        # window top border 30
+        # IE toolbars 86
+        @vertical_hack_ie   = 117
+        # FF toolbars 114
+        @vertical_hack_ff   = 144
+        # window left border 4
+        @horizontal_hack_ie = 5
+        @horizontal_hack_ff = 4
+        #
+        # @x_tolerance = 12
+        # @y_tolerance = 12
+        require_gems
+      end
+
+      #def self.runner_class(options)
+      #  script_file = options[:script_file]
+      #  load script_file # force a load
+      #
+      #  runner_module = self.module_for script_file
+      #  klass_name    = "#{runner_module.to_s}::Runner"
+      #
+      #  # Define a Runner class in the test script's module inheriting from AwetestLegacy::Runner
+      #  runner_module.module_eval do
+      #    eval <<-RUBY
+      #  class #{klass_name} < Awetestlib::Runner
+      #    def initialize(options)
+      #      #super(options)
+      #      setup_global_test_vars(options)
+      #    end
+      #  end
+      #    RUBY
+      #  end
+      #
+      #  runner = runner_module::Runner.new(options)
+      #
+      #  if options[:library]
+      #    lib_file = options[:library]
+      #    load lib_file
+      #    lib_module = self.module_for lib_file
+      #    runner.extend(lib_module)
+      #  end
+      #
+      #  # Add in the methods defined in the script's module
+      #  runner.extend(runner_module)
+      #  runner
+      #end
+
+      def initialize(options)
+
+        options.each_pair do |k, v|
+          self.send("#{k}=", v)
+        end
+        load script_file
+        setup_global_test_vars(options)
+
+        # load and extend with library module if it exists
+        if options[:library]
+          lib_file = options[:library]
+          load lib_file # force a fresh load
+          lib_module = module_for lib_file
+          self.extend(lib_module)
+        end
+
+        # load and extend with script
+        script_file = options[:script_file]
+        load script_file # force a fresh load
+        runner_module = module_for script_file
+        self.extend(runner_module)
+
+      end
+
+      def browser_to_use(browser, browser_version = nil)
+        platform = ''
+        platform = 'Windows' if !!((RUBY_PLATFORM =~ /(win|w)(32|64)$/) || (RUBY_PLATFORM =~ /mswin|mingw/))
+        platform = 'OSX' if RUBY_PLATFORM =~ /darwin/
+
+        browser_abbrev =
+            Awetestlib::BROWSER_ALTERNATES[platform][browser] ?
+                Awetestlib::BROWSER_ALTERNATES[platform][browser] : browser
+        if not browser_version
+          case browser_abbrev
+            when 'IE'
+              browser_version = 8
+            when 'FF'
+              browser_version = 11
+            when 'C', 'GC'
+              browser_version = 10
+            when 'S'
+              browser_version = 10
+          end
+        end
+        return OpenStruct.new(
+              :name => (Awetestlib::BROWSER_MAP[browser_abbrev]),
+              :abbrev => browser_abbrev,
+              :version => browser_version
+        )
+      end
+
+      def require_gems
+
+        case @targetBrowser.abbrev
+
+          when 'IE'
+            if $watir_script
+              require 'watir/ie'
+              require 'watir'
+              require 'watir/process'
+              require 'watirloo'
+              require 'patches/watir'
+              Watir::IE.visible = true
+            else
+              require 'watir-webdriver'
+            end
+          when 'FF'
+            if @targetBrowser.version.to_f < 4.0
+              require 'firewatir'
+              require 'patches/firewatir'
+            else
+              require 'watir-webdriver'
+            end
+
+          when 'S'
+            require 'safariwatir'
+
+          when 'C', 'GC'
+            require 'watir-webdriver'
+
+          # when 'CL'
+          #   require 'celerity'
+          #   require 'watir-webdriver'
+
+        end
+
+        if USING_WINDOWS
+          require 'watir/win32ole'
+          @ai = ::WIN32OLE.new('AutoItX3.Control')
+          require 'pry'
+        else
+          # TODO: Need alternative for Mac?
+          @ai = ''
+        end
+
+        if @xls_path
+          require 'roo'
+        end
+
+      end
+
+      def module_for(script_file)
+        File.read(script_file).match(/^module\s+(\w+)/)[1].constantize
+      end
+
+      def before_run
+        initiate_html_report
+        start_run
+      end
+
+      def start
+        before_run
+        run
+      rescue Exception => e
+        failed_to_log(e.to_s)
+      ensure
+        after_run
+      end
+
+      def after_run
+        finish_run
+        @report_class.finish_report(@html_report_file)
+        open_report_file
+        #finish_run
+        @myLog.close if @myLog
+      end
+
+      def initiate_html_report
+        @html_report_name = File.join(File.dirname(__FILE__), '..', '..', '..', 'tmp', @myName)
+        @html_report_dir = File.dirname(@html_report_name)
+        FileUtils.mkdir @html_report_dir unless File.directory? @html_report_dir
+        @report_class = Awetestlib::HtmlReport.new(@myName)
+        @html_report_file = @report_class.create_report(@html_report_name)
+      end
+
+      def open_report_file
+        full_report_file = File.expand_path(@html_report_file)
+        if USING_WINDOWS
+          system("explorer file:///#{full_report_file}")
+        elsif USING_OSX
+          system("open #{full_report_file}")
+        else
+          puts "Can find report in #{full_report_file}"
+        end
+
+      end
+
+    end
+  end
+end