scoutui 2.0.3.50.pre → 2.0.3.51.pre

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1237be740903254cf628d515e266f53506c6c049
-  data.tar.gz: ea0fa6fb2485aa500af51535acc3a5b46759e44f
+  metadata.gz: 6c5cc805fe6fbfbc8493fbba16daf30ce96ed97a
+  data.tar.gz: 6713d51d7c4dda1a06c7ed3da8be5ab87d08eee2
 SHA512:
-  metadata.gz: 8b00bb35b19f173fe117525d9451a7f063275998c614acd58111712c5cccda67b36b18c2bb2f795ab4ae73ed7fa0288cc1f58f5c4bdbc67f9bfc6ebb012355b6
-  data.tar.gz: 31914dccf00ff3df9193732fc6c96e48f970cba2f8877acf378581c1a7f15c1cd4f271f9ce0198a5adab95ad5c8ba37d30112a55d011a6d3f5dbadf032d72b88
+  metadata.gz: 9c185fb0012d0fa6176d1112f58a41cbccadc92535803a74bf57cae78aa267656baaaf158e2165d4d574e2652ce60c5a57c88db3d9466849839663f74d70bb8a
+  data.tar.gz: 47cf0a7f0360242c67f9dadb5c36c671e4e530831f08335021356b0c14411c3a68d5ffe126f7ad18a833e664d50d008a54cf513c333fd0169ac0e8551363a648

data/lib/scoutui/appmodel/q_model.rb

@@ -71,9 +71,16 @@ module Scoutui::ApplicationModel
           Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " -- process page --"  if Scoutui::Utils::TestUtils.instance.isDebug?
           hit=@app_model[_obj]
         elsif getter.downcase=='get'
-          hit=hit[_obj]
+
+          if !hit.nil? && hit.has_key?(_obj)
+            hit=hit[_obj]
+          else
+            Scoutui::Logger::LogMgr.instance.warn __FILE__ + (__LINE__).to_s + " Missing getter : #{_obj.to_s}"
+            return nil
+          end
+
         else
-          Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " getter : #{getter} is unknown."
+          Scoutui::Logger::LogMgr.instance.warn __FILE__ + (__LINE__).to_s + " getter : #{getter} is unknown."
           return nil
         end
         Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " HIT => #{hit}" if Scoutui::Utils::TestUtils.instance.isDebug?

data/lib/scoutui/base/assertions.rb

@@ -184,7 +184,16 @@ module Scoutui::Base
     end
 
     def isVisibleCmd?(_a)
-      _a.is_a?(String) && _a.match(/^\s*[!]*visible\((.*)\)\s*$/i)
+      _a.is_a?(String) &&
+          ( _a.match(/^\s*[!]*visible\((.*)\)\s*$/i) ||
+            _a.match(/^\s*[!]*visible\((.*)?,\s*(\d+)\s*\)$/) )
+
+
+    #  if xpath.match(/^\s*!visible\((.*,\s*\d+\s*)\)$/)
+    #    _e = xpath.match(/^\s*!visible\((.*),\s*\d+\s*\)$/)[1].to_s.strip
+    #    _timeout=xpath.match(/^\s*!visible\((.*),\s*(\d+)\s*\)$/)[2].to_i
+    #  end
+
     end
 
 
@@ -438,6 +447,8 @@ module Scoutui::Base
     def isVisible?(my_driver, _execute_when, _enableAsserts=true)
       rc=true
 
+      _tm = Scoutui::Commands::Utils.instance.getTimeout
+
       begin
 
         _t = isVisibleFrameCmd?(_execute_when)
@@ -454,7 +465,13 @@ module Scoutui::Base
           end
 
         elsif isVisibleCmd?(_execute_when)
