scoutui 2.0.3.48.pre → 2.0.3.49.pre

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5f9db5fd1abf3789bd4478d67c278041fccc6a6a
-  data.tar.gz: b16acc15a0806e9fd3726a457542bf9982da05d3
+  metadata.gz: 56198d903e76686d5d7c19967087e96604dc0f2e
+  data.tar.gz: c597f3635b475beb5ae53ffc5c1cd726540b9b2b
 SHA512:
-  metadata.gz: d915b727bb94c32a8222456bf679fe602f471e2dd4a1c647a311b11d7180d89e834852a388ff0096c7a65d2307437531a6da99b340ea4df271d4b10b205fc4bb
-  data.tar.gz: 80c60d07fe1ddc11325486dc06da66e994e42ef67f00d27e3a3d73cdddd51a81ad0a68edea3a5a24a29c9b8cebe283e02ae4f7093f03d206c8114fe67522b5ee
+  metadata.gz: 240d65f90565942c321bef2a1988ea4b9cd49ae650960236d41b0a35eeffe2772f5ef456d31c3f7365d24c7e8445f532a3c7b7d73860f89b97ea074668858f2d
+  data.tar.gz: c19cc9bfef61ddb103ea035f12d324fb342297b48ae16e555bf67fe5c3cdff7e32b4fad8fddecfc3a7a2e8a1290cb101aeda03a10e1c27f257bad1f85d239035

data/examples/screenshot/fullshot.rb

@@ -0,0 +1,66 @@
+# needs the selenium-webdriver and mini_magick gems
+]
+require 'eyes_selenium'
+
+
+
+
+
+
+# Substitute these with the size of your web page
+page_width = 1024
+page_height = 800
+
+height_captured = 0
+y_tiles = 0
+
+wd = Selenium::WebDriver.for :firefox  # Connect to your Selenium Webdriver
+
+eyes=Applitools::Eyes.new()
+eyes.api_key = "Peter"
+eyes.force_fullpage_screenshot = true
+
+viewport = Selenium::WebDriver::Dimension.new(1024, 768)
+
+driver = eyes.open(
+    app_name: 'Full',
+    test_name: 'FullShot',
+    viewport_size: viewport,
+    driver: wd)
+
+
+asb = Applitools::Selenium::Browser.new(driver, eyes)
+
+driver.navigate.to "http://www.concursolutions.com"
+driver.manage.window.maximize
+shot=driver.get_screenshot
+puts __FILE__ + (__LINE__).to_s + " shot => #{shot.class}"
+
+if false
+while height_captured < page_height
+  width_captured = 0
+  x_tiles = 0
+
+  while width_captured < page_width
+    tile_file = "screenshot-#{y_tiles}-#{x_tiles}.png"
+
+    driver.execute_script("window.scrollTo(#{width_captured}px, #{height_captured});")
+
+    driver.save_screenshot tile_file
+
+    screenshot = MiniMagick::Image.new tile_file
+    width_captured += screenshot.width
+    x_tiles += 1
+  end
+
+  height_captured += screenshot.height
+  y_tiles += 1
+end
+
+# Use imagemagick's montage command to stitch the screenshot tiles together
+`montage screenshot-[0-#(y_tiles}]-[0-#{x_tiles}].png -tile #{x_tiles}x#{y_tiles} -geometry #{screenshot.width}x#{screenshot.height}+0+0 screenshot.png`
+
+
+end
+
+driver.quit

data/lib/scoutui/base/assertions.rb

@@ -25,19 +25,19 @@ module Scoutui::Base
 
     def isValidAssertType(_a)
 
-      puts __FILE__ + (__LINE__).to_s + " isValidAssertionType(#{_a})"
+      Scoutui::Logger::LogMgr.instance.asserts.debug __FILE__ + (__LINE__).to_s + " isValidAssertionType(#{_a})"
       @assertionTypes.each do |e|
         _p=e[:pattern]
 
