scoutui 2.0.1 → 2.0.2

data/examples/ex2/tests/test-example3.sauce.sh

@@ -0,0 +1,77 @@
+#/bin/bash
+##
+# Description
+#   This test script overrides the provided title and appname (if provided in the test config. file)
+#
+# Set the APPLITOOLS_API_KEY environment variable with your key.
+#
+#          export APPLITOOLS_API_KEY="__YOUR_KEY_HERE__"
+##
+export SCOUTUI_BIN=../../../bin/scoutui_driver.rb
+# Specify browser under test  (chrome, firefox, ie, safari)
+BUT=firefox
+
+# Specify the title and appName needed by Applitools
+## NOTE:  If the test configuration file specifies the title and app, it is superseded by the
+##        command line options.
+TITLE=Carmax_Ex3
+APP=Oct2015
+
+# Specify the test configuration file
+TEST_CFG="../test-configs/test.config.json"
+
+##
+# content
+# strict
+# exact
+# layyout
+##
+MATCH_TYPE="layout"
+
+
+
+sauce_eyes() {
+
+
+
+
+    ./run-test.sh  -b chrome -d ../commands/commands.yml \
+                       -P ../appmodel/page_model.json \
+                       -t ../test-configs/test.config.json  \
+                       -v  \
+                       -A STP_Example \
+                       -T VH \
+                       -O /tmp/vt \
+                       -e \
+                       -m content \
+                       -s \
+                       -S $TITLE \
+                       -c ../../capabilities/win10.chrome46.json
+}
+
+
+sauce() {
+
+    ./run-test.sh  -b chrome -d ../commands/commands.yml \
+                   -P ../appmodel/page_model.json \
+                   -t ../test-configs/test.config.json  \
+                   -v  \
+                   -s \
+                   -w 5 \
+                   -S $TITLE \
+                   -c ../../capabilities/win10.chrome46.json
+}
+
+
+local() {
+
+    ./run-test.sh  -b chrome -d ../commands/commands.yml \
+                   -P ../appmodel/page_model.json \
+                   -t ../test-configs/test.config.json  \
+                   -v  \
+                   -w 5 \
+                   -c ../../capabilities/win10.chrome46.json
+
+}
+
+sauce

data/examples/ex2/tests/test-example3.sh

@@ -0,0 +1,41 @@
+#/bin/bash
+##
+# Description
+#   This test script overrides the provided title and appname (if provided in the test config. file)
+#
+# Set the APPLITOOLS_API_KEY environment variable with your key.
+#
+#          export APPLITOOLS_API_KEY="__YOUR_KEY_HERE__"
+##
+export SCOUTUI_BIN=../../../bin/scoutui_driver.rb
+# Specify browser under test  (chrome, firefox, ie, safari)
+BUT=firefox
+
+# Specify the title and appName needed by Applitools
+## NOTE:  If the test configuration file specifies the title and app, it is superseded by the
+##        command line options.
+TITLE=DEMO-CarMax
+APP=Oct2015
+
+# Specify the test configuration file
+TEST_CFG="../test-configs/test.config.json"
+
+##
+# content
+# strict
+# exact
+# layyout
+##
+MATCH_TYPE="layout"
+
+EYES=--eyes
+EYES=
+
+
+# The following command line parameters will override provided title and appName (if provided in test config file)
+#$SCOUTUI_BIN  --config $TEST_CFG  --browser $BUT $EYES --app $APP --title $TITLE  --match $MATCH_TYPE --pagemodel ../appmodel/page_model.json  --debug
+
+# The following
+# $SCOUTUI_BIN --config $TEST_CFG  --eyes  --match $MATCH_TYPE  --browser $BUT
+
+./run-test.sh -b chrome -d ../commands/commands.yml -P ../appmodel/page_model.json -t ../test-configs/test.config.json  -w 5 -v

data/lib/scoutui/appmodel/q_model.rb

@@ -49,6 +49,11 @@ module Scoutui::ApplicationModel
     # getPageElement("page(login).get(login_form).get(button)")
     def getPageElement(s)
       Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " getPageElement(#{s})"