+
+          if _execute_when.match(/^\s*[!]*visible\((.*)?,\s*(\d+)\s*\)$/)
+            _locator = _execute_when.match(/^\s*[!]*visible\((.*)?,\s*(\d+)\s*\)$/)[1].to_s
+            _tm = _execute_when.match(/^\s*[!]*visible\((.*)?,\s*(\d+)\s*\)$/)[2].to_i
+          else
            _locator = _execute_when.match(/^\s*[!]*visible\((.*)\)\s*$/i)[1].to_s
+          end
 
 
            _locator = Scoutui::Base::UserVars.instance.normalize(_locator)
@@ -465,7 +482,7 @@ module Scoutui::Base
 
         Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " visible => #{_locator}"
 
-        _obj = Scoutui::Base::QBrowser.findElement(my_driver, _locator, Scoutui::Commands::Utils.instance.getFrameSearch(),  Scoutui::Commands::Utils.instance.getTimeout)
+        _obj = Scoutui::Base::QBrowser.findElement(my_driver, _locator, Scoutui::Commands::Utils.instance.getFrameSearch(),  _tm) # Scoutui::Commands::Utils.instance.getTimeout)
 
         Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " obj => #{_obj}"
 

data/lib/scoutui/base/q_browser.rb

@@ -19,10 +19,7 @@ module Scoutui::Base
       begin
         Selenium::WebDriver::Wait.new(timeout: _timeout).until {
           rc=drv.find_element(:xpath => xpath).displayed?
-
           obj=getObject(drv, obj, _timeout=nil)
-
-
         }
       rescue => ex
         ;
@@ -423,6 +420,124 @@ module Scoutui::Base
       obj
     end
 
