class Scoutui::Commands::VerifyElement

Public Instance Methods

_execute(drv) click to toggle source
# File lib/scoutui/commands/verify_element.rb, line 108
    def _execute(drv)
      @drv=drv if !drv.nil?
      _e=getLocator()

      if _e.nil?
        _e = @cmd.match(/(verify[eE]lt|verify[eE]lement)\s*\((.*)\)/)[2].to_s.strip
      end

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

      _xpath = Scoutui::Base::UserVars.instance.get(_e)

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


      page_elt = Scoutui::Utils::TestUtils.instance.getPageElement(_xpath)

      Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " Process page request #{page_elt} => #{page_elt.class.to_s}"

      xpath=nil

      if page_elt.is_a?(Hash) && page_elt.has_key?('locator')

        locator = Scoutui::Base::UserVars.instance.get(page_elt['locator'].to_s)
        obj=Scoutui::Base::QBrowser.getElement(@drv, locator, Scoutui::Commands::Utils.instance.getFrameSearch(),  Scoutui::Commands::Utils.instance.getTimeout)

        if !obj.nil? && obj.is_a?(Selenium::WebDriver::Element) && obj.tag_name.downcase.match(/(select)/)
          opt = Selenium::WebDriver::Support::Select.new(obj)

         # opts = _opt.selected_options

          if !opt.nil?
            opts = opt.options

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

            optionList=[]
            textList=[]
            opts.each do |item|
              textList << item.attribute('text')  if !item.attribute('text').nil?
              optionList << item.attribute('value')  if !item.attribute('value').nil?
            end

            Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s +  " optsText   : #{textList}"
            Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s +  " optsValues : #{optionList}"


            if page_elt.has_key?('options')
              diffSet = page_elt['options'] - textList

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

              Testmgr::TestReport.instance.getReq('UI').tc('visible_when').add(diffSet.empty?, "Verify expected options exists for #{_e}  (unmatched: #{diffSet})")


              Scoutui::Logger::LogMgr.instance.asserts.info "Verify expected options exists for #{_e}  (unmatched: #{diffSet}) - #{diffSet.empty?}"


              setResult(diffSet.empty?)
            end

          end
        end



        if page_elt.has_key?('visible_when') && page_elt['visible_when'].is_a?(Array)

          _expectedResults=Scoutui::Base::VisualTestFramework::processAsserts(@drv, page_elt['visible_when'])


          Testmgr::TestReport.instance.getReq('UI').tc('visible_when').add(!obj.nil? && obj.displayed?, "Verify #{locator} is visible")


          _expectedResults = _expectedResults && !obj.nil? && obj.displayed?
          Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " expectedResult : #{_expectedResults}"
          return _expectedResults

        elsif page_elt.has_key?('visible_when') && page_elt['visible_when'].match(/title\(/)
          current_title = @drv.title
          expected_title = Regexp.new(page_elt['visible_when'].match(/title\((.*)\)/)[1].to_s)
          rc=!expected_title.match(current_title).nil?


          Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " Verify expected title (#{current_title}) matches (#{expected_title}) => " + rc.to_s

#          Testmgr::TestReport.instance.getReq('UI').tc('visible_when').add(expected_title==current_title, "Verify title matches #{expected_title}")
        end


        if page_elt.has_key?('visible_when') && page_elt['visible_when'].match(/(text|value)\s*\(/)

          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 + " tmpObj => #{tmpObj} with expected value #{expectedVal}"

          xpath = Scoutui::Base::UserVars.instance.get(tmpObj)

          obj = Scoutui::Base::QBrowser.getObject(@drv, 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 #{locator} is visible since condition (#{condition} #{xpath} is met."
                elsif condition=='value' && o.attribute('value').to_s==expectedVal
                  desc=" Verify #{locator} is visible since #{condition} of #{xpath} is #{expectedVal}"
                end

                if !desc.nil?
                  locatorObj = Scoutui::Base::QBrowser.getObject(@drv, 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



            end

            Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " value : #{obj.attribute('value').to_s}"
          end

        end

      elsif page_elt.is_a?(Hash)

        page_elt.each do |elt|

          Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " ELT => #{elt} : #{elt.to_s}"
          Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + "     ELT[0] : #{elt[0]}"
          Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + "     ELT[1] : #{elt[1]}"

          if elt.is_a?(Array)
            _h={ elt[0] => elt[1] }

            _verify(_h)
          end

        end


      end

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


    end
_verify(elt) click to toggle source
# File lib/scoutui/commands/verify_element.rb, line 7
def _verify(elt)
  begin

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

    _k = elt.keys[0].to_s
    a = elt[_k]

    Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " Assert => #{_k} :  #{a.to_s}"

    #    _k = 'generic-assertion'
    _v={}

    if a.is_a?(Hash)
      _v=a


      if _v.has_key?('reqid')
        _req=_v['reqid'].to_s
      else
        _req = Scoutui::Utils::TestUtils.instance.getReq()
      end


      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(@drv, _locator, Scoutui::Commands::Utils.instance.getTimeout())

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

      if _v.has_key?('visible_when')


        if _v['visible_when'].match(/^\s*(text|value)\s*\(/)

          _elt = _v['visible_when']

          Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " verify text";
          condition = _elt.match(/(value|text)\((.*)\)/)[1].to_s
          tmpObj = _elt.match(/(value|text)\((.*)\)/)[2].to_s
          expectedVal = _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(@drv, _xpath, Scoutui::Commands::Utils.instance.getTimeout)

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

          expected_regex = Regexp.new(expectedVal)
          rc =  !obj.text.to_s.match(expected_regex).nil?


          Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " req: #{_req}  obj : #{obj}, rc:#{rc}"; #gets
          if rc
            Testmgr::TestReport.instance.getReq(_req).get_child('visible_when').add(!obj.nil?, "Verify element exists when #{condition} match #{expectedVal}")
          end


        elsif _v['visible_when'].match(/always/i)
          Scoutui::Logger::LogMgr.instance.asserts.info __FILE__ + (__LINE__).to_s + " Verify assertion #{_k} - #{_locator} visible - #{!_obj.nil?.to_s}"
          Testmgr::TestReport.instance.getReq(_req).get_child('visible_when').add(!_obj.nil?, "Verify assertion #{_k} - #{_locator} visible")
        elsif _v['visible_when'].match(/never/i)
          Scoutui::Logger::LogMgr.instance.asserts.info "Verify assertion #{_k} #{_locator} not visible - #{obj.nil?.to_s}"
          Testmgr::TestReport.instance.getReq(_req).get_child('visible_when').add(obj.nil?, "Verify assertion #{_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 assertion object exists if the role #{_role} matches expected role #{_expected_role.to_s}"

          if _role==_expected_role.to_s
            Scoutui::Logger::LogMgr.instance.asserts.info "Verify assertion #{_k} #{_locator}  visible when role #{_role} - #{!_obj.nil?.to_s}"
            Testmgr::TestReport.instance.getReq(_req).get_child('visible_when').add(!_obj.nil?, "Verify assertion #{_k} #{_locator}  visible when role #{_role}")
          end

        end
      end


    end

  rescue => ex

    Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " abort processing."
    Scoutui::Logger::LogMgr.instance.debug "Error during processing: #{ex}"
    Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s +  "\nBacktrace:\n\t#{ex.backtrace.join("\n\t")}"
  end

end
execute(_drv, e=nil) click to toggle source
# File lib/scoutui/commands/verify_element.rb, line 104
def execute(_drv, e=nil)
  _execute(_drv)
end