class Scoutui::Base::Assertions

Attributes

assertionTypes[RW]
drv[RW]

Public Class Methods

new() click to toggle source
# File lib/scoutui/base/assertions.rb, line 14
def initialize
  @assertionTypes=[
      { :cmd => 'isChecked',   :pattern => '^\s*[!]*isChecked\((.*)\)\s*$', :parse => lambda { |_a| _parseFrameLoc('isChecked', _a) } },
      { :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 => 'isText',      :pattern => '^\s*[!]*(isText)\s*\(.*\)\s*\=\s*(.*)\s*$',   :parse => lambda { |_a| _parseWith('isText', _a) } },
      { :cmd => 'isValue',     :pattern => '^\s*[!]*(isValue)\s*\(.*\)\s*\=\s*(.*)\s*$',   :parse => lambda { |_a| _parseWith('isValue', _a) } },
      { :cmd => 'visible',     :pattern => '^\s*[!]*visible\((.*)\)\s*$', :parse => nil },
      { :cmd => 'isUrl',       :pattern => '^\s*isUrl\((.*)\)\s*$', :parse => lambda { |_a| _parseWith('isUrl', _a) } },
      { :cmd => 'url',         :pattern => '^\s*url\((.*)\)\s*$', :parse => lambda { |_a| _parseWith('url', _a) } },
      { :cmd => 'compare',     :pattern => '^\s*(\$\{.*\})\s*(==|!=)(.*)$', :parse => nil }
  ]

end

Public Instance Methods

_parseFrameLoc(_cmd, _a) click to toggle source

_a : frame(xyz).frame(123), <locator>