+
+    # 5150
+    def self.findElements(opts)
+      puts __FILE__ + (__LINE__).to_s + " findElements(#{opts})"
+      driver=opts[:driver]
+      locator=opts[:locator]
+      locateBy=:xpath
+      hits=nil
+
+
+      if locator.match(/^\s*css\s*\=\s*/i)
+        locateBy = :css
+        locator = locator.match(/css\s*\=\s*(.*)/i)[1].to_s
+      elsif locator.match(/^#/i)
+        locateBy = :css
+      end
+
+      puts __FILE__ + (__LINE__).to_s + "  driver  : #{driver.class}"
+      puts __FILE__ + (__LINE__).to_s + "  locator : #{locator}"
+
+      begin
+      _timeout=Scoutui::Commands::Utils.instance.getTimeout
+      Selenium::WebDriver::Wait.new(timeout: _timeout).until { hits=driver.find_elements( locateBy => locator) }
+
+      rescue => ex
+        puts __FILE__ + (__LINE__).to_s + "  #{ex.class}"
+        puts ex.backtrace
+
+      end
+      hits
+    end
+
+    def self.hasParent?(element, parent_xpath)
+
+      parent=nil
+      if element.is_a?(Selenium::WebDriver::Element)
+        begin
+          parent = element.find_element(:xpath, parent_xpath)
+        rescue Selenium::WebDriver::Error::NoSuchElementError
+          ;
+        end
+
+      end
+
+      parent
+    end
+
+    # 5150
+    # http://stackoverflow.com/questions/14288917/selenium-webdriver-get-attributes-after-finding-an-element
+    def self.isAccessible(opts)
+
+      puts __FILE__ + (__LINE__).to_s + " == isAccessible(#{opts}) =="
+      hits = Scoutui::Base::QBrowser.findElements(opts)
+
+      puts __FILE__ + (__LINE__).to_s + " HITS => #{hits.length}"
+
+
+      i=0
+      begin
+        hits.each do | obj |
+            if obj.displayed?
+              puts __FILE__ + (__LINE__).to_s + " #{i}. #{obj.tag_name}"
+
+              tagName=obj.tag_name.to_s.strip
+
+              ## Verify labels are present for user input elements
+              if tagName.match(/(textarea|input)/) && obj.attribute('id')
+                id=obj['id'].to_s
+
+               # parent_li = obj.find_element(:xpath, './../label')
+                parent_li = Scoutui::Base::QBrowser.hasParent?(obj, "./../label[@for='#{id}']")
+
+                Testmgr::TestReport.instance.getReq('WCAG').testcase(tagName).add(!parent_li.nil?, "Verify matching label (id=#{id.to_s}) exists for #{tagName}.")
+
+                if parent_li
+                  forId = parent_li['for']
+                  puts __FILE__ + (__LINE__).to_s + "    parent: #{parent_li.tag_name}"
+                  puts __FILE__ + (__LINE__).to_s + "    assert <id, for>: #{id}, #{forId}"
+
+                  Testmgr::TestReport.instance.getReq('WCAG').testcase(tagName).add(id==forId, "Verify matching label for #{tagName} has same id (#{id}) and for (#{forId}) values")
+                else
+                  puts __FILE__ + (__LINE__).to_s + "  => Missing associated label for #{tagName}"
+                end
+
+
+              #---------------------------------------------------#
+
+              elsif tagName.match(/(img)/)
+
+                src=obj.attribute('src')
+                alt=obj.attribute('alt')
+                longdesc=obj.attribute('longdesc')
+
+                puts __FILE__ + (__LINE__).to_s + " ** #{i}. process #{tagName}  <alt, longdesc>::<#{alt.nil?}, #{longdesc.nil?}, #{src}> **"
+
+                Testmgr::TestReport.instance.getReq('WCAG').testcase(tagName).add(!(alt.nil? && longdesc.nil?), "Verify alt/longdesc (#{alt.to_s} exists for img[#{i}] (#{src})")
+
+
+              else
+                puts __FILE__ + (__LINE__).to_s + " == #{tagName} out of scope for Acccessibility"
+
+              end
+
+
+
+              i+=1
+            end
+        end
+
+      rescue => ex
+        puts __FILE__ + (__LINE__).to_s + " #{ex.class}"
+        puts ex.backtrace
+      end
+
+
+    end
+
+
     def self.findElement(drv, _locator, _frames, _timeout=nil)
 
       Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " findElement(#{_locator}, #{Scoutui::Commands::Utils.instance.getFrameSearch})"
@@ -621,6 +736,7 @@ module Scoutui::Base
         Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " By      => #{locateBy.to_s}"
         Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " Locator => #{locator}"
         Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " Visible_When => #{visible_when}"
+        Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " Timeout => #{_timeout}"
 
         Selenium::WebDriver::Wait.new(timeout: _timeout).until { rc=drv.find_element( locateBy => locator) }
 

data/lib/scoutui/base/visual_test_framework.rb

@@ -57,6 +57,10 @@ module Scoutui::Base
 
           Scoutui::Base::Assertions.instance.assertPageElement(k, page_elt, _obj, my_driver, _req)
 
+          if page_elt.has_key?('asserts')
+            Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " ** process Asserts #{page_elt['asserts']} **"
+            STDIN.gets
+          end
 
 
         elsif sub_elts > 0
@@ -108,6 +112,7 @@ module Scoutui::Base
 
               if _v.has_key?('reqid')
                 _req=_v['reqid'].to_s
+                Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " temporary update REQID to #{_req}"
               end
 
               if _v.has_key?('locator')
@@ -118,7 +123,25 @@ module Scoutui::Base
 
                 _obj = Scoutui::Base::QBrowser.getFirstObject(my_driver, _locator, Scoutui::Commands::Utils.instance.getTimeout())
 
-                Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " HIT #{_locator} => #{(!_obj.nil?).to_s}"  # if Scoutui::Utils::TestUtils.instance.isDebug?
+                Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " HIT #{_locator} => #{(!_obj.nil?).to_s}"
+              end
+
+
+              if _v.has_key?('asserts')
+                Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " ** process Asserts **"
+                _v['asserts'].each do | _ass|
+                  Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " => #{_ass}"
+                end
+
+
+                # Should be refactored (TBD)
+                _backupReq = Scoutui::Utils::TestUtils.instance.getReq()
+                Scoutui::Utils::TestUtils.instance.setReq(_req) if !_req.nil?
+
+                _assertResult=processAsserts(my_driver, _v["asserts"])
+
+                Scoutui::Utils::TestUtils.instance.setReq(_backupReq) if !_req.nil?
+
               end
 
               if Scoutui::Base::Assertions.instance.visible_when_always(_k, _v, _obj, _req)
@@ -153,9 +176,13 @@ module Scoutui::Base
 
 
                 end
+
+              else
+                Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " Unknown: #{_k} : #{_v}"
               end
 
 
+
             rescue => ex
               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")}"
@@ -186,6 +213,11 @@ module Scoutui::Base
           end
 
           # next
+
+        elsif page_elt.is_a?(Hash) && page_elt.has_key?('asserts')
+          # 5150
+          Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " ** asserts from PageElement verification **"
+          Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " =============="; STDIN.gets
         end
 
 
@@ -319,6 +351,7 @@ module Scoutui::Base
       processConditions(my_driver, e, 'assertions')
     end
 
+    # recsult=processAsserts(my_driver, e[STEP_KEY]["asserts"])
     def self.processAsserts(my_driver, _execute_when, _enableAsserts=true)
 
       Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " processAsserts#{_execute_when}"
@@ -334,34 +367,60 @@ module Scoutui::Base
 
           _rc=nil
 
+          _bm=nil
 
           _assertType=Scoutui::Base::Assertions.instance.isValidAssertType(_a)
 
-          if !_assertType.nil?
+          Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " assertType : #{_assertType}"
 
+          if !_assertType.nil?
 
             if _assertType[:cmd].match(/^\s*isEnabled\s*$/i)  # Scoutui::Base::Assertions.instance.isEnabledCmd?(_a)
-              _rc=Scoutui::Base::Assertions.instance.isEnabled?(my_driver, _a, _enableAsserts)
+
+              _bm=Benchmark.measure {
+                _rc=Scoutui::Base::Assertions.instance.isEnabled?(my_driver, _a, _enableAsserts)
+              }
+
             elsif _assertType[:cmd]=='visible'
-              _rc=Scoutui::Base::Assertions.instance.isVisible?(my_driver, _a, _enableAsserts)
+
+                _bm=Benchmark.measure {
+                  _rc=Scoutui::Base::Assertions.instance.isVisible?(my_driver, _a, _enableAsserts)
+                }
+
             elsif _assertType[:cmd]=='isSelected'
-              _rc=Scoutui::Base::Assertions.instance.isEnabled?(my_driver, _a)
+              _bm=Benchmark.measure {
+                _rc=Scoutui::Base::Assertions.instance.isEnabled?(my_driver, _a)
+              }
+
             elsif _assertType[:cmd]=='isText'
-              _rc=Scoutui::Base::Assertions.instance.isEnabled?(my_driver, _a)
+              _bm=Benchmark.measure {
+                _rc=Scoutui::Base::Assertions.instance.isEnabled?(my_driver, _a)
+              }
+
             elsif _assertType[:cmd]=='isValue'
-              _rc=Scoutui::Base::Assertions.instance.isEnabled?(my_driver, _a)
+              _bm=Benchmark.measure {
+                _rc=Scoutui::Base::Assertions.instance.isEnabled?(my_driver, _a)
+              }
             end
 
           elsif Scoutui::Base::Assertions.instance.isRoleCmd?(_a)
-            _rc=Scoutui::Base::Assertions.instance.isRole?(_a)
+            _bm=Benchmark.measure {
+              _rc=Scoutui::Base::Assertions.instance.isRole?(_a)
+            }
 #          elsif Scoutui::Base::Assertions.instance.isVisibleCmd?(_a)
 #            _rc=Scoutui::Base::Assertions.instance.isVisible?(my_driver, _a)
           elsif Scoutui::Base::Assertions.instance.isSelectedCmd?(_a)
-            _rc=Scoutui::Base::Assertions.instance.isSelected?(my_driver, _a)
+            _bm=Benchmark.measure {
+              _rc=Scoutui::Base::Assertions.instance.isSelected?(my_driver, _a)
+            }
           elsif Scoutui::Base::Assertions.instance.isValueCmd?(_a)
-            _rc=Scoutui::Base::Assertions.instance.isValue?(my_driver, _a)
+            _bm=Benchmark.measure {
+              _rc=Scoutui::Base::Assertions.instance.isValue?(my_driver, _a)
+            }
           elsif Scoutui::Base::Assertions.instance.isTitleCmd?(_a)
-            _rc=Scoutui::Base::Assertions.instance.isTitle(my_driver, _a)
+            _bm=Benchmark.measure {
+              _rc=Scoutui::Base::Assertions.instance.isTitle(my_driver, _a)
+            }
           elsif _a.match(/^\s*(req|requirement)\s*\((.*)\)\s*$/i)
 
             _reqID=_a.match(/^\s*(req|requirement)\s*\((.*)\)\s*$/i)[2].to_s
@@ -371,15 +430,45 @@ module Scoutui::Base
             Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " => #{_reqAsserts}"
 
             _req = Scoutui::Utils::TestUtils.instance.setReq(_reqID)
-            _rc=processAsserts(my_driver, _reqAsserts, _enableAsserts)
+
+            _bm=Benchmark.measure {
+              _rc=processAsserts(my_driver, _reqAsserts, _enableAsserts)
+            }
+
             Scoutui::Utils::TestUtils.instance.setReq(_req)
+
+
+          elsif !_a.match(/^page\([\w\d]+\)/).nil?
+
+            puts __FILE__ + (__LINE__).to_s + "\n\n=== Validate Page ==="
+
+            _obj = processPageElement(my_driver, nil, _a)
+
+              # 5150
+            puts __FILE__ + (__LINE__).to_s + " *** WHAT type of assertion => #{_obj}"; STDIN.gets
+
+          elsif !_a.match(/^\s*accessibility\s*$/).nil?
+            puts __FILE__ + (__LINE__).to_s + " *** Accessibility ***"
+
+
+            # 5150
+            # Get all displayed textareas
+            ['//textarea', '//img'].each do |elt_wcag|
+              Scoutui::Base::QBrowser.isAccessible({ :driver => my_driver, :locator => elt_wcag })
+            end
+
+ #          textAreas = Scoutui::Base::QBrowser.getObjects( { :driver => my_driver, :locator => '//textarea' })
           end
 
           if !_rc.nil?
 
             if _enableAsserts
               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}")
