awetestlib 0.1.2 → 0.1.5

data/lib/regression/legacy.rb

@@ -1,40 +0,0 @@
-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

data/lib/regression/page_data.rb

@@ -1,185 +0,0 @@
-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

data/lib/regression/runner.rb

@@ -1,278 +0,0 @@
-require 'regression/browser'
-require 'regression/find'
-require 'regression/user_input'
-require 'regression/waits'
-require 'regression/tables'
-require 'regression/page_data'
-require 'regression/drag_and_drop'
-require 'regression/utilities'
-require 'regression/logging'
-require 'regression/validations'
-
-#require 'rbconfig'
-require 'ostruct'
-require 'active_support'
-require 'active_support/inflector'
-
-module Awetestlib
-
-  class Runner
-
-  # order matters here
-    include Logging
-    include Browser
-    include Find
-    include UserInput
-    include Waits
-    include Tables
-    include PageData
-    include DragAndDrop
-    include Utilities
-    include 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'
-
-    puts ENV["OS"]
-
-    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
-      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 version.to_f >= 9.0
-            require 'watir-webdriver'
-          else
-            require 'watir/ie'
-            require 'watir'
-            require 'watir/process'
-            require 'watirloo'
-            require 'patches/watir'
-            Watir::IE.visible = true
-          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
-
-    end
-
-    def module_for(script_file)
-      File.read(script_file).match(/^module\s+(\w+)/)[1].constantize
-    end
-
-    def before_run
-      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
-      @myLog.close if @myLog
-    end
-
-  end
-end