-        puts __FILE__ + (__LINE__).to_s + " == verify #{_a} matches #{_p} =="
+        Scoutui::Logger::LogMgr.instance.asserts.debug __FILE__ + (__LINE__).to_s + " == verify #{_a} matches #{_p} =="
 
         if _a.match(/#{_p}/)
-          puts __FILE__ + (__LINE__).to_s + "  matched : #{e}"
+          Scoutui::Logger::LogMgr.instance.asserts.debug __FILE__ + (__LINE__).to_s + "  matched : #{e}"
           return e
         end
       end
 
-      puts __FILE__ + (__LINE__).to_s + " => unknown command : #{_a}"
+      Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " => unknown command : #{_a}"
       return nil
     end
 
@@ -67,7 +67,7 @@ module Scoutui::Base
         if _fMatch
           f=c[2].strip
 
-          puts __FILE__ + (__LINE__).to_s + " arg: #{f}"
+          Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " arg: #{f}"
 
           rc = { 'cmd' => cmd,
                  'frame'    =>  _fMatch[1].strip,
@@ -102,10 +102,10 @@ module Scoutui::Base
     #
     # { 'locator => <locator> '}
     def _parseFrameLocator(_a)
-      puts __FILE__ + (__LINE__).to_s + " _parseFrameLocator(#{_a})"
+      Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " _parseFrameLocator(#{_a})"
       _pattern='(frame\(.*\)[\.frame\(.*\)]*)\s*,\s*(.*)\s*$'
       _fMatch = _a.match(/#{_pattern}/)
-      puts __FILE__ + (__LINE__).to_s + " === _fMatch : #{_fMatch}"
+      Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " === _fMatch : #{_fMatch}"
       rc=nil
       if _fMatch
         rc = {
@@ -117,7 +117,7 @@ module Scoutui::Base
         }
       end
 
-      puts __FILE__ + (__LINE__).to_s + " _parseFrameLocator(#{_a}) => #{rc}"
+      Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " _parseFrameLocator(#{_a}) => #{rc}"
       rc
     end
 
@@ -143,7 +143,7 @@ module Scoutui::Base
         if _fMatch
           f=c[2].strip
 
-          puts __FILE__ + (__LINE__).to_s + " arg: #{f}"
+          Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " arg: #{f}"
 
           rc = { 'cmd' => cmd,
                  'frame'    =>  _fMatch[1].strip,
@@ -191,7 +191,7 @@ module Scoutui::Base
     def isVisibleFrameCmd?(_a)
       rc=nil
 
-      puts __FILE__ + (__LINE__).to_s + " [isVisibleFrameCmd]: #{_a}"
+      Scoutui::Logger::LogMgr.instance.asserts.debug __FILE__ + (__LINE__).to_s + " [isVisibleFrameCmd]: #{_a}"
 
       begin
         if isVisibleCmd?(_a)
@@ -200,19 +200,19 @@ module Scoutui::Base
 
           f=_a.match(/^\s*[!]*visible\((.*)\)\s*$/)[1].strip
 
-          puts __FILE__ + (__LINE__).to_s + " arg: #{f}"
+          Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " arg: #{f}"
           rc = { 'frame'    =>  f.match(/#{_pattern}/)[1].strip,
                  'locator'  =>  f.match(/#{_pattern}/)[2].strip }
 
         else
-          puts "=> NOT vsibleCmd"
+          Scoutui::Logger::LogMgr.instance.asserts.debug "=> NOT vsibleCmd"
         end
 
       rescue => ex
         ;
       end
 
-      puts __FILE__ + (__LINE__).to_s + " isVisibleFrameCmd?(#{_a}) : #{rc}"
+      Scoutui::Logger::LogMgr.instance.asserts.debug __FILE__ + (__LINE__).to_s + " isVisibleFrameCmd?(#{_a}) : #{rc}"
       rc
     end
 
@@ -255,7 +255,7 @@ module Scoutui::Base
 
         obj = Scoutui::Base::QBrowser.getObject(my_driver, xpath, Scoutui::Commands::Utils.instance.getTimeout)
 
-        puts __FILE__ + (__LINE__).to_s + " #{condition} : #{obj}"
+        Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " #{condition} : #{obj}"
 
         begin
 
@@ -281,7 +281,7 @@ module Scoutui::Base
         rescue => ex
           rc=false
           Scoutui::Logger::LogMgr.instance.warn __FILE__ + (__LINE__).to_s + " #{ex.class.to_s}"
-          puts __FILE__ + (__LINE__).to_s +  "Backtrace:\n\t#{ex.backtrace.join("\n\t")}"
+          Scoutui::Logger::LogMgr.instance.warn __FILE__ + (__LINE__).to_s +  "Backtrace:\n\t#{ex.backtrace.join("\n\t")}"
         end
 
       end
@@ -298,7 +298,7 @@ module Scoutui::Base
       _t=nil
 
       _assertType=isValidAssertType(_execute_when)
-      puts __FILE__ + (__LINE__).to_s + " assertType => #{_assertType}"
+      Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " assertType => #{_assertType}"
       if !_assertType.nil?
         _t = _assertType[:parse].call(_execute_when)
       end
@@ -345,7 +345,7 @@ module Scoutui::Base
 
         _enabled = Scoutui::Base::QBrowser.isEnabled?(_obj, my_driver, _locator)
 
-        puts __FILE__ + (__LINE__).to_s + " _obj.enabled? => #{_enabled}"
+        Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " _obj.enabled? => #{_enabled}"
 
         if _execute_when.match(/^\s*!isEnabled/i) && _enabled
 
@@ -357,7 +357,7 @@ module Scoutui::Base
             begin
               Selenium::WebDriver::Wait.new(timeout: 15).until {
                 _obj = Scoutui::Base::QBrowser.findElement(my_driver, _locator, Scoutui::Commands::Utils.instance.getFrameSearch(),  Scoutui::Commands::Utils.instance.getTimeout)
-                puts __FILE__ + (__LINE__).to_s + " waiting .. => #{_obj.class.to_s} : enabled - #{_obj.enabled?}"
+                Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " waiting .. => #{_obj.class.to_s} : enabled - #{_obj.enabled?}"
 
                 !_obj.enabled?
               }
@@ -420,7 +420,7 @@ module Scoutui::Base
       _obj = Scoutui::Base::QBrowser.findElement(my_driver, _locator, Scoutui::Commands::Utils.instance.getFrameSearch(),  Scoutui::Commands::Utils.instance.getTimeout)
 
       _state = _obj.selected?
-      puts __FILE__ + (__LINE__).to_s + " _obj.selected? => #{_state}"
+      Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " _obj.selected? => #{_state}"
 
       if _execute_when.match(/^\s*!(isSelected|selected)/i) && _state
         Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " !isSelected(#{_locator}) : false"
@@ -479,7 +479,7 @@ module Scoutui::Base
 
                 Selenium::WebDriver::Wait.new(timeout: 15).until {
                   _obj = Scoutui::Base::QBrowser.findElement(my_driver, _locator, Scoutui::Commands::Utils.instance.getFrameSearch(),  Scoutui::Commands::Utils.instance.getTimeout)
-                  puts __FILE__ + (__LINE__).to_s + " waiting .. => #{_obj.class.to_s}"
+                  Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " waiting .. => #{_obj.class.to_s}"
                   _rc = (_obj.is_a?(Selenium::WebDriver::Element) && !_obj.displayed?) || _obj.nil?
                 }
 
@@ -487,10 +487,10 @@ module Scoutui::Base
 
                 Selenium::WebDriver::Wait.new(timeout: 15).until {
                   _obj = Scoutui::Base::QBrowser.findElement(my_driver, _locator, Scoutui::Commands::Utils.instance.getFrameSearch(),  Scoutui::Commands::Utils.instance.getTimeout)
-                  puts __FILE__ + (__LINE__).to_s + " waiting .. => #{_obj.class.to_s}"
+                  Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " waiting .. => #{_obj.class.to_s}"
 
                   if _obj.is_a?(Selenium::WebDriver::Element)
-                    puts "***** displayed? : #{_obj.displayed?}"
+                    Scoutui::Logger::LogMgr.instance.debug "***** displayed? : #{_obj.displayed?}"
                   end
 
                   _rc = !_obj.nil? && _obj.displayed?
@@ -502,12 +502,12 @@ module Scoutui::Base
             ;
           end
 
-          puts __FILE__ + (__LINE__).to_s + " waitFor : #{_rc}"
+          Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " waitFor : #{_rc}"
           return _rc
         end
 
 
-        puts __FILE__ + (__LINE__).to_s + " _obj.displayed? => #{_state}"
+        Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " _obj.displayed? => #{_state}"
 
         if _execute_when.match(/^\s*!visible/i) && _state
           Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " !visible(#{_locator}) : false"
@@ -520,7 +520,7 @@ module Scoutui::Base
       rescue => ex
         rc=false
         Scoutui::Logger::LogMgr.instance.warn __FILE__ + (__LINE__).to_s + " #{ex.class.to_s}"
-        puts __FILE__ + (__LINE__).to_s +  "Backtrace:\n\t#{ex.backtrace.join("\n\t")}"
+        Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s +  "Backtrace:\n\t#{ex.backtrace.join("\n\t")}"
       end
 
       Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " visible?(#{_execute_when}) => #{rc}"
@@ -611,8 +611,8 @@ module Scoutui::Base
 
 
               if _v.is_a?(String)
-                puts __FILE__ + (__LINE__).to_s + " #{_v} is a string - next"
-                puts __FILE__ + (__LINE__).to_S + " TBD"  # Pause", gets
+                Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " #{_v} is a string - next"
+                Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_S + " TBD"  # Pause", gets
                 next
               end
 
@@ -663,7 +663,7 @@ module Scoutui::Base
 
 
                 elsif assertPageElement(_k, _v, _obj, my_driver, _req)
-                  puts __FILE__ + (__LINE__).to_s + " Processed assertPageElement(#{_k}, #{_v})";
+                  Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " Processed assertPageElement(#{_k}, #{_v})";
                   ;
 #               elsif visible_when_title(_k, _v, _obj, my_driver, _req)
 #                 ;
@@ -693,7 +693,7 @@ module Scoutui::Base
 
             rescue => ex
               Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " Invalid file: #{datafile} - abort processing."
-              puts __FILE__ + (__LINE__).to_s +  "Backtrace:\n\t#{ex.backtrace.join("\n\t")}"
+              Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s +  "Backtrace:\n\t#{ex.backtrace.join("\n\t")}"
             end
 
 
@@ -726,7 +726,7 @@ module Scoutui::Base
 
       end
 
-      puts __FILE__ + (__LINE__).to_s + " Pause debug"; gets
+      Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " Pause debug"; gets
     end
 
     #
@@ -736,7 +736,7 @@ module Scoutui::Base
         _req = Scoutui::Utils::TestUtils.instance.getReq()
       end
 
-      puts __FILE__ + (__LINE__).to_s + " [isVisible]: #{page_elt}, req:#{_req}"
+      Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " [isVisible]: #{page_elt}, req:#{_req}"
 
       rc=false
       cmd='visible'
@@ -762,7 +762,7 @@ module Scoutui::Base
 
         obj = Scoutui::Base::QBrowser.getObject(my_driver, xpath, Scoutui::Commands::Utils.instance.getTimeout)
 
-        puts __FILE__ + (__LINE__).to_s + " #{condition} : #{obj}"
+        Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " #{condition} : #{obj}"
 
         if condition.match(/^text/)
           _txt = obj.text
@@ -779,7 +779,7 @@ module Scoutui::Base
         expected_url = page_elt.match(/^\s*(url)\s*\((.*)\)/)[2].to_s
 
 
-        puts __FILE__ + (__LINE__).to_s + " verify is URL matches #{current_url} with expected #{expected_url}"
+        Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " verify is URL matches #{current_url} with expected #{expected_url}"
 
         expected_regex = Regexp.new(expected_url)
         rc=!current_url.match(expected_regex).nil?
@@ -994,7 +994,7 @@ module Scoutui::Base
       if page_elt.is_a?(Hash) && page_elt.has_key?('visible_when') && !page_elt['visible_when'].is_a?(Array) && page_elt['visible_when'].match(/^\s*(text|value)\s*\(/)
 
         begin
-          puts __FILE__ + (__LINE__).to_s + " ==> #{page_elt['visible_when'].match(/^\s*(text|value)\s*\(/)[1]}"
+          Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " ==> #{page_elt['visible_when'].match(/^\s*(text|value)\s*\(/)[1]}"
 
           _processed=true
           rc=nil
@@ -1079,7 +1079,7 @@ module Scoutui::Base
 
         rescue => ex
           Scoutui::Logger::LogMgr.instance.warn __FILE__ + (__LINE__).to_s + " Error during processing: #{ex}"
-          puts __FILE__ + (__LINE__).to_s +  "Backtrace:\n\t#{ex.backtrace.join("\n\t")}"
+          Scoutui::Logger::LogMgr.instance.warn __FILE__ + (__LINE__).to_s +  "Backtrace:\n\t#{ex.backtrace.join("\n\t")}"
 
         end
 

data/lib/scoutui/base/q_browser.rb

@@ -151,7 +151,7 @@ module Scoutui::Base
 
       if isChrome?(drv)
 
-        puts __FILE__ + (__LINE__).to_s + " swtich on Chrome browser"
+        Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " swtich on Chrome browser"
         bframes = drv.find_elements(:xpath, '//iframe')
 
         Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " //iframe : size #{bframes.size}"
@@ -172,14 +172,14 @@ module Scoutui::Base
             end
 
 
-            puts __FILE__ + (__LINE__).to_s + "[switch_into_frame.chrome]: <tag, id> :: <#{_tag}, #{id} >"
+            Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + "[switch_into_frame.chrome]: <tag, id> :: <#{_tag}, #{id} >"
 
             if !_tag.empty? && id==_tag
 
               hit = bframes[i]
               drv.switch_to.frame hit
 
-              puts __FILE__ + (__LINE__).to_s + " swtichframe to #{i} - #{_tag}"
+              Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " swtichframe to #{i} - #{_tag}"
               break
             end
 
@@ -192,7 +192,7 @@ module Scoutui::Base
 
       else
         # Firefox, IE
-        puts __FILE__ + (__LINE__).to_s + " [switch_into_frame]: drv.switch_to.frame(#{id.to_s}";
+        Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " [switch_into_frame]: drv.switch_to.frame(#{id.to_s}";
 
         hit = drv.switch_to.frame(id.to_s.strip)
       end
@@ -207,10 +207,10 @@ module Scoutui::Base
     # format: frame(<string>)[.frame(<string>)]*
     def self.switch_frame(drv, e)
 
-      puts __FILE__ + (__LINE__).to_s + "\n\n== self.switch_frame(#{e}) =="
+      Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + "\n\n== self.switch_frame(#{e}) =="
       frames=nil
       if e.is_a?(Hash) && e.has_key?('page') && e['page'].has_key?('frames')
-        puts __FILE__ + (__LINE__).to_s + " frames => #{e['page']['frames']}";
+        Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " frames => #{e['page']['frames']}";
 
         frames=e['page']['frames']
       elsif e.is_a?(String)
@@ -219,19 +219,19 @@ module Scoutui::Base
 
 
       if !frames.nil?
-        puts __FILE__ + (__LINE__).to_s + " [self.switch_frame]: frames => #{frames}";
+        Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " [self.switch_frame]: frames => #{frames}";
 
     #   frame_list=frames.split(/(frame\(.*\))\.(?=[\w])/)
         frame_list=frames.split(/\.(?=frame)/)
 
 
         frame_list.each do |_f|
-          puts __FILE__ + (__LINE__).to_s + " processing #{_f}"
+          Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " processing #{_f}"
 
           if !_f.empty?
             _id = _f.match(/frame\((.*)\)/)[1]
 
-            puts __FILE__ + (__LINE__).to_s + " [self.switch_frame]: switch_to.frame #{_id}"
+            Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " [self.switch_frame]: switch_to.frame #{_id}"
 
             # Swtich based on browser type
 
@@ -243,14 +243,14 @@ module Scoutui::Base
                 Scoutui::Logger::LogMgr.instance.warn __FILE__ + (__LINE__).to_s + " Sucessfully switched frame into #{_id}"
               end
             else
-              puts __FILE__ + (__LINE__).to_s + " [firefox]: switch_to.frame #{_id}"
+              Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " [firefox]: switch_to.frame #{_id}"
               drv.switch_to.frame _id
             end
 
             if false
 
               if drv.browser.to_s.match(/firefox/i)
-                puts __FILE__ + (__LINE__).to_s + " [firefox]: switch_to.frame #{_id}"
+                Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " [firefox]: switch_to.frame #{_id}"
                 drv.switch_to.frame _id
               else
 
@@ -285,7 +285,7 @@ module Scoutui::Base
           _obj.tag_name
           _obj.attribute('type')
         else
-          puts __FILE__ + (__LINE__).to_s + " | isStale? => nil"
+          Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " | isStale? => nil"
           return nil
         end
 
@@ -300,7 +300,7 @@ module Scoutui::Base
         puts ex.backtrace
       end
 
-      puts __FILE__ + (__LINE__).to_s + " | isStale?(#{_obj}) : nosuch=#{_noSuch},  stale=#{_isStale}"
+      Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " | isStale?(#{_obj}) : nosuch=#{_noSuch},  stale=#{_isStale}"
       return (_noSuch || _isStale)
     end
 
@@ -326,7 +326,7 @@ module Scoutui::Base
               wait = Selenium::WebDriver::Wait.new(:timeout =>  Scoutui::Commands::Utils.instance.getTimeout)
               isDisplayed = wait.until {
                 if Scoutui::Base::QBrowser.isStale?(_obj)
-                  puts __FILE__ + (__LINE__).to_s + " ** refetch #{_locator} **"
+                  Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " ** refetch #{_locator} **"
                   _obj=Scoutui::Base::QBrowser.findElement(my_driver, Scoutui::Base::UserVars.instance.normalize(_locator), Scoutui::Commands::Utils.instance.getFrameSearch(),  Scoutui::Commands::Utils.instance.getTimeout)
                 end
                 true if _obj.enabled?
@@ -334,15 +334,15 @@ module Scoutui::Base
 
             end
 
-            puts __FILE__ + (__LINE__).to_s + " enabled => #{_obj.enabled?}"
+            Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " enabled => #{_obj.enabled?}"
 
             if _obj.enabled?
               _disabled=_obj.attribute("disabled")
               _rdonly = _obj.attribute("readonly")
 
-              puts __FILE__ + (__LINE__).to_s + " disabled: #{_disabled}  nil: #{_disabled.nil?}"
-              puts __FILE__ + (__LINE__).to_s + " readonly: #{_rdonly}    nil: #{_rdonly.nil?}"
-              puts __FILE__ + (__LINE__).to_s + " enabled:  #{_obj.enabled?}"
+              Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " disabled: #{_disabled}  nil: #{_disabled.nil?}"
+              Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " readonly: #{_rdonly}    nil: #{_rdonly.nil?}"
+              Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " enabled:  #{_obj.enabled?}"
 
               rc = _obj.enabled? && !(_obj.attribute("disabled") || _obj.attribute("readonly") )
 
@@ -374,9 +374,9 @@ module Scoutui::Base
                                                 _frames,
                                                 _timeout)
 
-      puts __FILE__ + (__LINE__).to_s + " | locator: #{_locator}"
-      puts __FILE__ + (__LINE__).to_s + " | obj : #{obj}"
-      puts __FILE__ + (__LINE__).to_s + " | stale : " + Scoutui::Base::QBrowser.isStale?(obj).to_s
+      Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " | locator: #{_locator}"
+      Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " | obj : #{obj}"
+      Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " | stale : " + Scoutui::Base::QBrowser.isStale?(obj).to_s
 
       cnt=0
       if obj.is_a?(Selenium::WebDriver::Element) && Scoutui::Base::QBrowser.isStale?(obj) && !_locator.nil?
@@ -390,7 +390,7 @@ module Scoutui::Base
               wait = Selenium::WebDriver::Wait.new(:timeout =>  Scoutui::Commands::Utils.instance.getTimeout)
               _isntStale = wait.until {
                   _rc=Scoutui::Base::QBrowser.isStale?(obj)
-                  puts __FILE__ + (__LINE__).to_s + "  stale(#{_locator}) : #{_rc}"
+                  Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + "  stale(#{_locator}) : #{_rc}"
                   if _rc
                     obj = Scoutui::Base::QBrowser.findElement(drv, _locator,
                                                               _frames,
@@ -403,10 +403,10 @@ module Scoutui::Base
             end
 
 
-            puts __FILE__ + (__LINE__).to_s + " #{i} ==> stale(#{_locator}) : #{_isntStale}"
+            Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " #{i} ==> stale(#{_locator}) : #{_isntStale}"
 
             if !_isntStale
-                puts __FILE__ + (__LINE__).to_s + " #{i} => obj is STALE : #{_locator}"
+              Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " #{i} => obj is STALE : #{_locator}"
                 obj = Scoutui::Base::QBrowser.findElement(drv, _locator,
                                                           _frames,
                                                           _timeout)
@@ -419,7 +419,7 @@ module Scoutui::Base
 
       end
 
-      puts __FILE__ + (__LINE__).to_s + " getElement(#{_locator}) : #{obj}, cnt:#{cnt}, isntStale:#{_isntStale}"
+      Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " getElement(#{_locator}) : #{obj}, cnt:#{cnt}, isntStale:#{_isntStale}"
       obj
     end
 
@@ -437,7 +437,7 @@ module Scoutui::Base
       elsif Scoutui::Commands::Utils.instance.isFrameSearch?
         hits = Scoutui::Base::QBrowser.frame_getObject(drv, _locator, _timeout)
 
-        puts __FILE__ + (__LINE__).to_s + " hits => #{hits.class} : #{hits}"
+        Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " hits => #{hits.class} : #{hits}"
         if hits.is_a?(Array) && !hits.empty?
           obj=hits[0]
         elsif hits.is_a?(Selenium::WebDriver::Element)
@@ -456,7 +456,7 @@ module Scoutui::Base
 
     def self.frame_getObject(drv, _locator, _timeout=nil)
 
-      puts __FILE__ + (__LINE__).to_s + " [enter]:frame_getObject : #{_locator}"
+      Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " [enter]:frame_getObject : #{_locator}"
 
       rc = Array.new()
 
@@ -472,7 +472,7 @@ module Scoutui::Base
 
       _obj = getObject(drv, _locator, _timeout)
 
-      puts __FILE__ + (__LINE__).to_s + " frames => #{frames}  :  #{_obj}"
+      Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " frames => #{frames}  :  #{_obj}"
 
       if _obj.nil? || (_obj.is_a?(Array) && _obj.empty?)
 
@@ -500,7 +500,7 @@ module Scoutui::Base
               drv.switch_to.frame frames[i]
             else
 
-              puts __FILE__ + (__LINE__).to_s +  " switch_to.frame #{_tag}"
+              Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s +  " switch_to.frame #{_tag}"
               drv.switch_to.frame _tag
             end
 
@@ -524,7 +524,7 @@ module Scoutui::Base
             break
           end
 
-          puts __FILE__ + (__LINE__).to_s + " switch_to.parent_frame()"
+          Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " switch_to.parent_frame()"
           drv.switch_to.parent_frame if _madeSwitch
 
         end

data/lib/scoutui/base/user_vars.rb

@@ -74,6 +74,10 @@ module Scoutui::Base
 
     def normalize(s)
 
+      if s.nil? || s.empty?
+        return s
+      end
+
       begin
         if Scoutui::Base::UserVars.instance.isTestData?(s)
 

data/lib/scoutui/base/visual_test_framework.rb

@@ -15,7 +15,7 @@ module Scoutui::Base
 
     def self.processPageElement(my_driver, k, xpath)
 
-      puts __FILE__ + (__LINE__).to_s + " processPageElement(#{xpath})"
+      Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " processPageElement(#{xpath})"
       processed=false
       _obj=nil
 
@@ -78,7 +78,7 @@ module Scoutui::Base
 
 
               if _v.is_a?(String)
-                puts __FILE__ + (__LINE__).to_s + " #{_v} is a string - next"
+                Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " #{_v} is a string - next"
                 next
               end
 
@@ -147,7 +147,7 @@ module Scoutui::Base
                 Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " visible_when : (Array) - TBD  #{_v['visible_when']}"
 
                 _v['visible_when'].each do |_vwhen|
-                  puts __FILE__ + (__LINE__).to_s + " #{_vwhen}  #{_vwhen.class}"
+                  Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " #{_vwhen}  #{_vwhen.class}"
 
                   Scoutui::Base::Assertions.instance.assertPageElement(_k, _vwhen, _obj, my_driver, _req)
 
@@ -157,8 +157,8 @@ module Scoutui::Base
 
 
             rescue => ex
-              Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " Error during processing: #{ex}"
-              puts __FILE__ + (__LINE__).to_s +  "Backtrace:\n\t#{ex.backtrace.join("\n\t")}"
+              Scoutui::Logger::LogMgr.instance.warn __FILE__ + (__LINE__).to_s + " Error during processing: #{ex}"
+              Scoutui::Logger::LogMgr.instance.warn __FILE__ + (__LINE__).to_s +  "Backtrace:\n\t#{ex.backtrace.join("\n\t")}"
             end
 
 
@@ -366,9 +366,9 @@ module Scoutui::Base
 
             _reqID=_a.match(/^\s*(req|requirement)\s*\((.*)\)\s*$/i)[2].to_s
 
-            puts __FILE__ + (__LINE__).to_s + "  Process REQ ASSERT: #{_reqID}";
+            Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + "  Process REQ ASSERT: #{_reqID}";
             _reqAsserts=Scoutui::Base::Requirements.instance.get(_reqID)
-            puts __FILE__ + (__LINE__).to_s + " => #{_reqAsserts}"
+            Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " => #{_reqAsserts}"
 
             _req = Scoutui::Utils::TestUtils.instance.setReq(_reqID)
             _rc=processAsserts(my_driver, _reqAsserts, _enableAsserts)
@@ -410,7 +410,7 @@ module Scoutui::Base
 
       _req = Scoutui::Utils::TestUtils.instance.getReq()
 
-      puts __FILE__ + (__LINE__).to_s + "======= #{e[STEP_KEY][_conditionType]} ========="
+      Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + "======= #{e[STEP_KEY][_conditionType]} ========="
 
 
       e[STEP_KEY][_conditionType].each do |elt|
@@ -450,7 +450,7 @@ module Scoutui::Base
 
             if !_locator.match(/^page\([\w\d]+\)/).nil?
               _obj = processPageElement(my_driver, _k, _locator)
-              puts __FILE__ + (__LINE__).to_s + " Processed #{_locator} => #{_obj.class.to_s}"
+              Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " Processed #{_locator} => #{_obj.class.to_s}"
             else
 
               Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " " + _k.to_s + " => " + _locator
@@ -475,8 +475,8 @@ module Scoutui::Base
 
 
 
-              puts __FILE__ + (__LINE__).to_s + " _uservar_val : #{_uservar_val}"
-              puts __FILE__ + (__LINE__).to_s + " Assert user variable - #{user_var} matches #{expected_v} => #{_uservar_val.match(expected_v)}"
+              Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " _uservar_val : #{_uservar_val}"
+              Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " Assert user variable - #{user_var} matches #{expected_v} => #{_uservar_val.match(expected_v)}"
 
 
               if _uservar_val.match(expected_v) || _uservar_val==expected_v
@@ -518,9 +518,9 @@ module Scoutui::Base
 
         rescue => ex
 
-          Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " abort processing."
-          Scoutui::Logger::LogMgr.instance.debug "Error during processing: #{ex}"
-          puts __FILE__ + (__LINE__).to_s +  "Backtrace:\n\t#{ex.backtrace.join("\n\t")}"
+          Scoutui::Logger::LogMgr.instance.warn __FILE__ + (__LINE__).to_s + " abort processing."
+          Scoutui::Logger::LogMgr.instance.warn "Error during processing: #{ex}"
+          Scoutui::Logger::LogMgr.instance.warn __FILE__ + (__LINE__).to_s +  "Backtrace:\n\t#{ex.backtrace.join("\n\t")}"
         end
 
 
@@ -593,17 +593,17 @@ module Scoutui::Base
 
               _obj =  Scoutui::Base::QBrowser.getObject(my_driver, _e, Scoutui::Commands::Utils.instance.getTimeout)
 
-               puts __FILE__ + (__LINE__).to_s + " Wait until element #{xpath} => #{_e} is not visible #{_obj}.class.to_s"
+              Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " Wait until element #{xpath} => #{_e} is not visible #{_obj}.class.to_s"
 
               if _obj.nil?
                 _rc = true
               else
-                puts __FILE__ + (__LINE__).to_s + " _obj => #{_obj} : exists: #{!_obj.nil?}"
+                Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " _obj => #{_obj} : exists: #{!_obj.nil?}"
 
                 begin
                   Selenium::WebDriver::Wait.new(timeout: _timeout).until {
                     _obj = Scoutui::Base::QBrowser.getObject(my_driver, _e, 5)
-                    puts __FILE__ + (__LINE__).to_s + " waiting .. => #{_obj.class.to_s}"
+                    Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " waiting .. => #{_obj.class.to_s}"
 
                     _obj.nil?
                   }
@@ -665,7 +665,7 @@ module Scoutui::Base
 
 
                     if _v.is_a?(String)
-                      puts __FILE__ + (__LINE__).to_s + " #{_v} is a string - next"
+                      Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " #{_v} is a string - next"
                       next
                     end
 
@@ -740,8 +740,8 @@ module Scoutui::Base
 
 
                   rescue => ex
-                    Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " Invalid file: #{datafile} - abort processing."
-                    puts __FILE__ + (__LINE__).to_s +  "Backtrace:\n\t#{ex.backtrace.join("\n\t")}"
+                    Scoutui::Logger::LogMgr.instance.warn __FILE__ + (__LINE__).to_s + " Invalid file: #{datafile} - abort processing."
+                    Scoutui::Logger::LogMgr.instance.warn __FILE__ + (__LINE__).to_s +  "Backtrace:\n\t#{ex.backtrace.join("\n\t")}"
                   end
 
 
@@ -801,7 +801,7 @@ module Scoutui::Base
     # Scoutui::Base::VisualTestFramework.processFile(@drv, @eyes, @test_settings['host'], @test_settings['dut'])
     def self.processFile(eyeScout, test_settings, strategy=nil)
 
-      puts __FILE__ + (__LINE__).to_s + " [enter]:processFile(#{test_settings['dut']})"
+      Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " [enter]:processFile(#{test_settings['dut']})"
       my_driver = eyeScout.drv()
 
       baseUrl = Scoutui::Base::UserVars.instance.getHost()
@@ -899,7 +899,7 @@ module Scoutui::Base
 
             _rc=(_uservar_val.match(/#{_val}/) || _uservar_val==_val)
 
-            puts __FILE__ + (__LINE__).to_s + " _rc => #{_rc} is nil (#{_rc.nil?})"
+            Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " _rc => #{_rc} is nil (#{_rc.nil?})"
 
             if !_rc
               Scoutui::Logger::LogMgr.instance.info " Execute_When: #{_uservar_val} == #{_val} : false - skip #{e[STEP_KEY]}"
@@ -927,7 +927,7 @@ module Scoutui::Base
             _executeIt=true
 
             _execute_when.each do |_a|
-              Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " exeucute_when => #{_a.class} : #{_a}"
+              Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " execute_when => #{_a.class} : #{_a}"
 
 
               if _a.to_s.match(/^\s*(\$\{.*\})\s*(==|!=)(.*)$/)
@@ -954,7 +954,7 @@ module Scoutui::Base
                   Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " isEnabled #{_a} : failed"
                   _executeIt=false
                 else
-                  puts __FILE__ + (__LINE__).to_s + " IS_ENABLED : #{_a}";
+                  Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " IS_ENABLED : #{_a}";
                 end
 
 
@@ -963,6 +963,8 @@ module Scoutui::Base
                 if !Scoutui::Base::Assertions.instance.isRole?(_a)
                   Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " isRole #{_a} : failed"
                   _executeIt = false
+                else
+                  Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " execute => role matched"
                 end
 
               elsif Scoutui::Base::Assertions.instance.isVisibleCmd?(_a)
@@ -1003,7 +1005,7 @@ module Scoutui::Base
           elsif _execute_when.is_a?(String)
             _rc=Scoutui::Base::Assertions.instance.isVisible(my_driver, _execute_when, _reqid, true)
 
-            puts __FILE__ + (__LINE__).to_s + " EXECUTE_WHEN  #{_rc}";
+            Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " EXECUTE_WHEN  #{_rc}";
 
             if !_rc
               Scoutui::Logger::LogMgr.instance.info " Execute_When: true - skip #{e[STEP_KEY]}"
@@ -1014,6 +1016,7 @@ module Scoutui::Base
         end
 
 
+
         skipIt = (!_skip.nil?) && (_skip.to_s.strip.downcase=='true')
         Scoutui::Logger::LogMgr.instance.info "\to skip : #{skipIt}" if Scoutui::Utils::TestUtils.instance.isDebug?
 
@@ -1032,18 +1035,18 @@ module Scoutui::Base
         if e[STEP_KEY].has_key?('command')
           _id = e[STEP_KEY]['command']['id'].to_s
           _rc=CmdShellMgr::DSL.instance.cmd(:cmd => "execute(#{_id})")
-          puts __FILE__ + (__LINE__).to_s + " rc => #{_rc}"
+          Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " rc => #{_rc}"
           next
         end
 
         if e[STEP_KEY].has_key?('getResults')
           _id = e[STEP_KEY]['getResults']['id'].to_s
           _rc = CmdShellMgr::DSL.instance.cmd(:cmd => "getResults(#{_id})")
-          puts __FILE__ + (__LINE__).to_s + " rc => #{_rc}"
+          Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " rc => #{_rc}"
 
           if e[STEP_KEY]['getResults'].has_key?('capture')
             m2=CmdShellMgr::DSL.instance.cmd(:cmd => "getResult(#{_id}).capture(#{e[STEP_KEY]['getResults']['capture'].to_s})")
-            puts __FILE__ + (__LINE__).to_s + " Capture => #{m2}"
+            Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " Capture => #{m2}"
 
 
             if e[STEP_KEY]['getResults'].has_key?('assignto')
@@ -1103,8 +1106,6 @@ module Scoutui::Base
             end
 
             processExpected(my_driver, e)
-
-
             processAssertions(my_driver, e)
             _assertResult=processAsserts(my_driver, e[STEP_KEY]["asserts"])
 
@@ -1139,6 +1140,10 @@ module Scoutui::Base
               return
             end
 
+
+            ##
+            # SaveAs
+            ##
             if e[STEP_KEY].has_key?('saveas')
               # processSaveAs(e)
 
@@ -1160,19 +1165,24 @@ module Scoutui::Base
                 end
 
               rescue => ex
-                puts __FILE__ + (__LINE__).to_s + " #{ex}"
-                puts  ex.backtrace
+                Scoutui::Logger::LogMgr.instance.warn __FILE__ + (__LINE__).to_s + " #{ex}"
+                Scoutui::Logger::LogMgr.instance.warn  ex.backtrace
               ensure
                 _f.close
               end
 
             end
 
+            if Scoutui::Utils::TestUtils.instance.screenShots?
+              _saveScreenAs=Scoutui::Utils::TestUtils.instance.sanitize_filename(_name)
+              Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " ScreenSave : #{_saveScreenAs}"
+              my_driver.save_screenshot("/tmp/#{_saveScreenAs}.png")
+            end
 
             if isSnapIt(e)
 
               if QBrowser.existsAlert?(my_driver)
-                puts __FILE__ + (__LINE__).to_s + " Snapit with existing Alert"
+                Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " Snapit with existing Alert"
               end
 
               if !_region.nil?
@@ -1222,6 +1232,8 @@ module Scoutui::Base
 
         processExpected(my_driver, e)
         processAssertions(my_driver, e)
+        _assertResult=processAsserts(my_driver, e[STEP_KEY]["asserts"])   # 5150
+        Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " ======  assertResults : #{_assertResult}"
 
         if e[STEP_KEY].has_key?("highlight") && e[STEP_KEY]["highlight"].has_key?("locators")
           _cmd="Highlight"

data/lib/scoutui/commands/click_object.rb

@@ -30,7 +30,7 @@ module Scoutui::Commands
           elsif _pg.is_a?(String)
             isVisible=Scoutui::Base::Assertions.instance.isVisible(@drv, _pg, _r)
           else
-            puts __FILE__ + (__LINE__).to_s + " => #{_pg}"
+            Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " => #{_pg}"
           end
 
         end
@@ -102,7 +102,7 @@ module Scoutui::Commands
 
             (0..5).each do |_i|
               _retry = true
-              puts __FILE__ + (__LINE__).to_s + " #{_i} => click(#{obj})"
+              Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " #{_i} => click(#{obj})"
               begin
 
                 _startTime=Time.now

data/lib/scoutui/commands/highlight.rb

@@ -42,6 +42,8 @@ module Scoutui::Commands
           locators = e['page']['locators']
         end
 
+        Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " highlight.locators => #{locators}"
+
         locators.each do |elt|
 
 

data/lib/scoutui/commands/type.rb

@@ -37,7 +37,7 @@ module Scoutui::Commands
           elsif _pg.is_a?(String)
             isVisible=Scoutui::Base::Assertions.instance.isVisible(@drv, _pg, _r)
           else
-            puts __FILE__ + (__LINE__).to_s + " => #{_pg}"
+            Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " => #{_pg}"
           end
 
 #         Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " IsVisible #{isVisible} - PAUSE"; gets
@@ -151,13 +151,13 @@ module Scoutui::Commands
                   for i in 0 .. (_uservars.size - 1)
 
                     _t = Scoutui::Base::UserVars.instance.get(_uservars[i][0])
-                    puts __FILE__ + (__LINE__).to_s + " translate(#{_uservars[i][0]}) => #{_t}"
+                    Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " translate(#{_uservars[i][0]}) => #{_t}"
 
                     if !_t.nil? && _uservars[i][0]!=_t
                       _v2.gsub!("\$\{#{_uservars[i][0]}\}", _t)
                     end
 
-                    puts __FILE__ + (__LINE__).to_s + " value => #{_v2}"
+                    Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " value => #{_v2}"
 
                   end
 
@@ -193,7 +193,7 @@ module Scoutui::Commands
 
 
 
-                  puts __FILE__ + (__LINE__).to_s + " Stale: #{_stale}, i: #{_cnt}, _inRow:#{_inRow}"
+                  Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " Stale: #{_stale}, i: #{_cnt}, _inRow:#{_inRow}"
                 end
 
                   obj.send_keys(_text_to_type)
@@ -213,7 +213,7 @@ module Scoutui::Commands
                     if i > 0
                       obj.send_keys("")
                       @drv.action.send_keys(:enter).perform
-                      puts __FILE__ + (__LINE__).to_s + " ENTER"; STDIN.gets()
+                      Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " ENTER"; STDIN.gets()
                       obj.send_keys("<ENTER>")
                     end
 
@@ -234,8 +234,8 @@ module Scoutui::Commands
         end
 
       rescue => ex
-        Scoutui::Logger::LogMgr.instance.debug "Error during processing: #{ex.class}"
-        puts __FILE__ + (__LINE__).to_s +  "Backtrace:\n\t#{ex.backtrace.join("\n\t")}"
+        Scoutui::Logger::LogMgr.instance.warn "Error during processing: #{ex.class}"
+        Scoutui::Logger::LogMgr.instance.warn __FILE__ + (__LINE__).to_s +  "Backtrace:\n\t#{ex.backtrace.join("\n\t")}"
       end
 
       _endTime=Time.now

data/lib/scoutui/commands/update_url.rb

@@ -39,7 +39,7 @@ module Scoutui::Commands
         _stop=Time.now
         _duration=_stop - _start
 
-        puts __FILE__ + (__LINE__).to_s + " Perf navigate to #{normUrl} : #{_duration}"
+        Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " Perf navigate to #{normUrl} : #{_duration}"
         Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " => title #{@drv.title.to_s}"
         _rc=true
       rescue => ex

data/lib/scoutui/commands/utils.rb

@@ -59,34 +59,34 @@ module Scoutui::Commands
           '__DDMMYY__' => lambda { Date.parse(Time.now.to_s).strftime("%d%m%Y") },
           '__MM/DD/YY__' => lambda { Date.parse(Time.now.to_s).strftime("%m/%d/%y") },
           '__MM/DD/YY\+\d+__' => lambda { |s|
-            puts __FILE__ + (__LINE__).to_s + " Process s => #{s}"
+            Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " Process s => #{s}"
             d=s.match(/__MM\/DD\/YY\+(\d+)__/)[1]
             d=(Date.today + d.to_i).strftime("%m/%d/%y")
-            puts __FILE__ + (__LINE__).to_s + "    new date: #{d}"
+            Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + "    new date: #{d}"
             d
           },
           '__MMDDYY__' => lambda { Date.parse(Time.now.to_s).strftime("%m%d%y") },
           '__MMDDYY\+\d+__' => lambda { |s|
-            puts __FILE__ + (__LINE__).to_s + " Process s => #{s}"
+            Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " Process s => #{s}"
             d=s.match(/__MMDDYY\+(\d+)__/)[1]
             d=(Date.today + d.to_i).strftime("%m%d%y")
-            puts __FILE__ + (__LINE__).to_s + "    new date: #{d}"
+            Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + "    new date: #{d}"
             d
           },
           '__MM/DD/YYYY__' => lambda { Date.parse(Time.now.to_s).strftime("%m/%d/%Y") },
           '__MM/DD/YYYY\+\d+__' => lambda { |s|
-            puts __FILE__ + (__LINE__).to_s + " Process s => #{s}"
+            Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " Process s => #{s}"
             d=s.match(/__MM\/DD\/YYYY\+(\d+)__/)[1]
             d=(Date.today + d.to_i).strftime("%m/%d/%Y")
-            puts __FILE__ + (__LINE__).to_s + "    new date: #{d}"
+            Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + "    new date: #{d}"
             d
           },
           '__MMDDYYYY__' => lambda { Date.parse(Time.now.to_s).strftime("%m%d%Y") },
           '__MMDDYYYY\+\d+__' => lambda { |s|
-            puts __FILE__ + (__LINE__).to_s + " Process s => #{s}"
+            Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " Process s => #{s}"
             d=s.match(/__MMDDYYYY\+(\d+)__/)[1]
             d=(Date.today + d.to_i).strftime("%m%d%Y")
-            puts __FILE__ + (__LINE__).to_s + "    new date: #{d}"
+            Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + "    new date: #{d}"
             d
           },
           '__PARAGRAPH__' => lambda { Faker::Lorem.paragraph.to_s },
@@ -144,7 +144,7 @@ module Scoutui::Commands
         end
       end
 
-      puts __FILE__ + (__LINE__).to_s + " expandMacro : #{_text_to_type}"
+      Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " expandMacro : #{_text_to_type}"
 
       _text_to_type.to_s
 
@@ -156,7 +156,7 @@ module Scoutui::Commands
       setEnableFrameSearch(false)
 
       if stanza.is_a?(Hash) && stanza.has_key?('page') && stanza['page'].has_key?('frames')
-        puts __FILE__ + (__LINE__).to_s + " frames => #{stanza['page']['frames']}";
+        Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " frames => #{stanza['page']['frames']}";
 
         setEnableFrameSearch(stanza['page']['frames'])
 #        setEnableFrameSearch(!stanza['page']['frames'].to_s.match(/true/i).nil?)

data/lib/scoutui/eyes/eye_factory.rb

@@ -62,6 +62,17 @@ module Scoutui::Eyes
 
           eyes.match_level = Applitools::Eyes::MATCH_LEVEL[match_level.to_sym]
 
+          if !Scoutui::Utils::TestUtils.instance.eyesBatchname().nil?
+            batch = Applitools::Base::BatchInfo.new(Scoutui::Utils::TestUtils.instance.eyesBatchname())
+
+            if !Scoutui::Utils::TestUtils.instance.eyesBatchId().nil?
+              batch.id = Scoutui::Utils::TestUtils.instance.eyesBatchId()
+            end
+
+            eyes.batch = batch
+          end
+
+
           Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " eyes => #{eyes}"
         end
 

data/lib/scoutui/eyes/eye_scout.rb

@@ -236,7 +236,7 @@ module Scoutui::Eyes
 #     Testmgr::TestReport.instance.generateReport()
 
       metrics=Testmgr::TestReport.instance.getMetrics()
-      Scoutui::Logger::LogMgr.instance.info "Metrics => #{metrics}"
+      puts __FILE__ + (__LINE__).to_s + "Metrics => #{metrics}"
 
       Scoutui::Utils::TestUtils.instance.setMetrics(metrics)
     end

data/lib/scoutui/logger/log_mgr.rb

@@ -64,7 +64,8 @@ module Scoutui::Logger
     end
 
     def setLevel(_level)
-      @root.level = _level.to_sym
+
+      @asserts.level = @benchmarks.level = @commands.level = @root.level = _level.to_sym
 
       _l = _level.to_s
       if _l.match(/debug/i)
@@ -77,6 +78,8 @@ module Scoutui::Logger
         @level = LOGLEVELS[ERROR]
       elsif _l.match(/fatal/i)
         @level = LOGLEVELS[FATAL]
+      else
+        raise "UNKNOWN_LEVEL"
       end
 
     end

data/lib/scoutui/utils/utils.rb

@@ -45,11 +45,14 @@ module Scoutui::Utils
       @options[:enable_eyes]=false
       @options[:enable_fullscreen]=true
       @options[:enable_sauce]=false
+      @options[:batchid]=nil
+      @options[:batchname]=nil
       @options[:log_level]=:info     # :debug, :info, :warn, :error, :fatal
       @options[:match_level]='layout'
       @options[:default_wait]=30     # seconds
       @options[:debug]=false
       @options[:fail_fast]=false
+      @options[:screenshots]=false
 
 
       @app_model=nil
@@ -248,6 +251,8 @@ module Scoutui::Utils
           @options[:enable_eyes]=true
         }
         opt.on('--eyes:run Bool', [:true, :false]) { |o| @options[:enable_eyes]  = !o.match(/true/i).nil? }
+        opt.on('--eyes:batchname Name') { |o| @options[:batchname] = o }
+        opt.on('--eyes:batchid ID')     { |o| @options[:batchid] = o }
         opt.on('--eyes:fullscreen Bool', [:true, :false]) { |o| @options[:enable_fullscreen] = !o.match(/true/i).nil? }
         opt.on('--eyes:app AppName') { |o| @options[:app] = o }
         opt.on('--eyes:title Title') { |o| @options[:title] = o }
@@ -256,6 +261,9 @@ module Scoutui::Utils
         opt.on('--report:junit File') { |o| @options[:report] = o }
 
 
+        opt.on('--screenshots Bool', [:true, :false]) { |o| @options[:screenshots] = !o.match(/true/i).nil? }
+
+
 
         opt.on('--role ROLE') { |o|
           @options[:role]=o
@@ -347,6 +355,27 @@ module Scoutui::Utils
       @options[:capabilities]
     end
 
+
+    def sanitize_filename(filename)
+      # Split the name when finding a period which is preceded by some
+      # character, and is followed by some character other than a period,
+      # if there is no following period that is followed by something
+      # other than a period
+      fn = filename.split /(?<=.)\.(?=[^.])(?!.*\.[^.])/m
+
+      # We now have one or two parts (depending on whether we could find
+      # a suitable period). For each of these parts, replace any unwanted
+      # sequence of characters with an underscore
+      fn.map! { |s| s.gsub /[^a-z0-9\-]+/i, '_' }
+
+      # Finally, join the parts with a period and return the result
+      return fn.join '.'
+    end
+
+    def screenShots?
+      @options[:screenshots]
+    end
+
     def getHost()
       @options[:host].to_s
     end
@@ -363,6 +392,14 @@ module Scoutui::Utils
       @options[:debug]
     end
 
+    def eyesBatchname()
+      @options[:batchname]
+    end
+
+    def eyesBatchId()
+      @options[:batchid]
+    end
+
     def eyesEnabled?
       @options[:enable_eyes]
     end

data/lib/scoutui/version.rb

@@ -1,3 +1,3 @@
 module Scoutui
-  VERSION = "2.0.3.48.pre"
+  VERSION = "2.0.3.49.pre"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: scoutui
 version: !ruby/object:Gem::Version
-  version: 2.0.3.48.pre
+  version: 2.0.3.49.pre
 platform: ruby
 authors:
 - Peter Kim
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-09-20 00:00:00.000000000 Z
+date: 2016-09-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -275,6 +275,7 @@ files:
 - examples/eyes/diff.rb
 - examples/eyes/ex2.rb
 - examples/eyes_results/response.json
+- examples/screenshot/fullshot.rb
 - examples/shell/run_shell.rb
 - examples/shell/runit.sh
 - examples/yaml/dut.yml