+
+
+              _testcase = Scoutui::Utils::TestUtils.instance.getTC() || "visible_when"
+
+              Testmgr::TestReport.instance.getReq(_req).get_child(_testcase).add(_rc, "Assert #{_a}", _bm.real)
             end
 
             Scoutui::Commands::Utils.instance.resetFrameSearch()
@@ -847,6 +936,7 @@ module Scoutui::Base
         _skip   = e[STEP_KEY]["skip"]
         _region = e[STEP_KEY]["region"]
         _reqid  = e[STEP_KEY]["reqid"]
+        _testcase = e[STEP_KEY]["testcase"]
         _execute_when = e[STEP_KEY]["execute_when"]
         _use_frames = e[STEP_KEY]["frames"]
 
@@ -873,6 +963,10 @@ module Scoutui::Base
           Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + "  REQID was not provided"
         end
 
+        if !(_testcase.nil? || _testcase.empty?)
+          Scoutui::Utils::TestUtils.instance.setTC(_testcase)
+        end
+
 
         if !_execute_when.nil? && !_execute_when.to_s.empty?
 
@@ -1233,6 +1327,12 @@ module Scoutui::Base
         processExpected(my_driver, e)
         processAssertions(my_driver, e)
         _assertResult=processAsserts(my_driver, e[STEP_KEY]["asserts"])   # 5150