+
+      if s.match(/^\s*\//) || s.match(/^\s*css\s*=/i)
+        return nil
+      end
+
       hit=@app_model
 
       nodes = s.split(/\./)
@@ -75,6 +80,106 @@ module Scoutui::ApplicationModel
 
     end
 
+
+
+    # visible_when: hover(page(x).get(y).get(z))
+    def itemize(condition='visible_when', _action='hover', _pgObj=nil)
+      @results=hits(nil, @app_model, condition, _action, _pgObj)
+
+      puts "[itemize] => #{@results}"
+
+      @results
+    end
+
+
+    def hits(parent, h, condition, _action, pg)
+      #  puts __FILE__ + (__LINE__).to_s + " collect_item_attributes(#{h})"
+      result = []
+
+
+      if h.is_a?(Hash)
+
+        h.each do |k, v|
+          puts __FILE__ + (__LINE__).to_s + " Key: #{k} => #{v}"
+          if k == condition
+            #  h[k].each {|k, v| result[k] = v } # <= tweak here
+            if !v.is_a?(Array) && v.match(/^\s*#{_action}\s*\((.*)\)\s*$/i)
+
+              pageObject=v.match(/^\s*#{_action}\s*\((.*)\)\s*$/i)[1]
+
+              puts __FILE__ + (__LINE__).to_s + " <pg, pageObject> : <#{pg}, #{pageObject}>"
+              #         result[k] = v
+
+              #          puts '*******************'
+              #          puts __FILE__ + (__LINE__).to_s + " HIT : #{h[k]}"
+              #          result << { h[k] => v }
+
+              if pg.nil?
+                result << parent
+              elsif pg == pageObject
+                result << parent
+
+              end
+
+            elsif v.is_a?(Array)
+
+              v.each do |vh|
+                puts " =====> #{vh}"
+
+                if vh.is_a?(Hash) && vh.has_key?(condition) && vh[condition].match(/^\s*#{_action}\s*/i)
+
+                  pageObject=vh[condition].match(/^\s*#{_action}\s*\((.*)\)\s*$/i)[1]
+
+
+                  puts __FILE__ + (__LINE__).to_s + " matched on #{_action}, pg:#{pg}, #{pageObject}"
+
+                  if pg.nil?
+                    result << parent
+                  elsif pg == pageObject
+                    result << parent
+                  end
+
+                end
+
+              end
+
+            end
+
+          elsif v.is_a? Hash
+            if parent.nil?
+              _rc = hits("page(#{k})", h[k], condition, _action, pg)
+            else
+              _rc = hits("#{parent}.get(#{k})", h[k], condition, _action, pg)
+            end
+
+
+            if !(_rc.nil? || _rc.empty?)
+
+
+              result << _rc
+
+              puts __FILE__ + (__LINE__).to_s + " ADDING  #{k} : #{_rc}"
+              #           puts "====> #{k} : #{_rc.class} : #{_rc.length}"
+
+
+              result.flatten!
+            end
+
+
+          end
+        end
+
+      end
+
+
+
+      result=nil if result.empty?
+      puts __FILE__ + (__LINE__).to_s + " result : #{result}"
+      result
+    end
+
+
+
   end
 
 

data/lib/scoutui/base/assertions.rb

@@ -15,44 +15,604 @@ module Scoutui::Base
       @drv=_drv
     end
 
+
+    def assertPage(my_driver, _pg, _req=nil)
+      if _req.nil?
+        _req = Scoutui::Utils::TestUtils.instance.getReq()
+      end
+
+      if !_pg.match(/^page\([\w\d]+\)/).nil?
+
+
+        # Check if this is a form
+
+        page_elt = Scoutui::Utils::TestUtils.instance.getPageElement(_pg)
+        Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " Process page request #{page_elt} => #{page_elt.class.to_s}" if Scoutui::Utils::TestUtils.instance.isDebug?
+
+        sub_elts=0
+        if page_elt.is_a?(Hash)
+          sub_elts = page_elt.select { |_s| page_elt[_s].has_key?("locator") if page_elt[_s].is_a?(Hash) &&  !page_elt[_s].nil?  }.size
+        else
+          Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " Process an element (#{page_elt})"
+        end
+
+        Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " SubElts => #{sub_elts}" if Scoutui::Utils::TestUtils.instance.isDebug?
+
+        ##
+        # Check if this is a single element.
+        ##
+        if page_elt.is_a?(Hash) && page_elt.has_key?('locator')
+
+          ##
+          # expected:
+          #   wait: page(abc).get(def)    where this page_elt has "locator"
+
+          xpath = page_elt['locator'].to_s
+          Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " Verify #{page_elt['locator']}"
+
+        elsif sub_elts > 0
+          ##
+          # This pageobject consists of multiple pageobjects.
+          ##
+          Scoutui::Utils::TestUtils.instance.addPageCoverage(_pg)
+
+          Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " Validate form"
+
+          page_elt.each_pair do |_k, _v|
+
+            begin
+
+              Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " k,v :: #{_k.to_s}, #{_v.to_s}  (#{_v.class.to_s})" if Scoutui::Utils::TestUtils.instance.isDebug?
+
+              _obj=nil
+
+
+              if _v.is_a?(String)
+                puts __FILE__ + (__LINE__).to_s + " #{_v} is a string - next"
+                puts __FILE__ + (__LINE__).to_S + " Pause", gets
+                next
+              end
+
+              if _v.has_key?('assert_when') && _v['assert_when'].match(/role\s*\=/i)
+                _role = _v['assert_when'].match(/role\s*\=(.*)/i)[1].to_s
+                _expected_role = Scoutui::Utils::TestUtils.instance.getRole()
+
+                Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " Trigger: expected : #{_expected_role.to_s}, actual: #{_role.to_s}" if Scoutui::Utils::TestUtils.instance.isDebug?
+
+                if !_expected_role.nil? && !_role.match(/#{_expected_role}/i)
+                  Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " Skip assertion since conditional assertion #{_v['assert_when']} not met" if Scoutui::Utils::TestUtils.instance.isDebug?
+                  next
+                elsif _expected_role.nil?
+                  Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " Skip role based assertion since role was not provided" if Scoutui::Utils::TestUtils.instance.isDebug?
+                  next
+                end
+                Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " Verify object exists since the role #{_role} matches expected role #{_expected_role.to_s}" if Scoutui::Utils::TestUtils.instance.isDebug?
+              end
+
+
+              if Scoutui::Base::Assertions.instance.visible_when_skip(_k, _v)
+                Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " SKIP #{_k.to_s} - #{_v.to_s}" if Scoutui::Utils::TestUtils.instance.isDebug?
+                next
+              end
+
+              if _v.has_key?('locator')
+                _locator = _v['locator'].to_s
+                Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " " + _k.to_s + " => " + _locator
+
+                #  _locator = Scoutui::Utils::TestUtils.instance.getPageElement(_v['locator'])
+
+                _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?}"
+              end
+
+              if Scoutui::Base::Assertions.instance.visible_when_always(_k, _v, _obj, _req)
+                next
+              elsif _v.has_key?('visible_when')
+
+                if _v['visible_when'].match(/always/i)
+                  Scoutui::Logger::LogMgr.instance.asserts.info __FILE__ + (__LINE__).to_s + " Verify #{_k} - #{_locator} visible - #{!_obj.nil?.to_s}"
+
+                  if Scoutui::Utils::TestUtils.instance.assertExpected?
+                    Testmgr::TestReport.instance.getReq(_req).get_child('visible_when').add(!_obj.nil?, "Verify #{_k} - #{_locator} visible")
+                  end
+
+
+
+                elsif assertPageElement(_k, _v, _obj, my_driver, _req)
+                  puts __FILE__ + (__LINE__).to_s + " Processed assertPageElement(#{_k}, #{_v})"; # gets
+                  ;
+#               elsif visible_when_title(_k, _v, _obj, my_driver, _req)
+#                 ;
+
+#               elsif _v['visible_when'].match(/never/i)
+#                 Scoutui::Logger::LogMgr.instance.asserts.info "Verify #{_k} #{_locator} never visible - #{obj.nil?.to_s}"
+#                 Testmgr::TestReport.instance.getReq(_req).get_child('visible_when').add(obj.nil?, "Verify #{_k} #{_locator} not visible")
+
+                elsif _v['visible_when'].match(/role\=/i)
+                  _role = _v['visible_when'].match(/role\=(.*)/i)[1].to_s
+                  _expected_role = Scoutui::Utils::TestUtils.instance.getRole()
+
+                  Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " Verify object exists if the role #{_role} matches expected role #{_expected_role.to_s}" if Scoutui::Utils::TestUtils.instance.isDebug?
+
+                  if _role==_expected_role.to_s
+                    Scoutui::Logger::LogMgr.instance.asserts.info "Verify #{_k} #{_locator}  visible when role #{_role} - #{!_obj.nil?.to_s}"
+
+                    if Scoutui::Utils::TestUtils.instance.assertExpected?
+                      Testmgr::TestReport.instance.getReq(_req).get_child('visible_when').add(!_obj.nil?, "Verify #{_k} #{_locator}  visible when role #{_role}")
+                    end
+
+                  end
+
+                end
+              end
+
+
+            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")}"
+            end
+
+
+          end
+
+          return
+
+
+        elsif xpath.is_a?(Hash)
+          xpath.each_pair do |_k, _v|
+
+            Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " k,v :: #{_k.to_s}, #{_v.to_s}"
+
+            if _v.has_key?('locator')
+              _locator = _v['locator'].to_s
+              Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " " + _k.to_s + " => " + _locator
+
+              #  _locator = Scoutui::Utils::TestUtils.instance.getPageElement(_v['locator'])
+
+              _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?}"
+            end
+
+          end
+
+#          next
+        end
+
+
+      end
+
+      puts __FILE__ + (__LINE__).to_s + " Pause debug"; gets
+    end
+
+    #
+    # { reqid : <pageElt> }
+    def isVisible(my_driver, page_elt, _req=nil, _immediate=false)
+      if _req.nil?
+        _req = Scoutui::Utils::TestUtils.instance.getReq()
+      end
+
+      puts __FILE__ + (__LINE__).to_s + " [isVisible]: #{page_elt}, req:#{_req}"
+
+      rc=false
+      cmd='visible'
+      _processed=false
+
+
+
+      pageObject=page_elt
+
+      if page_elt.is_a?(String) && page_elt.match(/^\s*(text|value)\s*\(/)
+        #
+        # text(page(home).get(elt))
+        # value(page(home).get(elt))
+        #
+        _processed=true
+        condition = page_elt.match(/(value|text)\((.*)\)/)[1].to_s
+        tmpObj = page_elt.match(/(value|text)\((.*)\)/)[2].to_s
+        expectedVal = page_elt.match(/(value|text)\s*\(.*\)\s*\=\s*(.*)/)[2].to_s
+
+        xpath = Scoutui::Base::UserVars.instance.get(tmpObj)
+
+        Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " locator : #{xpath}"; #gets
+
+        obj = Scoutui::Base::QBrowser.getObject(my_driver, xpath, Scoutui::Commands::Utils.instance.getTimeout)
+
+        puts __FILE__ + (__LINE__).to_s + " #{condition} : #{obj}"
+
+        if condition.match(/^text/)
+          _txt = obj.text
+
+          expected_regex = Regexp.new(expectedVal)
+          rc =  _!txt.to_s.match(expected_regex).nil?
+          return rc
+        end
+
+
+      elsif page_elt.is_a?(String) && page_elt.match(/^\s*(url)\s*\((.*)\)/)
+
+        current_url = my_driver.current_url.to_s
+        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}"
+
+        expected_regex = Regexp.new(expected_url)
+        rc=!current_url.match(expected_regex).nil?
+
+        Scoutui::Logger::LogMgr.instance.debug  __FILE__ + (__LINE__).to_s + " verify current url #{current_url} matches #{rc}"
+
+        return rc
+
+      elsif page_elt.is_a?(String) && page_elt.match(/^\s*(visible)\((.*)\)/)
+        #
+        # visible(page(home).get(elt))
+        #
+        _processed=true
+        cmd = page_elt.match(/(visible)\((.*)\)/)[1].to_s
+        page_elt = page_elt.match(/(visible)\((.*)\)/)[2].to_s
+
+        if !page_elt.match(/\$\{.*\}/).nil?
+          page_elt = Scoutui::Base::UserVars.instance.normalize(page_elt)
+        end
+      end
+
+      if cmd=='visible' && page_elt.is_a?(String) && page_elt.match(/^\s*page\s*\(/)
+
+        Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " Process PageElement #{page_elt}"
+        pageObject = Scoutui::Utils::TestUtils.instance.getPageElement(page_elt)
+
+      elsif !Scoutui::Commands::Utils.instance.isCSS(page_elt).nil?
+        pageObject={ 'locator' => Scoutui::Commands::Utils.instance.isCSS(page_elt) }
+      elsif cmd=='visible' && page_elt.is_a?(String) && page_elt.match(/^\s*\//)
+        pageObject={ 'locator' => page_elt }
+      else
+        Scoutui::Logger::LogMgr.instance.warn __FILE__ + (__LINE__).to_s + " [isVisible]:unknown command"
+      end
+
+      if cmd=='visible' && pageObject.is_a?(Hash) && pageObject.has_key?('locator')
+
+        _processed=true
+        ##
+        # expected:
+        #   wait: page(abc).get(def)    where this page_elt has "locator"
+
+        locator = pageObject['locator'].to_s
+
+        _obj = Scoutui::Base::QBrowser.getFirstObject(my_driver, locator, Scoutui::Commands::Utils.instance.getTimeout)
+
+        if cmd=='visible'
+          if !_obj.nil?
+            rc=_obj.displayed?
+          end
+
+          if _immediate
+
+            Scoutui::Logger::LogMgr.instance.debug " return immediate (#{rc})"
+            return rc
+          end
+
+          Scoutui::Logger::LogMgr.instance.asserts.info "Verify #{page_elt} is visible - #{rc}"
+          Testmgr::TestReport.instance.getReq(_req).get_child('visible').add(rc, "Verify #{page_elt} is visible")
+        end
+
+        ## TITLE
+      elsif page_elt.is_a?(String) && page_elt.match(/\s*(title)\s*\(\s*(.*)\s*\)/)
+        _processed=true
+        current_title = my_driver.title.strip
+
+        _t = page_elt.match(/\s*title\s*\(\s*(.*)\s*\)/)[1].to_s
+
+        expected_title = Regexp.new(_t)
+        rc=!current_title.match(expected_title).nil?
+
+        Scoutui::Logger::LogMgr.instance.asserts.info "Verify current title, #{current_title}, matches #{expected_title})"
+        Testmgr::TestReport.instance.getReq(_req).get_child('title').add(rc, "Verify current title, #{current_title}, matches #{expected_title}")
+
+      elsif pageObject.is_a?(Hash)
+        Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " == Verify Page page_elt:#{page_elt}  pageObject:#{pageObject} req:#{_req} =="
+        assertPage(my_driver, page_elt, _req)
+      end
+
+      rc
+
+     end
+
     # { "visible_when" => "always" }
-    def visible_when_always(_k, _v, _obj=nil)
+    def visible_when_always(_k, _v, _obj=nil, _req='UI')
+
+      if _v.is_a?(Hash) && _v.has_key?('reqid')
+        _req = _v['reqid']
+      end
 
+      Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " visible_when_always(#{_k}, #{_v}, #{_obj}, #{_req})"
       _locator=nil
       rc=false
-      if _v.has_key?('locator')
+
+      if _v.is_a?(Hash) && _v.has_key?('visible_when') && _v['visible_when'].is_a?(Array)
+        Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " visible_when_always (array) - TBD"
+        return rc
+      end
+
+      if _v.is_a?(Hash) && _v.has_key?('locator')
         _locator = _v['locator'].to_s
       end
 
+      if _v.is_a?(Hash) && _v.has_key?('reqid')
+        _req = _v['reqid']
+      end
+
       if !_locator.nil? &&  _v.has_key?('visible_when') && _v['visible_when'].match(/always/i)
-          Scoutui::Logger::LogMgr.instance.info "Verify #{_k} - #{_locator} always visible - #{!_obj.nil?.to_s}"
-          Testmgr::TestReport.instance.getReq('UI').get_child('visible_when').add(!_obj.nil?, "Verify #{_k} - #{_locator} always visible")
+          Scoutui::Logger::LogMgr.instance.asserts.info "Verify #{_k} - #{_locator} always visible - #{(!_obj.nil?).to_s}"
+          Testmgr::TestReport.instance.getReq(_req).get_child('visible_when').add(!_obj.nil?, "Verify #{_k} - #{_locator} always visible")
+          rc=true
+      end
+      rc
+    end
+
+    def visible_when_title(_k, page_elt, _obj, my_driver, _req='UI')
+      _processed=false
+
+      if page_elt.is_a?(Hash) && page_elt.has_key?('reqid')
+        _req = page_elt['reqid']
+      end
+
+      Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " visible_when_title(#{_k}, #{page_elt}, #{_obj}, #{_req})"
+      _req='UI' if _req.nil? || _req.empty?
+
+      if page_elt.is_a?(Hash) && page_elt.has_key?('visible_when') && !page_elt['visible_when'].is_a?(Array)  && page_elt['visible_when'].match(/title\(/i)
+        _processed=true
+
+        current_title = my_driver.title.strip
+
+        _t = page_elt['visible_when'].match(/title\((.*)\)/)[1].to_s
+
+        expected_title = Regexp.new(_t)
+        rc=!current_title.match(expected_title).nil?
+
+
+        Scoutui::Logger::LogMgr.instance.asserts.info "Verify #{_k} - object exists when expected title, #{expected_title}, matches actual title(#{current_title})"
+        Testmgr::TestReport.instance.getReq(_req).get_child('visible_when').add(!_obj.nil? == rc, "Verify #{_k} - object exists when expected title, #{expected_title}, matches actual title(#{current_title}) - #{rc}")
+
+
+      end
+
+      _processed
+    end
+
+    def visible_when_never(_k, _v, _obj=nil, _req='UI')
+      if _v.is_a?(Hash) && _v.has_key?('reqid')
+        _req = _v['reqid']
+      end
+      Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " visible_when_never(#{_k}, #{_v}, #{_obj}, #{_req})"
+      _locator=nil
+      rc=false
+
+      if  _v.has_key?('locator')
+        _locator=_v['locator']
+      end
+
+      if !_locator.nil? &&  _v.has_key?('visible_when')
+
+        if _v['visible_when'].is_a?(Array)
+          Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " visible_when_never (array) - TBD"
+
+        elsif  _v['visible_when'].match(/never/i)
+          Scoutui::Logger::LogMgr.instance.asserts.info "Verify #{_k} #{_locator} never visible - #{_obj.nil?.to_s}"
+          Testmgr::TestReport.instance.getReq(_req).get_child('visible_when').add(_obj.nil?, "Verify #{_k} #{_locator} never visible")
           rc=true
+        end
+
       end
+
       rc
     end
 
+
     # { "visible_when" => true }
     def visible_when_skip(_k, _v)
 
-      Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " visible_when_visible : #{_v.to_s}" if Scoutui::Utils::TestUtils.instance.isDebug?
+      Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " visible_when_skip : #{_v.to_s}" if Scoutui::Utils::TestUtils.instance.isDebug?
       rc=false
 
-      if _v.is_a?(Hash) && _v.has_key?('visible_when') && _v['visible_when'].match(/skip/i)
-        rc=true
+      if _v.is_a?(Hash) && _v.has_key?('visible_when')
+
+        if _v['visible_when'].is_a?(Array)
+          Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " visible_when_skip (array) - TBD"
+
+        elsif _v['visible_when'].match(/skip/i)
+          rc=true
+
+          Scoutui::Logger::LogMgr.instance.asserts.info "Skip verify #{_k.to_s} - skipped"
+          Testmgr::TestReport.instance.getReq('UI').get_child('visible_when').add(nil, "Skip verify #{_k.to_s}")
+        end
 
-        Scoutui::Logger::LogMgr.instance.asserts.info "Skip verify #{_k.to_s} - skipped"
-        Testmgr::TestReport.instance.getReq('UI').get_child('visible_when').add(nil, "Skip verify #{_k.to_s}")
       end
 
       rc
     end
 
+
+
+    def visible_when_value(_k, page_elt, my_driver, _req='UI')
+      if page_elt.is_a?(Hash) && page_elt.has_key?('reqid')
+        _req = page_elt['reqid']
+      end
+      Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " visible_when_value(#{_k}, #{page_elt}, #{_req})"
+
+      _processed=false
+
+
+
+      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]}"
+
+          _processed=true
+          rc=nil
+
+          condition = page_elt['visible_when'].match(/(value|text)\((.*)\)/)[1].to_s
+          tmpObj = page_elt['visible_when'].match(/(value|text)\((.*)\)/)[2].to_s
+          expectedVal = page_elt['visible_when'].match(/(value|text)\s*\(.*\)\s*\=\s*(.*)/)[2].to_s
+
+
+
+          Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " #{condition} => #{tmpObj} with expected value #{expectedVal}"
+
+          xpath = Scoutui::Base::UserVars.instance.get(tmpObj)
+
+          obj = Scoutui::Base::QBrowser.getObject(my_driver, xpath, Scoutui::Commands::Utils.instance.getTimeout)
+
+          if !obj.nil?
+            #  Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " value : #{obj.value.to_s}"
+            Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " text  : #{obj.text.to_s}"
+
+            if obj.tag_name.downcase.match(/(select)/)
+              _opt = Selenium::WebDriver::Support::Select.new(obj)
+              opts = _opt.selected_options
+              Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " selected => #{opts.to_s}"
+
+
+
+              opts.each do |o|
+                Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + "| <v, t>::<#{o.attribute('value').to_s},  #{o.text.to_s}>"
+
+                desc=nil
+
+
+                if condition=='text' && o.text==expectedVal
+                  desc=" Verify #{_k}, #{locator}, is visible since condition (#{condition} #{xpath} is met."
+                elsif condition=='value' && o.attribute('value').to_s==expectedVal
+                  desc=" Verify #{_k}, #{locator}, is visible since #{condition} of #{xpath} is #{expectedVal}"
+                end
+
+                if !desc.nil?
+                  locatorObj = Scoutui::Base::QBrowser.getObject(my_driver, locator, Scoutui::Commands::Utils.instance.getTimeout)
+
+                  Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " LocatorObj : #{locatorObj} : #{!locatorObj.nil? && locatorObj.displayed?}"
+
+
+                  Testmgr::TestReport.instance.getReq('UI').tc('visible_when').add(!locatorObj.nil? && locatorObj.displayed?, desc)
+                end
+
+              end
+
+            else
+
+              desc=nil
+
+              locator = page_elt['locator']
+
+              _rc=false
+
+              if condition=='text'
+                _rc=obj.text==expectedVal
+                desc=" Verify #{_k}, #{locator}, is visible since condition '#{condition}' of #{xpath} is #{expectedVal}."
+              elsif condition=='value'
+                _rc=o.attribute('value').to_s==expectedVal
+                desc=" Verify #{_k}, #{locator}, is visible since condition '#{condition}' of #{xpath} is #{expectedVal}"
+              end
+
+              if !desc.nil?
+                locatorObj = Scoutui::Base::QBrowser.getObject(my_driver, locator, Scoutui::Commands::Utils.instance.getTimeout)
+
+                Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + "#{desc} : #{locatorObj} : #{!locatorObj.nil? && locatorObj.displayed? && _rc}"
+
+
+                Testmgr::TestReport.instance.getReq(_req).get_child('visible_when').add(!locatorObj.nil? && locatorObj.displayed? && _rc, desc)
+              end
+
+
+            end
+
+            Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " value : #{obj.attribute('value').to_s}"
+          end
+
+
+        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")}"
+
+        end
+
+
+#      elsif page_elt.has_key?('visible_when') &&  page_elt['visible_when'].match(/\s*(text|value)\s*\(/)
+#        Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " Unknown => #{page_elt}"
+
+      end
+
+      _processed
+
+    end
+
+
+
+    def assertPageElement(_k, _v, _obj, my_driver, _req)
+
+      _processed = true
+
+      if Scoutui::Base::Assertions.instance.visible_when_always(_k, _v, _obj, _req)
+        ;
+      elsif Scoutui::Base::Assertions.instance.visible_when_never(_k, _v, _obj, _req)
+        ;
+      elsif Scoutui::Base::Assertions.instance.visible_when_title(_k, _v, _obj, my_driver, _req)
+        ;
+      elsif Scoutui::Base::Assertions.instance.visible_when_value(_k, _v, my_driver, _req)
+        ;
+      elsif Scoutui::Base::Assertions.instance.visible_when_visible(_k, _v, _obj, my_driver, _req)
+        ;
+      else
+        _processed = false
+      end
+
+      _processed
+
+    end
+
+
     # _a : Hash
     # o locator => String
     # o visible_when => Hash
-    def visible_when_visible(_a)
+    def visible_when_visible(_k, page_elt, _obj, my_driver, _req='UI')
+
+      Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " visible_when_visible(#{_k}, #{page_elt}, #{_obj}, mydriver, #{_req}"
+
+      _processed = false
+      if page_elt.has_key?('visible_when') && !page_elt['visible_when'].is_a?(Array) && page_elt['visible_when'].match(/\s*visible\s*\(/)
+        _processed = true
+
+        condition = page_elt['visible_when'].match(/(visible)\((.*)\)/)[1].to_s
+        tmpObj = page_elt['visible_when'].match(/(visible)\((.*)\)/)[2].to_s
+        expectedVal = page_elt['visible_when'].match(/(visible)\s*\(.*\)\s*\=\s*(.*)/)[2].to_s
+
+        _locator = Scoutui::Base::UserVars.instance.get(tmpObj)
+        depObj = Scoutui::Base::QBrowser.getObject(my_driver, _locator, Scoutui::Commands::Utils.instance.getTimeout)
+
+        Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + "condition (#{condition}), tmpObj (#{tmpObj}) (#{depObj}), expectedVal (#{expectedVal})  :  _obj : #{_obj.displayed?}"
+
+
+        expectedRc = !expectedVal.match(/^\s*true\s*$/i).nil?
+
+
+        _desc=" Verify #{_k} is "
+        if expectedRc == !depObj.nil?
+          _desc+="visible when visible(#{tmpObj}) is #{expectedRc}"
+
+          Scoutui::Logger::LogMgr.instance.asserts.info __FILE__ + (__LINE__).to_s + _desc + " - #{!_obj.nil?}"
+          Testmgr::TestReport.instance.getReq(_req).get_child('visible_when_visible').add(!_obj.nil?, __FILE__ + (__LINE__).to_s + _desc)
+
+        else
+          _desc+="not visible when visible(#{tmpObj}) is #{!depObj.nil?} (expected:#{expectedRc})"
+
+          Scoutui::Logger::LogMgr.instance.asserts.info __FILE__ + (__LINE__).to_s + _desc + " - #{_obj.nil?}"
+          Testmgr::TestReport.instance.getReq(_req).get_child('visible_when_visible').add(_obj.nil?, __FILE__ + (__LINE__).to_s + _desc)
+        end
+
+      end
 
+      _processed
     end
 
   end