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

data/lib/awetestlib/regression/legacy.rb

@@ -311,7 +311,7 @@ module Awetestlib
       # @param (see #click_button_by_id)
       # @return (see #click_button_by_id)
       def click_img_by_xpath_and_name(browser, what, desc = '')
-        click(browser, :image, :xpath, "//a[@id = '#{what}']", desc)
+        click(browser, :image, :xpath, "//a[@name = '#{what}']", desc)
       end
 
       alias click_img_by_xpath click_img_by_xpath_and_name

data/lib/awetestlib/regression/mobile.rb

@@ -0,0 +1,293 @@
+module Awetestlib
+
+  module Regression
+
+    module Mobile
+
+      def open_mobile_browser
+
+        mark_test_level(": #{self.device_type.titleize}")
+
+        if Dir.pwd =~ /shamisen/i
+          subdir = 'awetest_report'
+          sleep1  = 30
+          sleep2  = 90
+          server_url = "http://127.0.0.1:4723/wd/hub"
+          # server_url = 'http://0.0.0.0:4723/wd/hub'
+        else
+          subdir = 'log'
+          sleep1 = 10
+          sleep2 = 10
+          server_url = "http://127.0.0.1:4723/wd/hub"
+        end
+
+        debug_to_log(with_caller("$debug => #{$debug}, $DEBUG => #{$DEBUG}"))
+        log_level = $debug ? 'debug:debug' : 'debug:debug' #'warn:debug'
+        debug_to_log(with_caller("#{Dir.pwd.chomp}"))
+
+        log_file = File.join(Dir.pwd.chomp, subdir, "#{File.basename(__FILE__, '.rb')}_appium_lib_#{Time.now.strftime("%Y%m%d%H%M%S")}.log")
+        command  = "start \"appium server\" appium --log-timestamp --log-level #{log_level} -g #{log_file} &"
+        debug_to_log(command)
+        appium      = IO.popen(command, :err => :out)
+        @appium_pid = appium.pid
+        debug_to_log(with_caller("Appium PID: #{@appium_pid}"))
+
+        debug_to_log(with_caller("nodejs version: #{`node --version`.chomp}"))
+
+        sleep_for(sleep1)
+
+        client         = Selenium::WebDriver::Remote::Http::Default.new
+        client.timeout = 300
+        desired_caps   = set_mobile_capabilities(self.device_id, self.device_type, self.sdk, self.emulator, client, server_url)
+
+        debug_to_log(desired_caps.to_yaml)
+
+        debug_to_log(with_caller('Instantiating Appium Driver'))
+        Appium::Driver.new(desired_caps)
+        debug_to_log(with_caller('Starting Appium Driver'))
+        $driver.start_driver
+
+        sleep_for(sleep2)
+
+        debug_to_log(with_caller('Getting Watir Browser from driver...'))
+        browser = Watir::Browser.new($driver.driver)
+
+        debug_to_log(with_caller('Returning browser'))
+
+        browser
+      rescue
+        failed_to_log(unable_to)
+      end
+
+      def set_mobile_capabilities(device_id, device_type, sdk, emulator, http_client, server_url = "http://127.0.0.1:4723/wd/hub")
+        mark_test_level
+
+        case device_type
+
+          when /android device/i
+            desired_caps = {
+                :caps       => {
+                    :newCommandTimeout         => 600,
+                    :androidDeviceReadyTimeout => 420,
+                    :avdLaunchTimeout          => 240000,
+                    :avdReadyTimeout           => 240000,
+                    :deviceName                => "Android Device",
+                    :automationName            => "Appium",
+                    :platformName              => "Android",
+                    :browserName               => "Chrome",
+                    :platformVersion           => sdk,
+                    'app'                      => "chrome",
+                    # 'appPackage'                => "com.android.chrome",
+                    :udid                      => device_id,
+                    :http_client               => http_client,
+                    :chromeOptions             => { "args" => ['--ignore-certificate-errors', '--verbose'] } #ignore-certificate-errors=true homepage=about:blank test_type=true' }
+                },
+                :appium_lib => {
+                    :server_url => server_url
+                }
+            }
+
+          when /android emulator/i
+
+            # NOTE: avd cannot start from snapshot?.
+
+            desired_caps = {
+                :caps       => {
+                    :newCommandTimeout         => 1200,
+                    :androidDeviceReadyTimeout => 420,
+                    :avdLaunchTimeout          => 240000,
+                    :avdReadyTimeout           => 240000,
+                    :debug                     => true,
+                    :deviceName                => "Android Emulator",
+                    :platformName              => "Android",
+                    :avd                       => emulator,
+                    :browserName               => "Browser",
+                    :avdArgs                   => '-no-audio -http-proxy 151.151.15.250:8080 -dns-server 10.27.206.11:55,10.27.206.101:55,10.91.218.197:55',
+                    :http_client               => http_client,
+                    :chromeOptions             => { 'args' => ['--ignore-certificate-errors', '--verbose'] }
+                },
+                :appium_lib => {
+                    :server_url => server_url
+                }
+            }
+
+          when /ios device/i
+            desired_caps = {
+                'platformVersion' => sdk,
+                'deviceName'      => "My_device",
+                'platformName'    => "iOS",
+                'browserName'     => 'Safari',
+                'udid'            => device_id }
+
+          when /ios simulator/i
+            desired_caps = {
+                'deviceName'      => device_type,
+                'platformVersion' => sdk,
+                'browserName'     => 'Safari',
+                'platformName'    => "iOS" }
+          else
+            raise "Unrecognized mobile device type: '#{device_type}'"
+        end
+
+        debug_to_log(with_caller("\n#{desired_caps.to_yaml}"))
+
+        desired_caps
+      rescue
+        failed_to_log(unable_to)
+      end
+
+      def parse_environment_node_for_mobile
+
+        if self.environment_nodename =~ /;/
+          entries                            = {}
+          self.environment['input_nodename'] = self.environment_nodename
+          unless self.environment_nodename =~ /^W:/
+            self.environment_nodename = "W:#{self.environment_nodename}"
+          end
+          parms = self.environment_nodename.split(';')
+          parms.each do |p|
+            key, vlu     = p.split(':')
+            entries[key] = vlu
+          end
+
+          entries.each do |key, vlu|
+            case key
+              when 'W'
+                self.environment_nodename           = vlu
+                self.options[:environment_nodename] = vlu
+                self.environment['nodename']        = vlu
+              when 'I'
+                self.device_id           = vlu
+                self.options[:device_id] = vlu
+              when 'K'
+                self.sdk           = vlu
+                self.options[:sdk] = vlu
+              when 'T'
+                self.device_type           = vlu
+                self.options[:device_type] = vlu
+              when 'E'
+                self.emulator           = vlu
+                self.options[:emulator] = vlu
+            end
+          end
+        end
+      rescue
+        failed_to_log(unable_to)
+      end
+
+      def clean_up_android_temp
+
+        debug_to_log 'Here we will clean up emulator TMP files...'
+        user              = Etc::getlogin
+        # debug_to_log user
+        android_temp_path = 'C:\\Users\\'+user+'\\AppData\\Local\\Temp\\AndroidEmulator'
+        debug_to_log android_temp_path
+        if Dir.exists?(android_temp_path)
+          dir = Dir.new(android_temp_path)
+          dir.each do |file|
+            debug_to_log file if file =~ /^TMP.+\.tmp/
+          end
+          tmp_ptrn = '\\TMP*.tmp'
+          dir_cmd  = "dir #{android_temp_path}#{tmp_ptrn} 2>&1"
+          del_cmd  = "del #{android_temp_path}#{tmp_ptrn} 2>&1"
+          debug_to_log "#{__LINE__}: #{dir_cmd}"
+          dir_out = `#{dir_cmd}`
+          unless dir_out =~ /file not found/i
+            debug_to_log "#{__LINE__}: #{del_cmd}"
+            debug_to_log `#{del_cmd}`.chomp
+            if `#{dir_cmd}` =~ /file not found/i
+              debug_to_log 'Emulator TMP files deleted successfully'
+            end
+          end
+        else
+          debug_to_log("#{android_temp_path} not found")
+        end
+
+      rescue
+        failed_to_log(unable_to)
+      end
+
+      def end_android_processes
+
+        processes = ['node.exe', 'emulator-arm.exe', 'emulator-x86.exe', 'adb.exe', 'chromedriver.exe', 'cmd.exe']
+        tasks     = get_process_list
+        targets   = []
+
+        if USING_OSX
+          kill_cmd = 'kill -9 @@@@@'
+        else
+          kill_cmd = 'taskkill /f /pid @@@@@'
+        end
+
+        processes.each do |image_name|
+          if image_name == 'cmd.exe'
+            hit = tasks.detect { |t| t[:window_title] =~ /^appium server/i }
+          else
+            hit = tasks.detect { |t| t[:image_name] =~ /^#{image_name}/i }
+          end
+
+          if hit and hit.length > 0
+            targets << hit
+          end
+        end
+
+        ['node.exe', 'emulator', 'cmd.exe', 'adb.exe', 'chromedriver'].each do |process|
+          hit = targets.detect { |t| t[:image_name] =~ /^#{process}/i }
+          if hit and hit.length > 0
+            pid   = hit[:pid]
+            name  = hit[:image_name]
+            title = hit[:window_title]
+            cmd   = kill_cmd.sub('@@@@@', pid)
+            debug_to_log("[#{cmd}] #{name} #{title}")
+            kill_io = IO.popen(cmd, :err => :out)
+            debug_to_log(kill_io.read.chomp)
+            kill_io.close
+          end
+
+        end
+      rescue
+        failed_to_log(unable_to)
+      end
+
+      def get_process_list
+
+        if USING_OSX
+          cmd = "ps axo comm,pid,sess,fname"
+        else
+          cmd = 'tasklist /v -fo csv 2>&1'
+        end
+
+        debug_to_log(cmd)
+        raw  = `#{cmd}`
+        list = raw.force_encoding(Encoding::UTF_8)
+        # debug_to_log(list)
+        if list =~ /No tasks are running which match the specified criteria/i
+          tasks = nil
+        else
+          begin
+            csv = CSV.new(list, :headers => true, :header_converters => :symbol)
+              # debug_to_log(with_caller(__LINE__, "\n", "#{csv}"))
+          rescue => e
+            raise e
+          end
+          begin
+            arr = csv.to_a
+              # debug_to_log(with_caller(__LINE__, "\n", "#{arr}"))
+          rescue => e
+            raise e
+          end
+          begin
+            tasks = arr.map { |row| row.to_hash }
+              # debug_to_log(tasks)
+          rescue => e
+            raise e
+          end
+        end
+        tasks
+      rescue
+        failed_to_log(unable_to)
+      end
+
+    end
+  end
+end

data/lib/awetestlib/regression/reporting.rb

@@ -0,0 +1,298 @@
+module Awetestlib
+
+  module Regression
+
+    module Reporting
+
+      def get_caller_line
+        last_caller = get_call_list[0]
+        line        = last_caller.split(':', 3)[1]
+        line
+      end
+
+      def get_call_list(depth = 9, dbg = false)
+        my_list   = []
+        call_list = Kernel.caller
+        debug_to_log(with_caller(call_list)) if dbg
+        call_list.each_index do |x|
+          my_caller = call_list[x].to_s
+          my_caller =~ /([\(\)\w_\_\-\.]+\:\d+\:?.*?)$/
+          my_list << "[#{$1.gsub(/eval/, @myName)}] "
+          break if x > depth or my_caller =~ /:in .run.$/
+        end
+        my_list
+      rescue
+        failed_to_log(unable_to)
+      end
+
+      alias get_callers get_call_list
+
+      def get_call_list_new(depth = 15, dbg = $debug)
+        a_list    = ['[unknown]']
+        proj_name = File.basename(@library) if @library
+        call_list = Kernel.caller
+        log_message(DEBUG, with_caller(call_list)) if dbg
+        call_list.each_index do |x|
+          a_caller = call_list[x].to_s
+          a_caller =~ /([\(\)\w_\_\-\.]+\:\d+\:?.*?)$/
+          caller = $1
+          if caller =~ /#{@myName}/
+            a_list << "#{caller.gsub(/\(eval\)/, "(#{@myName})")}"
+          elsif proj_name and caller =~ /#{proj_name}/
+            a_list << "#{caller.gsub(/\(eval\)/, "(#{proj_name})")}" if proj_name
+          elsif @library2 and caller =~ /#{@library2}/
+            a_list << "#{caller.gsub(/\(eval\)/, "(#{@library2})")}" if @library2
+          else
+            a_list << "#{caller}"
+          end
+          next if a_caller =~ /:in .run.$/ and not a_caller.include?(@myName)
+          break if x > depth
+        end
+        a_list
+      rescue
+        failed_to_log(unable_to)
+      end
+
+      def get_debug_list(dbg = false, no_trace = false, last_only = false)
+        calls = get_call_array(10)
+        debug_to_log(with_caller("*** #{__LINE__}\n#{calls.to_yaml}\n***")) if dbg
+        arr = []
+        calls.each_index do |ix|
+          if ix > 1 # skip this method and the logging method
+            if filter_call(calls[ix])
+              arr << calls[ix]
+            end
+          end
+        end
+        debug_to_log(with_caller("*** #{__LINE__}\n#{arr.to_yaml}\n***")) if dbg
+        if arr.length > 0
+          list = ''
+          arr.reverse.each do |l|
+            if last_only
+              list = l
+              break
+            else
+              list << "=>#{l}"
+            end
+          end
+          if no_trace
+            "#{list}"
+          else
+            " [TRACE:#{list}]"
+          end
+        else
+          ''
+        end
+      rescue
+        failed_to_log(unable_to)
+      end
+
+      def filter_call(call)
+        modl = call.match(/^(browser|logging|find|runner|tables|user_input|utilities|validations|waits|page_data|legacy|drag_and_drop|awetest)/) || ''
+        meth = call.match(/in .(run|each)/) || ''
+        true unless "#{modl}#{meth}".length > 0
+      end
+
+      def get_test_level(meth = nil)
+        arr       = []
+        each_line = 0
+        call_list = Kernel.caller
+        #debug_to_log("#{call_list.to_yaml}")
+        call_list.each_index do |x|
+          myCaller = call_list[x].to_s
+          myCaller =~ /([\(\)\w_\_\-\.]+\:\d+\:?.*?)$/
+          string = $1
+          unless string =~ /logging\.rb|mark_test_level|mark_test_level|debug_to_report|debug_toreport/
+            if string.length > 0
+              if string =~ /each|each_key/
+                each_line = string.match(/\:(\d+)\:/)[1]
+              elsif string.match(/\:(\d+)\:/)[1] == each_line
+                next
+              else
+                arr << string.gsub(/eval/, @myName)
+              end
+            end
+          end
+          break if meth and string.match(/#{meth}/)
+          break if myCaller =~ /:in .run.$|runner\.rb/
+        end
+        #debug_to_log("#{arr.length} #{nice_array(arr)}")
+        [arr.length, arr]
+      end
+
+      # TODO: need to sanitize html for html report
+      def html_to_log(element)
+        debug_to_log("#{element}\n #{element.html}")
+      end
+
+      # @private
+      def parse_caller(caller)
+        call_script, call_line, call_meth = caller.split(':')
+        call_script.gsub!(/\.rb/, '')
+        call_script = call_script.camelize
+        call_meth =~ /in .([\w\d_ ]+)./
+        call_meth = $1
+        if call_meth.match(/((rescue|block|eval)\s*in\s*)/)
+          delete = $1
+          append = $2
+          call_meth.sub!(delete, '')
+          call_meth << " (#{append})"
+        end
+        [call_script, call_line, call_meth]
+      rescue
+        failed_to_log(unable_to)
+      end
+
+      def initialize_reference_regexp
+        unless @reference_regexp.is_a?(Regexp)
+          @reference_template = '(\*\*\*\s+@@@@\s+\*\*\*)'
+          @reference_pattern  = @reference_template.sub('@@@@', '([\w\d_\s,-:;\?]+)')
+          @reference_regexp   = Regexp.new(@reference_pattern)
+        end
+      end
+
+      # @private
+      def choose_refs(arr, *indices)
+        refs = ''
+        indices.each do |idx|
+          refs << "*** #{arr[idx]} *** "
+        end
+        refs
+      rescue
+        failed_to_log(unable_to)
+      end
+
+      # @private
+      def format_refs(list)
+        refs = ''
+        if list
+          list.split(/,\s*/).each do |ref|
+            refs << format_reference(ref)
+          end
+        end
+        refs
+      end
+
+      # @private
+      def format_reference(ref)
+        "*** #{ref} *** "
+      end
+
+      # @private
+      def unformat_refs(list)
+        refs = ''
+        if list.is_a?(Array)
+          list.each { |ref| refs << unformat_reference(ref) + ' ' }
+        else
+          list.split(/,\s*/).each do |ref|
+            refs << unformat_reference(ref) + ' '
+          end
+        end
+        refs
+      rescue
+        failed_to_log(unable_to)
+      end
+
+      # @private
+      def unformat_ref_arr(arr)
+        refs = []
+        arr.each { |ref| refs << unformat_reference(ref) }
+        refs
+      rescue
+        failed_to_log(unable_to)
+      end
+
+      # @private
+      def unformat_reference(ref)
+        ref.gsub!('***', '').strip
+      rescue
+        failed_to_log(unable_to)
+      end
+
+      # @private
+      def collect_references(*strings)
+        refs = ''
+        strings.each do |strg|
+          refs << " #{format_refs(strg)}" if strg and strg.length > 0
+        end if strings
+        refs
+      end
+
+      # @private
+      def tally_error_references
+        tags_tested = 0
+        tags_hit    = 0
+        if @my_error_hits and @my_error_hits.length > 0
+          mark_test_level(">> Failed Defect or Test Case instances:")
+          tags_hit = @my_error_hits.length
+          @my_error_hits.keys.sort.each do |ref|
+            msg = "#{ref} (#{@my_error_hits[ref]})"
+            msg << " -- #{@refs_desc[ref]}" if @refs_desc
+            message_to_report(msg)
+          end
+        end
+        if @my_error_references and @my_error_references.length > 0
+          tags_tested = @my_error_references.length
+          if self.report_all_test_refs
+            mark_test_level(">> All tested Defect or Test Case instances:")
+            @my_error_references.keys.sort.each do |ref|
+              msg = "#{ref} (#{@my_error_references[ref]})"
+              msg << " -- #{@refs_desc[ref]}" if @refs_desc
+              message_to_report(msg)
+            end
+          end
+          message_to_report(">> Fails on tested Defect or Test Case references: #{tags_hit} of #{tags_tested}")
+        else
+          message_to_report(">> No Defect or Test Case references found.")
+        end
+      end
+
+      # @private
+      def parse_error_references(message, fail = false)
+        initialize_reference_regexp unless @reference_regexp
+        msg = message.dup
+        while msg.match(@reference_regexp)
+          capture_error_reference($2, fail)
+          msg.sub!($1, '')
+        end
+      rescue
+        failed_to_log(unable_to)
+      end
+
+      # @private
+      def capture_error_reference(ref, fail)
+        if fail
+          @my_error_hits = Hash.new unless @my_error_hits
+          if @my_error_hits[ref]
+            @my_error_hits[ref] += 1
+          else
+            @my_error_hits[ref] = 1
+          end
+          #debug_to_report("#{__method__}: error hits:\n#{@my_error_hits.to_yaml}")
+        end
+        @my_error_references = Hash.new unless @my_error_references
+        if @my_error_references[ref]
+          @my_error_references[ref] += 1
+        else
+          @my_error_references[ref] = 1
+        end
+      rescue
+        failed_to_log(unable_to)
+      end
+
+      def report_results(errors, msg)
+        call_script, call_line, call_meth = parse_caller(get_call_array[1])
+        msg                               = ">> SUMMARY: #{build_msg("#{call_meth.titleize}:", msg)}"
+        if errors > 0
+          mark_test_level("#{msg}  ::FAIL::")
+        else
+          mark_test_level("#{msg}  ::Pass::")
+          true
+        end
+      rescue
+        failed_to_log(unable_to)
+      end
+
+    end
+  end
+end