+
+        if e[STEP_KEY].has_key?('accessible') && e[STEP_KEY]['accessible'].to_s.match(/true/)
+          Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " ** Accessibility **"
+          STDIN.gets
+        end
+
         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")

data/lib/scoutui/commands/commands.rb

@@ -102,7 +102,9 @@ module Scoutui::Commands
               _caborted=true
             end
 
-            Testmgr::TestReport.instance.getReq(_req).get_child(_cmd.downcase).add(!_caborted, "Verify command assign did not abort")
+            _testcase = Scoutui::Utils::TestUtils.instance.getTC() || _cmd.downcase
+
+            Testmgr::TestReport.instance.getReq(_req).get_child(_testcase).add(!_caborted, "Assert command assign did not abort")
           end
         end
 

data/lib/scoutui/commands/select_object.rb

@@ -8,6 +8,8 @@ module Scoutui::Commands
 
     def execute(drv, e=nil)
 
+      _seekTime={ :start => 0, :end => 0 }
+
       Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " SelectObject.execute(#{e})"
       @drv=drv if !drv.nil?
 
@@ -30,7 +32,9 @@ module Scoutui::Commands
             puts __FILE__ + (__LINE__).to_s + " frames => #{e['page']['frames']}";
           end
 
+          _seekTime[:start]=Time.now
           obj = Scoutui::Base::QBrowser.findElement(@drv, _xpath, Scoutui::Commands::Utils.instance.getFrameSearch(),  Scoutui::Commands::Utils.instance.getTimeout)
+          _seekTime[:end]=Time.now
 
 
           if !obj.nil? && obj.tag_name.downcase.match(/(select)/)
@@ -57,8 +61,8 @@ module Scoutui::Commands
         Scoutui::Logger::LogMgr.instance.debug "Backtrace:\n\t#{ex.backtrace.join("\n\t")}"
       end
 
-      Testmgr::TestReport.instance.getReq(_req).testcase('select').add(!obj.nil?, "Verify object to select exists #{_xpath} : #{obj.class.to_s}")
-      Testmgr::TestReport.instance.getReq(_req).testcase('select').add(_rc, "Verify selected text #{_val}")
+      Testmgr::TestReport.instance.getReq(_req).testcase('select').add(!obj.nil?, Scoutui::Base::UserVars.instance.normalize("Verify object to select exists #{_xpath} : #{obj.class.to_s}"), _seekTime[:end] - _seekTime[:start])
+      Testmgr::TestReport.instance.getReq(_req).testcase('select').add(_rc, Scoutui::Base::UserVars.instance.normalize("Verify selected text #{_val}"))
       setResult(_rc)
 
     end

data/lib/scoutui/commands/type.rb

@@ -52,6 +52,8 @@ module Scoutui::Commands
     def execute(drv=nil, pageElt=nil)
       @drv=drv if !drv.nil?
 
+      _tm={:start => 0, :end => 0 }
+
       _isKb=false
       _rc=false
       _req = Scoutui::Utils::TestUtils.instance.getReq()
@@ -83,8 +85,12 @@ module Scoutui::Commands
 
           Scoutui::Logger::LogMgr.instance.commands.debug __FILE__ + (__LINE__).to_s + "Process TYPE #{_val} into  #{_xpath}"
 
+          _tm[:start]=Time.now
+
           obj = Scoutui::Base::QBrowser.getElement(@drv, _xpath, Scoutui::Commands::Utils.instance.getFrameSearch(),  Scoutui::Commands::Utils.instance.getTimeout)
 
+          _tm[:end]=Time.now
+
           Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " type(#{_val})"
           Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " tag : #{obj.tag_name}" if obj.is_a?(Selenium::WebDriver::Element)
 
@@ -107,6 +113,9 @@ module Scoutui::Commands
                   end
                   true if obj.displayed?
                 }
+
+                _tm[:end]=Time.now
+
               rescue Selenium::WebDriver::Error::TimeOutError => ex
                 Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " Timeout waiting for display?: #{_xpath}"
               end
@@ -119,6 +128,7 @@ module Scoutui::Commands
               (0..3).each do |j|
                 if Scoutui::Base::QBrowser.isStale?(obj)
                   obj = Scoutui::Base::QBrowser.getElement(@drv, _xpath, Scoutui::Commands::Utils.instance.getFrameSearch(),  Scoutui::Commands::Utils.instance.getTimeout)
+                  _tm[:end]=Time.now
                 else
                   break
                 end
@@ -181,12 +191,14 @@ module Scoutui::Commands
                       _inRow=0
                       sleep 0.5
                       obj = Scoutui::Base::QBrowser.getElement(@drv, _xpath, Scoutui::Commands::Utils.instance.getFrameSearch(),  Scoutui::Commands::Utils.instance.getTimeout)
+                      _tm[:end]=Time.now
                     else
                       _inRow+=1
 
                       break if _inRow >= 3
 
                       obj = Scoutui::Base::QBrowser.getElement(@drv, _xpath, Scoutui::Commands::Utils.instance.getFrameSearch(),  Scoutui::Commands::Utils.instance.getTimeout)
+                      _tm[:end]=Time.now
                     end
 
                   end
@@ -242,8 +254,8 @@ module Scoutui::Commands
 
 
       if !_isKb
-        Testmgr::TestReport.instance.getReq(_req).testcase('type').add(!obj.nil?, "Verify object #{_xpath} to type #{_val} exists : #{obj.class.to_s}")
-        Testmgr::TestReport.instance.getReq(_req).testcase('type').add(_rc, "Verify typed data #{_rc}", (_endTime - _startTime))
+        Testmgr::TestReport.instance.getReq(_req).testcase('type').add(!obj.nil?, Scoutui::Base::UserVars.instance.normalize("Verify object #{_xpath} to type #{_val} exists : #{obj.class.to_s}"), _tm[:end]-_tm[:start])
+        Testmgr::TestReport.instance.getReq(_req).testcase('type').add(_rc, Scoutui::Base::UserVars.instance.normalize("Verify typed data #{_rc}"), (_endTime - _startTime))
       end
 
       setResult(_rc)

data/lib/scoutui/commands/update_url.rb

@@ -6,6 +6,8 @@ module Scoutui::Commands
     def execute(drv, _e=nil)
       @drv=drv if !drv.nil?
 
+      _duration=nil
+
       _req = Scoutui::Utils::TestUtils.instance.getReq()
 
       baseUrl = Scoutui::Base::UserVars.instance.getHost()
@@ -48,6 +50,11 @@ module Scoutui::Commands
       end
 
 
+      _testcase = Scoutui::Utils::TestUtils.instance.getTC() || "navigate"
+
+      Testmgr::TestReport.instance.getReq(_req).testcase(_testcase).add(_rc, Scoutui::Base::UserVars.instance.normalize("Verify navigate to url #{normUrl}"), _duration)
+
+
       setResult(_rc)
 
     end

data/lib/scoutui/commands/utils.rb

@@ -153,6 +153,8 @@ module Scoutui::Commands
 
     def reset(stanza=nil)
 
+      Scoutui::Utils::TestUtils.instance.setTC(nil)
+
       setEnableFrameSearch(false)
 
       if stanza.is_a?(Hash) && stanza.has_key?('page') && stanza['page'].has_key?('frames')

data/lib/scoutui/utils/utils.rb

@@ -111,10 +111,18 @@ module Scoutui::Utils
       @currentTest[:reqid]
     end
 
+    def getTC()
+      @currentTest[:testcase]
+    end
+
     def setReq(_r='UI')
       @currentTest[:reqid]=_r
     end
 
+    def setTC(_tc=nil)
+      @currentTest[:testcase]=_tc
+    end
+
     def loadModel(f=nil)
       if f.nil?
         return nil

data/lib/scoutui/version.rb

@@ -1,3 +1,3 @@
 module Scoutui
-  VERSION = "2.0.3.50.pre"
+  VERSION = "2.0.3.51.pre"
 end

metadata

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