scoutui 2.0.3.30.pre → 2.0.3.31.pre

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: bec2331d9973d87b6ebde0aa7d385835cd64d28e
-  data.tar.gz: 1773cec8ac473fac69be4a81cd86ee4b3a05823c
+  metadata.gz: 73a3448dde2bef2a6176cd5a8845b08caca7d92c
+  data.tar.gz: 808bda329dce2017ffd5133606337a70512a2379
 SHA512:
-  metadata.gz: f0bb080dd63f6f999f572991459bc34dafa68b5f471b5b1e9e2192df7464a7657137388c4c424bd7461426bba572fd6d02b87566a5f2c2346bf5ac4e9aaa5ba2
-  data.tar.gz: c79d401e27bd6b1d506f3b74e4aac4786ed0328ecfbe03389baf126692dfc6c87a7014a00ff002752f94bc754729702645951816a1d172c73982790b095d34b3
+  metadata.gz: 59ba1d8747567b7a8261afd434f3a86e8c8a6913d6e28a1d7afaee997b0e72041d12c03d72ceb03fb488e116219c393957a8e366891697fa88c3b3d14f53dd37
+  data.tar.gz: 0cca14d03c2acb9a15c87cf6b979f61a0f8a4840f39a47860842c0ed1062b5755697e644d23efb24f8ebe92e4efe50d6883f5a5178524b84a34c0aefa0aca518

data/lib/scoutui/base/assertions.rb

@@ -13,8 +13,10 @@ module Scoutui::Base
 
     def initialize
       @assertionTypes=[
-          { :cmd => 'isEnabled',   :pattern => '^\s*[!]*isEnabled\((.*)\)\s*$'},
-          { :cmd => 'visible',     :pattern => '^\s*[!]*visible\((.*)\)\s*$'}
+          { :cmd => 'isEnabled',   :pattern => '^\s*[!]*isEnabled\((.*)\)\s*$', :parse => lambda { |_a| _parseFrameLoc('isEnabled', _a) } },
+          { :cmd => 'isSelected',  :pattern => '^\s*[!]*isSelected\((.*)\)\s*$', :parse => lambda { |_a| _parseFrameLoc('isSelected', _a) } },
+          { :cmd => 'isValue',      :pattern => '^\s*(isValue)\s*\(.*\)\s*\=\s*(.*)\s*$',   :parse => lambda { |_a| _parseWith('isValue', _a) } },
+          { :cmd => 'visible',     :pattern => '^\s*[!]*visible\((.*)\)\s*$', :parse => nil }
       ]
 
     end
@@ -26,14 +28,15 @@ module Scoutui::Base
       @assertionTypes.each do |e|
         _p=e[:pattern]
 