# File lib/scoutui/base/assertions.rb, line 171
def _parseFrameLoc(_cmd, _a)

  Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " _parseFrameLoc(#{_cmd}, #{_a})"
  rc=nil

  begin
    _fMatch=nil

    _pattern='(frame\(.*\)[\.frame\(.*\)]*)\s*,\s*(.*)\s*$'

    c=_a.match(/^\s*([!]*#{_cmd})\((.*)\)\s*$/)

    if c
      cmd = c[1].strip
      _fMatch = c[2].match(/#{_pattern}/)
    end


    if _fMatch
      f=c[2].strip

      Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " arg: #{f}"

      rc = { 'cmd' => cmd,
             'frame'    =>  _fMatch[1].strip,
             'locator'  =>  _fMatch[2].strip }
    elsif c
      rc = {
          'cmd' => cmd,
          'locator' => c[2].strip
      }
    end

  rescue => ex
    ;
  end

  rc
end
_parseFrameLocator(_a) click to toggle source

Returns

if frame exists

{
   'frame' => <frame>,
   'locator' => 'locator'
}

otherwise,

{ 'locator => <locator> '}

# File lib/scoutui/base/assertions.rb, line 150
def _parseFrameLocator(_a)
  Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " _parseFrameLocator(#{_a})"
  _pattern='(frame\(.*\)[\.frame\(.*\)]*)\s*,\s*(.*)\s*$'
  _fMatch = _a.match(/#{_pattern}/)
  Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " === _fMatch : #{_fMatch}"
  rc=nil
  if _fMatch
    rc = {
           'frame'    =>  _fMatch[1].strip,
           'locator'  =>  _fMatch[2].strip }
  else
    rc = {
        'locator' => _a
    }
  end

  Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " _parseFrameLocator(#{_a}) => #{rc}"
  rc
end
_parseWith(_cmd, _a) click to toggle source
# File lib/scoutui/base/assertions.rb, line 94
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

      Scoutui::Logger::LogMgr.instance.debug __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
assertPage(my_driver, _pg, _req=nil) click to toggle source
# File lib/scoutui/base/assertions.rb, line 713
    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)
                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

              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)
                  Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " Processed assertPageElement(#{_k}, #{_v})";
                  ;
#               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."
              Scoutui::Logger::LogMgr.instance.info __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

      Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " Pause debug"; gets
    end
assertPageElement(_k, _v, _obj, my_driver, _req) click to toggle source
# File lib/scoutui/base/assertions.rb, line 1254
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
compareValue(_a) click to toggle source
# File lib/scoutui/base/assertions.rb, line 29
def compareValue(_a)
  _match = _a.match(/^\s*(\$\{.*\})\s*(==|!=)(.*)$/)
  _var  = _match[1]
  _cond = _match[2]
  _val  = _match[3]

  _rc=false

  _uservar_val = Scoutui::Base::UserVars.instance.getVar(_var)
  _uservar_val = Scoutui::Base::UserVars.instance.get(_var)  if _uservar_val.nil?

  Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " execute_when.condition => #{_uservar_val} equals #{_val}"

  if _cond=='=='

    if _val.match(/\/.*\//)
      _regex = Regexp.new(_val.match(/\/(.*)\//)[1].to_s)
      Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + "  Val: #{_uservar_val}  REGEX : #{_regex}  => #{!_uservar_val.match(_regex).nil?}"
      _rc = !_uservar_val.match(_regex).nil?
    else
      _rc=(_uservar_val.match(/#{_val}/) || _uservar_val==_val)
    end

  else
    _rc=(!_uservar_val.match(/#{_val}/) || _uservar_val!=_val)
  end

  _rc
end
isChecked?(my_driver, _execute_when) click to toggle source
# File lib/scoutui/base/assertions.rb, line 297
def isChecked?(my_driver, _execute_when)
  rc=true

  _locator = _execute_when.match(/^\s*[!]*(isChecked)\((.*)\)\s*$/i)[2].to_s

  _locator = Scoutui::Base::UserVars.instance.normalize(_locator)

  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)

  _state = _obj.attribute("checked")

  _state = false if _state.nil? || _state.empty?

  Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " _obj.checked? => #{_state}"

  if _execute_when.match(/^\s*!(isChecked)/i) && _state
    Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " !isChecked(#{_locator}) : false"
    rc=false
  elsif _execute_when.match(/^\s*(isChecked)/i) && !_state
    Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " isChecked(#{_locator}) : false"
    rc=false
  end

  Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " isChecked?(#{_execute_when}) => #{rc}"
  rc
end
isEnabled?(my_driver, _execute_when, _enableAsserts=true) click to toggle source
# File lib/scoutui/base/assertions.rb, line 392
def isEnabled?(my_driver, _execute_when, _enableAsserts=true)

  rc=true
  _locator=nil
  _obj=nil
  _t=nil

  _assertType=isValidAssertType(_execute_when)
  Scoutui::Logger::LogMgr.instance.debug __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

    _obj = Scoutui::Base::QBrowser.findElement(my_driver, Scoutui::Base::UserVars.instance.normalize(_locator), Scoutui::Commands::Utils.instance.getFrameSearch(),  Scoutui::Commands::Utils.instance.getTimeout)
  else
    Scoutui::Logger::LogMgr.instance.warn __FILE__ + (__LINE__).to_s + " invalid assertion cmd: #{_execute_when}"
  end

  Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " _obj : #{_obj}"

  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 _t.has_key?('cmd') && !_t['cmd'].empty? && _t['cmd'].match(/[!]*isEnabled/i)

    Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " process isEnabled(#{_obj})"

    if !(_obj.is_a?(Selenium::WebDriver::Element))
      Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " #{_execute_when} => element not found"
      return false
    else
      Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " check if Enabled"
    end

    _enabled = Scoutui::Base::QBrowser.isEnabled?(_obj, my_driver, _locator)

    Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " _obj.enabled? => #{_enabled}"

    if _execute_when.match(/^\s*!isEnabled/i) && _enabled

      if _enableAsserts
        Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " !isEnabled(#{_locator}) : false"
        rc=false
      else

        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)
            Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " waiting .. => #{_obj.class.to_s} : enabled - #{_obj.enabled?}"

            !_obj.enabled?
          }

        rescue Selenium::WebDriver::Error::TimeOutError
          rc=!_obj.enabled?

          Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " TimeOutError waiting for !enabled - #{_locator}  => #{rc}"
        end

        Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + "  wait #{_locator} to be !enabled => #{rc}"
      end

    elsif _execute_when.match(/^\s*isEnabled/i) && !_enabled
      Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " isEnabled(#{_locator}) : false"
      rc=false
    end



  elsif _t.has_key?('cmd') && !_t['cmd'].empty? && _t['cmd'].match(/[!]*is[tT]ext/i)
    rc=false

    if _obj.is_a?(Selenium::WebDriver::Element)
      _v = _obj.text.to_s

      Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " isText(#{_locator.to_s}) : #{_v}  (tagname: #{_obj.tag_name}, displayed: #{_obj.displayed?.to_s}"
      rc=!_v.match(/#{_t['expected_value']}/).nil?

      if _t['cmd'].match(/^!\s*is[tT]ext/i)
        rc=!rc
      end
    end

  elsif _t.has_key?('cmd') && !_t['cmd'].empty? && _t['cmd'].match(/[!]*is[vV]alue/i)
    rc=false

    if _obj.is_a?(Selenium::WebDriver::Element)
      _v = _obj.attribute('value')

      _t['expected_value'] = Scoutui::Base::UserVars.instance.normalize(_t['expected_value'])

       rc=!_v.match(/#{_t['expected_value']}/).nil?

      if _t['cmd'].match(/^!\s*is[vV]alue/i)
        rc=!rc
      end
    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 + " GeneralAssertion: #{_execute_when} => #{rc}"
  rc
end
isEnabledCmd?(_a) click to toggle source
# File lib/scoutui/base/assertions.rb, line 211
def isEnabledCmd?(_a)
  _a.is_a?(String) && _a.match(/^\s*[!]*isEnabled\((.*)\)\s*$/i)
end
isRole?(_execute_when) click to toggle source
# File lib/scoutui/base/assertions.rb, line 682
def isRole?(_execute_when)

  Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " isRole?(#{_execute_when})"

  rc=false

  if _execute_when.match(/^\s*(isrole|role)\s*(.*)\s*$/i)
    _role = _execute_when.match(/^\s*(isrole|role)\s*(.*)\s*$/i)[2].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 !_expected_role.nil?
      if _role.match(/#{_expected_role}/i)
        Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " role matches"
        rc=true
      else
        Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " roles do not match"
      end

    elsif _expected_role.nil?
      Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " Skip role based assertion since role was not provided"
    end

  end

  Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " isRole() => #{rc}"
  rc
end
isRoleCmd?(_a) click to toggle source
# File lib/scoutui/base/assertions.rb, line 215
def isRoleCmd?(_a)
  _a.is_a?(String) && _a.match(/^\s*(isrole|role)\(.*\)\s*/i)
end
isSelected?(my_driver, _execute_when) click to toggle source
# File lib/scoutui/base/assertions.rb, line 518
def isSelected?(my_driver, _execute_when)
  rc=true

  _locator = _execute_when.match(/^\s*[!]*(isSelected|selected)\((.*)\)\s*$/i)[2].to_s
  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)

  _state = _obj.selected?
  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"
    rc=false
  elsif _execute_when.match(/^\s*(isSelected|selected)/i) && !_state
    Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " isSelected(#{_locator}) : false"
    rc=false
  end

  Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " isSelected?(#{_execute_when}) => #{rc}"
  rc
end
isSelectedCmd?(_a) click to toggle source
# File lib/scoutui/base/assertions.rb, line 219
def isSelectedCmd?(_a)
  _a.is_a?(String) && _a.match(/^\s*[!]*(isSelected|selected)\((.*)\)\s*$/i)
end
isTitle(my_driver, _execute_when) click to toggle source
# File lib/scoutui/base/assertions.rb, line 275
def isTitle(my_driver, _execute_when)

  _result=Scoutui::Base::ResultAssertion.new()
  rc=nil

  Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " isTitle(#{_execute_when}"

  _locator = _execute_when.match(/^\s*[!]*(isTitle|title)\((.*)\)\s*$/i)[2].to_s
  Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " isTitle => #{_locator}"

  current_title = my_driver.title
  expected_title = Regexp.new(_locator)
  rc=!expected_title.match(current_title).nil?

  _result.setReport("Actual: #{current_title}   Expected: #{_locator}", rc)
  Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " isTitle?(#{_execute_when}) => #{rc}"
  rc
  _result
end
isTitleCmd?(_a) click to toggle source
# File lib/scoutui/base/assertions.rb, line 224
def isTitleCmd?(_a)
  _a.is_a?(String) && _a.match(/^\s*[!]*(isTitle|title)\s*\((.*)\)\s*$/i)
end
isUrlMatch(my_driver, _a) click to toggle source
# File lib/scoutui/base/assertions.rb, line 59
def isUrlMatch(my_driver, _a)
  current_url = my_driver.current_url.to_s
  expected_url = _a.match(/^\s*(url|isUrl)\s*\((.*)\)\s*$/)[2].to_s

  expected_regex = Regexp.new(Scoutui::Base::UserVars.instance.normalize(expected_url))
  rc=!current_url.match(expected_regex).nil?

  Scoutui::Logger::LogMgr.instance.debug  __FILE__ + (__LINE__).to_s + " verify current url #{current_url} matches regex #{expected_url} : #{rc}"

  return rc
end
isValidAssertType(_a) click to toggle source
# File lib/scoutui/base/assertions.rb, line 72
def isValidAssertType(_a)

  Scoutui::Logger::LogMgr.instance.asserts.debug __FILE__ + (__LINE__).to_s + " isValidAssertionType(#{_a})"
  @assertionTypes.each do |e|
    _p=e[:pattern]

    Scoutui::Logger::LogMgr.instance.asserts.debug __FILE__ + (__LINE__).to_s + " == verify #{_a} matches #{_p} =="

    if _a.match(/#{_p}/)
      Scoutui::Logger::LogMgr.instance.asserts.debug __FILE__ + (__LINE__).to_s + "  matched : #{e}"
      return e
    end
  end

  Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " => unknown command : #{_a}"
  return nil
end
isValue?(my_driver, page_elt) click to toggle source
# File lib/scoutui/base/assertions.rb, line 326
def isValue?(my_driver, page_elt)

  rc = false
  _txt = nil
  _result=Scoutui::Base::ResultAssertion.new()

  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)

    xpath = Scoutui::Base::UserVars.instance.normalize(xpath)  # 5150

    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)

    Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " #{condition} : #{obj}"

    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)
          expandedExpected = Scoutui::Commands::Utils.instance.expandMacro(expectedVal)

          Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " Expanded(#{expectedVal}) : #{expandedExpected}"
          rc =  (!_txt.to_s.match(expected_regex).nil?) || _txt.to_s==expandedExpected
        else
          Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " Unknown conditon: #{condition}"
        end


        _result.setReport("actual: #{_txt}  expected: #{expectedVal}")
        Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + "txt/val: #{_txt}  expected: #{expectedVal}  rc => #{rc}"
      end


    rescue => ex
      rc=false
      Scoutui::Logger::LogMgr.instance.warn __FILE__ + (__LINE__).to_s + " #{ex.class.to_s}"
      Scoutui::Logger::LogMgr.instance.warn __FILE__ + (__LINE__).to_s +  "Backtrace:\n\t#{ex.backtrace.join("\n\t")}"
    end

  end

  _result.setResult(rc)
#  rc
  _result
end
isValueCmd?(_a) click to toggle source
# File lib/scoutui/base/assertions.rb, line 228
def isValueCmd?(_a)
  _a.is_a?(String) && _a.match(/^\s*(value|text)\s*\(.*\)\s*\=\s*(.*)/i)
end
isVisible(my_driver, page_elt, _req=nil, _immediate=false) click to toggle source

{ reqid : <pageElt> }

# File lib/scoutui/base/assertions.rb, line 885
def isVisible(my_driver, page_elt, _req=nil, _immediate=false)
  if _req.nil?
    _req = Scoutui::Utils::TestUtils.instance.getReq()
  end

  Scoutui::Logger::LogMgr.instance.debug __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)

    Scoutui::Logger::LogMgr.instance.debug __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


    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?

    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

  Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " execute_when:visible => #{page_elt}"

  if cmd=='visible' && page_elt.is_a?(String) && page_elt.match(/^\s*page\s*\(/)

    Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " Process PageElement #{page_elt}"
    pageObject = Scoutui::Utils::TestUtils.instance.getPageElement(page_elt)

    Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + "     pageObject => #{pageObject}"

  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

    if pageObject.has_key?('frame')
      # 5150
      _obj=Scoutui::Base::QBrowser.findElementwithinFrame(my_driver, locator, pageObject['frame'],  Scoutui::Commands::Utils.instance.getTimeout)
    else
      _obj = Scoutui::Base::QBrowser.getFirstObject(my_driver, locator, Scoutui::Commands::Utils.instance.getTimeout)
    end

    if cmd=='visible'
      if !_obj.nil?
        rc=_obj.displayed?
      end

      if _immediate
        Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " 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
isVisible?(my_driver, _execute_when, _enableAsserts=true) click to toggle source
# File lib/scoutui/base/assertions.rb, line 542
def isVisible?(my_driver, _execute_when, _enableAsserts=true)
  rc=true
  _state=nil

  _tm = Scoutui::Commands::Utils.instance.getTimeout

  begin

    _t = isVisibleFrameCmd?(_execute_when)

    if !_t.nil?
      _locator = _t['locator']

      Scoutui::Logger::LogMgr.instance.debug  __FILE__ + (__LINE__).to_s + " Locator : #{_locator}"
      _locator = Scoutui::Base::UserVars.instance.normalize(_locator)

      Scoutui::Logger::LogMgr.instance.debug  __FILE__ + (__LINE__).to_s + " Normalize() => #{_locator}"


      _locator = Scoutui::Base::UserVars.instance.get(_locator)

      Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " Get(#{_locator}) : #{_locator}"

      if _t.has_key?('frame') && !_t['frame'].nil?
        Scoutui::Commands::Utils.instance.setEnableFrameSearch(_t['frame'])
      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

      Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " Locator : #{_locator}"
       _locator = Scoutui::Base::UserVars.instance.normalize(_locator)

      Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " Normalize() => #{_locator}"

       _locator = Scoutui::Base::UserVars.instance.get(_locator)

      Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " Get(#{_locator}) : #{_locator}"

    else
      Scoutui::Logger::LogMgr.instance.warn __FILE__ + (__LINE__).to_s + " invalid visible cmd: #{_execute_when}"
    end

    Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " visible => #{_locator}"

    (0..1).each do |_retry|
      begin
        wait = Selenium::WebDriver::Wait.new(:timeout =>  10)

        _obj=nil

        isDisplayed = wait.until {
          _obj = Scoutui::Base::QBrowser.findElement(my_driver, _locator, Scoutui::Commands::Utils.instance.getFrameSearch(),  _tm) # Scoutui::Commands::Utils.instance.getTimeout)
          _obj.is_a?(Selenium::WebDriver::Element) # && _obj.displayed?
        }

        Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " #{_locator} => #{_obj}  displayed:#{_obj.displayed?}"

        _state = Scoutui::Base::QBrowser.isDisplayed?(_obj)


        break if _state

      rescue Selenium::WebDriver::Error::TimeOutError
        Scoutui::Logger::LogMgr.instance.warn __FILE__ + (__LINE__).to_s + " Timed out => #{_locator}"

      rescue Selenium::WebDriver::Error::StaleElementReferenceError
        Scoutui::Logger::LogMgr.instance.warn __FILE__ + (__LINE__).to_s + " StaleElementReferenceError:  retry #{_retry} : #{_locator}";
        sleep(0.5)
      end
    end


    if !_state
      Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " Paused due to fail to find #{_locator}"; #STDIN.gets();
    end

    if !_enableAsserts
      _rc=false

      begin
        if _execute_when.match(/^\s*!visible/)

            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)
              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?
            }

        elsif _execute_when.match(/^\s*visible/)

            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)
              Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " waiting .. => #{_obj.class.to_s}"

              if _obj.is_a?(Selenium::WebDriver::Element)
                Scoutui::Logger::LogMgr.instance.debug "***** displayed? : #{_obj.displayed?}"
              end

              _rc = !_obj.nil? && _obj.displayed?
              _rc
            }
        end

      rescue Selenium::WebDriver::Error::TimeOutError
        ;
      end

      Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " waitFor : #{_rc}"
      return _rc
    end


    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"
      rc=false
    elsif _execute_when.match(/^\s*visible/i) && !_state
      Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " visible(#{_locator}) : false"
      rc=false
    end

  rescue => ex
    rc=false
    Scoutui::Logger::LogMgr.instance.warn __FILE__ + (__LINE__).to_s + " #{ex.class.to_s}"
    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}"
  rc
end
isVisibleCmd?(_a) click to toggle source
# File lib/scoutui/base/assertions.rb, line 232
def isVisibleCmd?(_a)
  _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
isVisibleFrameCmd?(_a) click to toggle source
# File lib/scoutui/base/assertions.rb, line 246
def isVisibleFrameCmd?(_a)
  rc=nil

  Scoutui::Logger::LogMgr.instance.asserts.debug __FILE__ + (__LINE__).to_s + " [isVisibleFrameCmd]: #{_a}"

  begin
    if isVisibleCmd?(_a)

      _pattern='(frame\(.*\)[\.frame\(.*\)]*)\s*,\s*(.*)\s*$'

      f=_a.match(/^\s*[!]*visible\((.*)\)\s*$/)[1].strip

      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
      Scoutui::Logger::LogMgr.instance.asserts.debug "=> NOT vsibleCmd"
    end

  rescue => ex
    ;
  end

  Scoutui::Logger::LogMgr.instance.asserts.debug __FILE__ + (__LINE__).to_s + " isVisibleFrameCmd?(#{_a}) : #{rc}"
  rc
end
setDriver(_drv) click to toggle source
# File lib/scoutui/base/assertions.rb, line 90
def setDriver(_drv)
  @drv=_drv
end
visible_when_always(_k, _v, _obj=nil, _req='UI') click to toggle source

{ “visible_when” => “always” }

# File lib/scoutui/base/assertions.rb, line 1025
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.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.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
visible_when_never(_k, _v, _obj=nil, _req='UI') click to toggle source
# File lib/scoutui/base/assertions.rb, line 1086
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_skip(_k, _v) click to toggle source

{ “visible_when” => true }

# File lib/scoutui/base/assertions.rb, line 1116
def visible_when_skip(_k, _v)

  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')

    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

  end

  rc
end
visible_when_title(_k, page_elt, _obj, my_driver, _req='UI') click to toggle source
# File lib/scoutui/base/assertions.rb, line 1056
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
visible_when_value(_k, page_elt, my_driver, _req='UI') click to toggle source
# File lib/scoutui/base/assertions.rb, line 1140
    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
          Scoutui::Logger::LogMgr.instance.debug __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}"
          Scoutui::Logger::LogMgr.instance.warn __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
visible_when_visible(_k, page_elt, _obj, my_driver, _req='UI') click to toggle source

_a : Hash o locator => String o visible_when => Hash

# File lib/scoutui/base/assertions.rb, line 1280
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

    if page_elt['visible_when'].match(/^\s*(visible)\s*\(.*\)\s*$/)
      expectedVal='true'
    else
      expectedVal = page_elt['visible_when'].match(/(visible)\s*\(.*\)\s*\=\s*(.*)/)[2].to_s
    end

    _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