-        puts __FILE__ + (__LINE__).to_s + " == verify #{_p} =="
+        puts __FILE__ + (__LINE__).to_s + " == verify #{_a} matches #{_p} =="
 
         if _a.match(/#{_p}/)
+          puts __FILE__ + (__LINE__).to_s + "  matched : #{e}"
           return e
         end
       end
 
-      puts _FILE__ + (__LINE__).to_s + " => unknown command : #{_a}"
+      puts __FILE__ + (__LINE__).to_s + " => unknown command : #{_a}"
       return nil
     end
 
@@ -41,9 +44,54 @@ module Scoutui::Base
       @drv=_drv
     end
 
+    def _parseWith(_cmd, _a)
+      Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " _parseWith(#{_cmd}, #{_a})"
+      rc=nil
+
+      begin
+        _fMatch=nil
+        _expectedVal=nil
+
+        _pattern='(frame\(.*\)[\.frame\(.*\)]*)\s*,\s*(.*)\s*$'
+
+        c=_a.match(/^\s*([!]*#{_cmd})\((.*)\)\s*\=(.*)\s*$/)
+
+        if c
+          cmd = c[1].strip
+          _fMatch = c[2].match(/#{_pattern}/)
+          _expectedVal = c[3]
+        end
+
+
+        if _fMatch
+          f=c[2].strip
+
+          puts __FILE__ + (__LINE__).to_s + " arg: #{f}"
+
+          rc = { 'cmd' => cmd,
+                 'frame'    =>  _fMatch[1].strip,
+                 'locator'  =>  _fMatch[2].strip,
+                 'expected_value' => _expectedVal }
+        elsif c
+          rc = {
+              'cmd' => cmd,
+              'locator' => c[2].strip,
+              'expected_value' => _expectedVal
+          }
+        end
+
+      rescue => ex
+        ;
+      end
+
+      Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " => #{rc}"
+      rc
+    end
 
     # _a : frame(xyz).frame(123), <locator>
     def _parseFrameLoc(_cmd, _a)
+
+      Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " _parseFrameLoc(#{_cmd}, #{_a})"
       rc=nil
 
       begin
@@ -85,10 +133,6 @@ module Scoutui::Base
       _a.is_a?(String) && _a.match(/^\s*[!]*isEnabled\((.*)\)\s*$/i)
     end
 
-    def isEnabledFrameCmd?(_a)
-      _parseFrameLoc('isEnabled', _a)
-    end
-
     def isRoleCmd?(_a)
       _a.is_a?(String) && _a.match(/^\s*(isrole|role)\(.*\)\s*/i)
     end
@@ -180,19 +224,31 @@ module Scoutui::Base
 
         puts __FILE__ + (__LINE__).to_s + " #{condition} : #{obj}"
 
-        if !obj.nil?
-          if condition.match(/^\s*text/)
-            _txt = obj.text
-            Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " text : #{_txt}"
-            expected_regex = Regexp.new(expectedVal)
-            rc =  !_txt.to_s.match(expected_regex).nil?
-          elsif condition.match(/^\*value/)
-            _txt = obj.attribute('value')
-            expected_regex = Regexp.new(expectedVal)
-            rc =  !_txt.to_s.match(expected_regex).nil?
+        begin
+
+          if !obj.nil?
+            if condition.match(/^\s*text/)
+              _txt = obj.text
+              Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " text : #{_txt}"
+              expected_regex = Regexp.new(expectedVal)
+              rc =  !_txt.to_s.match(expected_regex).nil?
+            elsif condition.match(/^\s*value/)
+              _txt = obj.attribute('value')
+              Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " value : #{_txt}"
+                                                         expected_regex = Regexp.new(expectedVal)
+              rc =  !_txt.to_s.match(expected_regex).nil?
+            else
+              Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " Unknown conditon: #{condition}"
+            end
+
+            Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + "txt/val: #{_txt}  rc => #{rc}"
           end
 
-          Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + "txt/val: #{_txt}  rc => #{rc}"
+
+        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")}"
         end
 
       end
@@ -202,29 +258,47 @@ module Scoutui::Base
 
 
     def isEnabled?(my_driver, _execute_when)
-      rc=true
 
-     # _locator = _execute_when.match(/^\s*[!]*isEnabled\((.*)\)\s*$/i)[1].to_s
+      rc=true
       _locator=nil
       _obj=nil
+      _t=nil
 
-      _t = isEnabledFrameCmd?(_execute_when)
+      _assertType=isValidAssertType(_execute_when)
+      puts __FILE__ + (__LINE__).to_s + " assertType => #{_assertType}"
+      if !_assertType.nil?
+        _t = _assertType[:parse].call(_execute_when)
+      end
 
       if !_t.nil?
         _locator = _t['locator']
+        Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " locator => #{_locator}"
 
         if _t.has_key?('frame')
           Scoutui::Commands::Utils.instance.setEnableFrameSearch(_t['frame'])
         end
 
-        Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " isChecked => #{_locator}"
         _obj = Scoutui::Base::QBrowser.findElement(my_driver, _locator, Scoutui::Commands::Utils.instance.getFrameSearch(),  Scoutui::Commands::Utils.instance.getTimeout)
       else
-        Scoutui::Logger::LogMgr.instance.warn __FILE__ + (__LINE__).to_s + " invalid visible cmd: #{_execute_when}"
+        Scoutui::Logger::LogMgr.instance.warn __FILE__ + (__LINE__).to_s + " invalid assertion cmd: #{_execute_when}"
       end
 
 
-      if _obj.is_a?(Selenium::WebDriver::Element) && _t.has_key?('cmd') && !_t['cmd'].empty?
+      if _obj.is_a?(Selenium::WebDriver::Element) && _t.has_key?('cmd') && !_t['cmd'].empty? && _t['cmd'].match(/[!]*isSelected/i)
+
+        _selected = _obj.selected?
+        if _execute_when.match(/^\s*!isSelected/i) && _selected
+          Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " !isSelected(#{_locator}) : false"
+          rc=false
+        elsif _execute_when.match(/^\s*isSelected/i) && !_selected
+          Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " isSelected(#{_locator}) : false"
+          rc=false
+        end
+
+
+      ##
+      # Object must exist and be enabled to 'pass' assertion.
+      elsif _obj.is_a?(Selenium::WebDriver::Element) && _t.has_key?('cmd') && !_t['cmd'].empty? && _t['cmd'].match(/[!]*isEnabled/i)
 
         _enabled = _obj.enabled?
 
@@ -238,11 +312,20 @@ module Scoutui::Base
           rc=false
         end
 
+      elsif _t.has_key?('cmd') && !_t['cmd'].empty? && _t['cmd'].match(/[!]*isValue/i)
+        rc=false
+
+        if _obj.is_a?(Selenium::WebDriver::Element)
+          _v = _obj.attribute('value')
+          rc=!_v.match(/#{_t['expected_value']}/).nil?
+        end
+
+        Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " assert #{_t['locator']} expected: #{_t['expected_value']} with actual: #{_v} => #{rc}"
       else
         Scoutui::Logger::LogMgr.instance.warn __FILE__ + (__LINE__).to_s + " Element not found: #{_execute_when}"
       end
 
-      Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " isEnabled?(#{_execute_when}) => #{rc}"
+      Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " GeneralAssertion: #{_execute_when} => #{rc}"
       rc
     end
 

data/lib/scoutui/base/visual_test_framework.rb

@@ -322,14 +322,14 @@ module Scoutui::Base
 
       Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " processAsserts#{_execute_when}"
 
-      _executeIt=true
+      result=true
 
       if !_execute_when.nil? && _execute_when.is_a?(Array)
 
         _req = Scoutui::Utils::TestUtils.instance.getReq()
 
         _execute_when.each do |_a|
-          Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " exeucute_when => #{_a}"
+          Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " assert: => #{_a}"
 
           _rc=nil
 
@@ -343,6 +343,10 @@ module Scoutui::Base
               _rc=Scoutui::Base::Assertions.instance.isEnabled?(my_driver, _a)
             elsif _assertType[:cmd]=='visible'
               _rc=Scoutui::Base::Assertions.instance.isVisible?(my_driver, _a)
+            elsif _assertType[:cmd]=='isSelected'
+              _rc=Scoutui::Base::Assertions.instance.isEnabled?(my_driver, _a)
+            elsif _assertType[:cmd]=='isValue'
+              _rc=Scoutui::Base::Assertions.instance.isEnabled?(my_driver, _a)
             end
 
           elsif Scoutui::Base::Assertions.instance.isRoleCmd?(_a)
@@ -358,15 +362,20 @@ module Scoutui::Base
           end
 
           if !_rc.nil?
-            Scoutui::Logger::LogMgr.instance.asserts.info __FILE__ + (__LINE__).to_s + "Verify #{_a} - #{_rc}"
+            Scoutui::Logger::LogMgr.instance.asserts.info __FILE__ + (__LINE__).to_s + " Verify #{_a} - #{_rc}"
             Testmgr::TestReport.instance.getReq(_req).get_child('visible_when').add(_rc, "Verify #{_a}")
 
             Scoutui::Commands::Utils.instance.resetFrameSearch()
+
+            result=(result && _rc)
           end
 
         end
       end
 
+      Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " *************  processAsserts() => #{result}"
+      result
+
     end
 
 
@@ -789,7 +798,8 @@ module Scoutui::Base
         dut_dupes = YAML.load_stream File.read(datafile)
         valid_file=true
       rescue => ex
-        Scoutui::Logger::LogMgr.instance.fatal __FILE__ + (__LINE__).to_s + " Invalid file: #{datafile} - abort processing."
+        Scoutui::Utils::TestUtils.instance.setState(:abort, "Unable to read #{datafile}.")
+        Scoutui::Logger::LogMgr.instance.fatal __FILE__ + (__LINE__).to_s + " #{ex.class}: Invalid file: #{datafile} - abort processing."
         Scoutui::Logger::LogMgr.instance.info ex.backtrace
       end
 
@@ -1024,8 +1034,16 @@ module Scoutui::Base
 
             processExpected(my_driver, e)
 
+
             processAssertions(my_driver, e)
-            processAsserts(my_driver, e[STEP_KEY]["asserts"])
+            _assertResult=processAsserts(my_driver, e[STEP_KEY]["asserts"])
+
+            Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " ======  assertResults : #{_assertResult}"
+
+            if !_assertResult && Scoutui::Utils::TestUtils.instance.isFailFast?
+              Scoutui::Utils::TestUtils.instance.setState(:abort, 'Failed assertion with failfast enabled.')
+              return
+            end
 
             if e[STEP_KEY].has_key?('saveas')
               # processSaveAs(e)

data/lib/scoutui/eyes/eye_scout.rb

@@ -225,7 +225,7 @@ module Scoutui::Eyes
         Scoutui::Logger::LogMgr.instance.info " Eyes.TestResults.Steps      : #{@testResults.steps.to_s}"
       end
 
-      Testmgr::TestReport.instance.getReq("Execution").testcase('Status').add(!Scoutui::Utils::TestUtils.instance.abort?, "Verify execution did not abort.")
+      Testmgr::TestReport.instance.getReq("Execution").testcase('Status').add(!Scoutui::Utils::TestUtils.instance.abort?, "Verify execution did not abort. #{Scoutui::Utils::TestUtils.instance.currentMessage}")
 
       Scoutui::Logger::LogMgr.instance.info " TestReport.Tap => #{@testResults.to_json}"
 

data/lib/scoutui/utils/utils.rb

@@ -22,6 +22,7 @@ module Scoutui::Utils
 
     def initialize
 
+      @currentMessage=""
       @coverage={:pages => []}
       @final_rc=false
       @metrics=nil
@@ -56,8 +57,13 @@ module Scoutui::Utils
 
     end
 
-    def setState(s)
+    def setState(s, _d=nil)
       @execution_status=s
+      @currentMessage=_d if !_d.nil?
+    end
+
+    def currentMessage
+      @currentMessage
     end
 
     def abort?

data/lib/scoutui/version.rb

@@ -1,3 +1,3 @@
 module Scoutui
-  VERSION = "2.0.3.30.pre"
+  VERSION = "2.0.3.31.pre"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: scoutui
 version: !ruby/object:Gem::Version
-  version: 2.0.3.30.pre
+  version: 2.0.3.31.pre
 platform: ruby
 authors:
 - Peter Kim
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-07-27 00:00:00.000000000 Z
+date: 2016-07-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler