class Scoutui::Base::VisualTestFramework

Constants

CMD_KEY
STEP_KEY

Public Class Methods

isRun(e) click to toggle source
# File lib/scoutui/base/visual_test_framework.rb, line 315
def self.isRun(e)
  _run=nil
  if e[STEP_KEY].has_key?("run")
    _run = e[STEP_KEY].has_key?("run").to_s
  end
  _run
end
isSnapIt(e) click to toggle source
# File lib/scoutui/base/visual_test_framework.rb, line 323
def self.isSnapIt(e)
  _snapit=false

  begin

    if e[STEP_KEY].has_key?("snapit")

      if e[STEP_KEY]["snapit"].is_a?(String)
        _snapit = !(e[STEP_KEY]["snapit"].to_s.match(/\s*(true|yes|y)\s*$/i).nil?)
      elsif e[STEP_KEY]["snapit"].is_a?(TrueClass)
        _snapit = e[STEP_KEY]["snapit"]
      end

    end

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

  _snapit
end
new() click to toggle source
# File lib/scoutui/base/visual_test_framework.rb, line 11
def initialize()

end
processAssertions(my_driver, e) click to toggle source
# File lib/scoutui/base/visual_test_framework.rb, line 392
def self.processAssertions(my_driver, e)
  processConditions(my_driver, e, 'assertions')
end
processAsserts(my_driver, _execute_when, _enableAsserts=true) click to toggle source

recsult=processAsserts(my_driver, e[“asserts”])

# File lib/scoutui/base/visual_test_framework.rb, line 397
    def self.processAsserts(my_driver, _execute_when, _enableAsserts=true)

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

      result=true

      if !_execute_when.nil? && _execute_when.is_a?(Array)

        _req = Scoutui::Utils::TestUtils.instance.getReq()

        _execute_when.each do |_a|
          Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " assert: => #{_a}"

          _tmpResult=nil
          _assertText=nil
          _rc=nil
          _bm=nil

          _assertMessage = "Assert #{_a}."

          _assertType=Scoutui::Base::Assertions.instance.isValidAssertType(_a)

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

          if !_assertType.nil?

            if _assertType[:cmd].match(/^\s*isEnabled\s*$/i)  # Scoutui::Base::Assertions.instance.isEnabledCmd?(_a)

              _bm=Benchmark.measure {
                _rc=Scoutui::Base::Assertions.instance.isEnabled?(my_driver, _a, _enableAsserts)
              }

            elsif _assertType[:cmd]=='visible'

                _bm=Benchmark.measure {
                  _rc=Scoutui::Base::Assertions.instance.isVisible?(my_driver, _a, _enableAsserts)
                }

            elsif _assertType[:cmd]=='isSelected'
              _bm=Benchmark.measure {
                _rc=Scoutui::Base::Assertions.instance.isEnabled?(my_driver, _a)
              }

            elsif _assertType[:cmd]=='isText'
              _bm=Benchmark.measure {
                _rc=Scoutui::Base::Assertions.instance.isEnabled?(my_driver, _a)
              }

            elsif _assertType[:cmd]=='isValue'
              _bm=Benchmark.measure {
                _rc=Scoutui::Base::Assertions.instance.isEnabled?(my_driver, _a)
              }
            elsif _assertType[:cmd].match(/(url|isUrl)/)
              _bm=Benchmark.measure {
                _rc=Scoutui::Base::Assertions.instance.isUrlMatch(my_driver, _a)
              }

            elsif _assertType[:cmd]=='compare'
              _bm=Benchmark.measure {
                _rc=Scoutui::Base::Assertions.instance.compareValue(_a)
              }

            elsif _assertType[:cmd]=='isChecked'
              _bm=Benchmark.measure {
                _rc=Scoutui::Base::Assertions.instance.isChecked?(my_driver, _a)
              }
            end

          elsif Scoutui::Base::Assertions.instance.isRoleCmd?(_a)
            _bm=Benchmark.measure {
              _rc=Scoutui::Base::Assertions.instance.isRole?(_a)
            }
#          elsif Scoutui::Base::Assertions.instance.isVisibleCmd?(_a)
#            _rc=Scoutui::Base::Assertions.instance.isVisible?(my_driver, _a)
          elsif Scoutui::Base::Assertions.instance.isSelectedCmd?(_a)
            _bm=Benchmark.measure {
              _rc=Scoutui::Base::Assertions.instance.isSelected?(my_driver, _a)
            }
          elsif Scoutui::Base::Assertions.instance.isValueCmd?(_a)
            _bm=Benchmark.measure {
              _tmpResult=Scoutui::Base::Assertions.instance.isValue?(my_driver, _a)
              _rc=_tmpResult.passed?
            }
          elsif Scoutui::Base::Assertions.instance.isTitleCmd?(_a)
            _bm=Benchmark.measure {
              _tmpResult=Scoutui::Base::Assertions.instance.isTitle(my_driver, _a)
              _rc=_tmpResult.passed?
            }

          elsif _a.match(/^\s*count\(.*\)\s*(==|!=|>=|<=|<|>)\s*(\d+|\$\{.*\})$/)

            _mResult = _a.match(/^\s*count\((.*)\)\s*(==|!=|>=|<=|<|>)\s*(\d+|\$\{.*\})$/)
            _locator = _mResult[1]
            _op = _mResult[2]
            _v = Scoutui::Base::UserVars.instance.normalize(_mResult[3]).to_i

            ## _v should be an integer

            _bm=Benchmark.measure {
              hits = Scoutui::Base::QBrowser.findElements( { :driver => my_driver, :locator => _locator })


              Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " Process COUNT : #{_locator} is #{_op} val #{_v}  => #{hits.length}"


              if _op=='=='
                _rc = hits.length == _v
              elsif _op=='>='
                _rc = hits.length >= _v
              elsif _op=='<='
                _rc = hits.length <= _v
              elsif _op=='<'
                _rc = hits.length < _v
              elsif _op=='>'
                _rc = hits.length > _v
              elsif _op=='!='
                _rc = hits.length != _v
              end

              _tmpResult=Scoutui::Base::ResultAssertion.new()
              _tmpResult.setReport("Assert count(#{_locator}) #{_op} #{_v}.  Actual: #{hits.length}   Expected: #{_v}. : #{_rc}", _rc)
            }



          elsif _a.match(/^\s*[fF]ocused\(.*\)\s*$/)

            _locator = _a.match(/^\s*[fF]ocused\((.*)\)\s*$/)[1]

            _bm=Benchmark.measure {
              _activeElt = my_driver.switch_to.active_element
              obj = Scoutui::Base::QBrowser.getElement(my_driver,
                                                       _locator,
                                                       Scoutui::Commands::Utils.instance.getFrameSearch(),
                                                       Scoutui::Commands::Utils.instance.getTimeout)

              _rc = (obj==_activeElt)
            }

            if _rc
              Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + "  focused() - MATCHED"
            end

          elsif _a.match(/^\s*([fF]ocused\.[Vv]alue\((.*)\))\s*$/)
            _expectedValue = _a.match(/^\s*([fF]ocused.[Vv]alue\((.*)\))\s*$/)[2].to_s
            _expectedValue = Scoutui::Base::UserVars.instance.normalize(_expectedValue)
            _activeElt=nil
            _value=nil

            _bm=Benchmark.measure {
              _activeElt = my_driver.switch_to.active_element
              _value=_activeElt.attribute('value')

              if !_activeElt.nil? && _value

                Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + "  activeElt.value  : |#{_value.to_s}|"

                _rc=!(_value.to_s.match(/#{_expectedValue}/).nil?) || (_value.to_s==_expectedValue)
              end
            }

            if _activeElt.is_a?(Selenium::WebDriver::Element)
              Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " ASSERT: focusValue: #{_expectedValue} vs #{_value} => #{_rc}"
            end



          elsif _a.match(/^\s*([!]*[fF]ocused\.[Tt]ext\((.*)\))\s*$/)

            _targetTxt = _a.match(/^\s*([!]*[fF]ocused.[Tt]ext\((.*)\))\s*$/)[2].to_s


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

            _activeElt=nil

            _bm=Benchmark.measure {
              _activeElt = my_driver.switch_to.active_element

              if !_activeElt.nil?
                Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + "  target.text     : |#{_targetTxt}|"
                Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + "  activeElt.text  : |#{_activeElt.text.to_s}|"

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

              #  _rc=!(_activeElt.text.to_s.match(/#{_targetTxt}/).nil?) # || _activeElt.text.to_s==_targetTxt.to_s
                _rc= (!_activeElt.text.to_s.match(Regexp.new(_targetTxt)).nil?) || (_activeElt.text.to_s==_targetTxt)

                Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " isMatch : #{_rc}"

                if _a.match(/^\s*![fF]ocused\./)
                  _rc=!_rc
                  Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " verify #{_targetTxt} != #{_activeElt.text} => #{_rc}"
                end

                Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + "  FocusedText : #{_activeElt.text} => #{_rc}"
              end
            }

            if _activeElt.is_a?(Selenium::WebDriver::Element)
              _assertText = "Verify #{_a} - focused: #{_activeElt.text}, expected: #{_targetTxt} - #{_rc}"
              Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " ASSERT: focusTxt: #{_targetTxt} vs #{_activeElt.text} => #{_rc}"
            end

          elsif _a.match(/^\s*(req|requirement)\s*\((.*)\)\s*$/i)

            _reqID=_a.match(/^\s*(req|requirement)\s*\((.*)\)\s*$/i)[2].to_s

            Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + "  Process REQ ASSERT: #{_reqID}";
            _reqAsserts=Scoutui::Base::Requirements.instance.get(_reqID)
            Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " => #{_reqAsserts}"

            _req = Scoutui::Utils::TestUtils.instance.setReq(_reqID)

            _bm=Benchmark.measure {
              _rc=processAsserts(my_driver, _reqAsserts, _enableAsserts)
            }

            Scoutui::Utils::TestUtils.instance.setReq(_req)


          elsif !_a.match(/^page\([\w\d]+\)/).nil?

            Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + "\n\n=== Validate Page ==="

            _obj = processPageElement(my_driver, nil, _a)

              # 5150
            #puts __FILE__ + (__LINE__).to_s + " *** WHAT type of assertion => #{_obj}"; STDIN.gets

          elsif !_a.match(/^\s*accessibility\s*$/).nil?
            Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " *** Accessibility ***"


            # 5150
            # Get all displayed textareas
            ['//textarea', '//img'].each do |elt_wcag|
              Scoutui::Base::QBrowser.isAccessible({ :driver => my_driver, :locator => elt_wcag })
            end

 #          textAreas = Scoutui::Base::QBrowser.getObjects( { :driver => my_driver, :locator => '//textarea' })


         # elsif _a.match(/^\s*[!](existsalert|existsalert|exists\(alert\))/i)
            elsif Scoutui::Commands::Utils.instance.isExistsAlert?(_a)
            _bm=Benchmark.measure {

              _c = Scoutui::Commands::JsAlert::ExistsAlert.new(_a)
              _rc = _c.execute(my_driver)
              _assertMessage = _c.getAssertText()
              #_rc = _c.alertExists?
              Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " existsAlert => #{_rc}"
            }
          end

          if !_rc.nil?

            if _enableAsserts
              Scoutui::Logger::LogMgr.instance.asserts.info __FILE__ + (__LINE__).to_s + " Verify #{_a} - #{_rc}"


              _testcase = Scoutui::Utils::TestUtils.instance.getTC() || "visible_when"

#              _assertMessage = "Assert #{_a}."

              if !_tmpResult.nil?
                _assertMessage+=" #{_tmpResult.report}"
              end

              Testmgr::TestReport.instance.getReq(_req).get_child(_testcase).add(_rc, _assertMessage, _bm.real)

              if Scoutui::Utils::TestUtils.instance.isFailFast? && !_rc

                _assertText =  "Failed assertion: #{_a.to_s}" if _assertText.nil?
                Scoutui::Utils::TestUtils.instance.setState(:abort, _assertText)

              end

            end

            Scoutui::Commands::Utils.instance.resetFrameSearch()

            result=(result && _rc)
          end

        end
      end

      Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " *************  processAsserts() => #{result}"
      result

    end
processCommand(_action, e, my_driver) click to toggle source
# File lib/scoutui/base/visual_test_framework.rb, line 256
def self.processCommand(_action, e, my_driver)
  _req = Scoutui::Utils::TestUtils.instance.getReq()
  Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " ===  Process ACTION : #{_action}  ==="  if Scoutui::Utils::TestUtils.instance.isDebug?

  if Scoutui::Commands::Utils.instance.isExistsAlert?(_action)
    _c = Scoutui::Commands::JsAlert::ExistsAlert.new(_action)
    _rc = _c.execute(my_driver)
    Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " existsAlert => #{_rc}"

    Scoutui::Logger::LogMgr.instance.asserts.info "Verify alert is present - #{!_rc.nil?.to_s}"
    Testmgr::TestReport.instance.getReq(_req).get_child('expectJsAlert').add(!_rc.nil?, "Verify alert is present")

  elsif Scoutui::Commands::Utils.instance.isVerifyForm?(_action)
    _c = Scoutui::Commands::VerifyForm.new(_action)
    _c.execute(my_driver)

  elsif !_action.match(/fillform\(/).nil? && false

 #   _c = Scoutui::Commands::FillForm.new(_action)

    _form = _action.match(/fillform\((.*)\s*\)/)[1].to_s
 #  _dut = _action.match(/fillform\(.*,\s*(.*)\)/)[1].to_s

    dut = e[STEP_KEY]['dut']

    Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " DUT => #{dut}" if Scoutui::Utils::TestUtils.instance.isDebug?
    _f = Scoutui::Utils::TestUtils.instance.getForm(_form)
    _f.dump()
    _f.verifyForm(my_driver)
    _f.fillForm(my_driver, dut)

  elsif !_action.match(/submitform\(/).nil? && false
    _cmd = Scoutui::Commands::SubmitForm.new(_action)
 #   _cmd.execute(my_driver)

    _form = _action.match(/submitform\((.*)\s*\)/)[1].to_s
    _f = Scoutui::Utils::TestUtils.instance.getForm(_form)
    _f.submitForm(my_driver)

  elsif !_action.match(/type\(/).nil?  && false
    _xpath = _action.match(/type\((.*),\s*/)[1].to_s
    _val   = _action.match(/type\(.*,\s*(.*)\)/)[1].to_s

    Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + "Process TYPE #{_val} into  #{_xpath}"  if Scoutui::Utils::TestUtils.instance.isDebug?

    obj = Scoutui::Base::QBrowser.getObject(my_driver, _xpath, Scoutui::Commands::Utils.instance.getTimeout)

    if !obj.nil? && !obj.attribute('type').downcase.match(/(text|password|email)/).nil?
      Scoutui::Logger::LogMgr.instance.commands.info "send_keys(#{_val})"
      obj.send_keys(Scoutui::Base::UserVars.instance.get(_val))
    else
      Scoutui::Logger::LogMgr.instance.warn __FILE__ + (__LINE__).to_s + " Unable to process command TYPE => #{obj.to_s}"
    end

  end


end
processConditions(my_driver, e, _conditionType) click to toggle source
# File lib/scoutui/base/visual_test_framework.rb, line 693
def self.processConditions(my_driver, e, _conditionType)
  Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " === ProcessAssertions(#{e.to_s} ====" if Scoutui::Utils::TestUtils.instance.isDebug?

  if !e[STEP_KEY].has_key?(_conditionType)
    return
  end

  if !e[STEP_KEY][_conditionType].is_a?(Array)
    Scoutui::Logger::LogMgr.instance.warn __FILE__ + (__LINE__).to_s + " \'assertions\' field must be type Array."
    return
  end

  _req = Scoutui::Utils::TestUtils.instance.getReq()

  Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + "======= #{e[STEP_KEY][_conditionType]} ========="


  e[STEP_KEY][_conditionType].each do |elt|

    begin


    _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']

        Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " Temp req #{_req} for assertion"
      end

      if _v.has_key?('locator')  && _v['locator'].is_a?(String) && _v.has_key?('enabled_when')

        Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " Process pageObject #{_v} for enabled_when - TBD";  # TBD gets;
        isVisible=Scoutui::Base::Assertions.instance.isEnabled(my_driver, _v['locator'], _req)

      elsif _v.has_key?('locator')  && _v['locator'].is_a?(String) && !_v.has_key?('visible_when')
        Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " Process pageObject #{_v}"
        isVisible=Scoutui::Base::Assertions.instance.isVisible(my_driver, _v['locator'], _req)

      elsif _v.has_key?('locator')
        _locator = _v['locator'].to_s

        if !_locator.match(/^page\([\w\d]+\)/).nil?
          _obj = processPageElement(my_driver, _k, _locator)
          Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " Processed #{_locator} => #{_obj.class.to_s}"
        else

          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?}" if Scoutui::Utils::TestUtils.instance.isDebug?
        end

      end

      if _v.has_key?('visible_when')

        if _v['visible_when'].match(/value\((\$\{.*\})\)=(.*)/)

          user_var = _v['visible_when'].match(/value\((\$\{.*\})\)=(.*)/)[1]
          expected_v = _v['visible_when'].match(/value\((\$\{.*\})\)=(.*)/)[2]

          _uservar_val = Scoutui::Base::UserVars.instance.getVar(user_var)



          Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " _uservar_val : #{_uservar_val}"
          Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " Assert user variable - #{user_var} matches #{expected_v} => #{_uservar_val.match(expected_v)}"


          if _uservar_val.match(expected_v) || _uservar_val==expected_v
            # 5150

            Scoutui::Logger::LogMgr.instance.asserts.info __FILE__ + (__LINE__).to_s + "Verify conditional assertion #{_k} - #{!_obj.nil?}"
            Testmgr::TestReport.instance.getReq(_req).get_child('visible_when').add(!_obj.nil?, "Verify assertion #{_k} - #{_locator} visible when #{_v['visible_when']}")
          else
            Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " Conditional Assertion skipped - trigger #{_v['visible_when']} is false"
          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 Scoutui::Base::Assertions.instance.visible_when_never(_k, _v, _obj, _req)
          ;
        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 Scoutui::Utils::TestUtils.instance.isDebug?

          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.warn __FILE__ + (__LINE__).to_s + " abort processing."
      Scoutui::Logger::LogMgr.instance.warn "Error during processing: #{ex}"
      Scoutui::Logger::LogMgr.instance.warn __FILE__ + (__LINE__).to_s +  "Backtrace:\n\t#{ex.backtrace.join("\n\t")}"
    end


  end


end
processExpected(my_driver, e) click to toggle source
# File lib/scoutui/base/visual_test_framework.rb, line 827
def self.processExpected(my_driver, e)

  _req = Scoutui::Utils::TestUtils.instance.getReq()

  Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + "processExpected()"

  Scoutui::Base::Assertions.instance.setDriver(my_driver)

  if e[STEP_KEY].has_key?('expected')

    expected_list=e[STEP_KEY]['expected']
    Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " => #{expected_list}"

    _expectedResults=processAsserts(my_driver, expected_list, false)
    Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " expectedResults => #{_expectedResults}"

    if expected_list.is_a?(Array)

      Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " Process Arr of Expected"

      expected_list.each do |_condition|

        Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " processExpected.Condition : #{_condition}"
        verifyCondition(my_driver, _condition)
      end
    end

    if expected_list.is_a?(Hash)

      expected_list.each_pair do |link_name, xpath|

        Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s +  "\t\t#{link_name} => #{xpath}"

        # Check if the verification is a "windows.*" verification

        if !xpath.match(/^\*window[s]\.length\s*\(\d+\)/).nil?
          _expected_length=xpath.match(/window[s]\.length\s*\((.*)\)/i)[1].to_s

          Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + "\tExpect window.length is #{_expected_length}"

          if _expected_length =~ /\A\d+\z/
            # 5150
            totalWindows = my_driver.window_handles.length

            if Scoutui::Utils::TestUtils.instance.assertExpected?
              Testmgr::TestReport.instance.getReq(_req).get_child('window_size').add(totalWindows==_expected_length.to_i, "Verify number of windows is #{_expected_length}  actual(#{totalWindows})")
            end

          end

          next
        end

        # Not Visible
        if !xpath.match(/^\s*[!]*visible\(.*\)$/).nil?
          _rc = false
          _e=nil
          _timeout=12
          _msg="is visible"

          if xpath.match(/^\s*!visible/)
            _msg="is not visible"
          end

          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
          else
            _e = xpath.match(/^\s*[!]*visible\((.*)\)$/)[1].to_s.strip
          end

          _obj =  Scoutui::Base::QBrowser.getObject(my_driver, _e, Scoutui::Commands::Utils.instance.getTimeout)

          Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " Wait until element #{xpath} => #{_e} is not visible #{_obj}.class.to_s"

          if _obj.nil? && xpath.match(/^\s*!visible\((.*)\)$/)
            _rc = true

          elsif !_obj.nil? && xpath.match(/^\s*visible\((.*)\)$/)
            _rc = true
          else
            Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " _obj => #{_obj} : exists: #{!_obj.nil?}"

            begin
              Selenium::WebDriver::Wait.new(timeout: _timeout).until {
                _obj = Scoutui::Base::QBrowser.getObject(my_driver, _e, 5)
                Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " waiting .. => #{_obj.class.to_s}"

                _obj.nil?
              }

            rescue Selenium::WebDriver::Error::TimeOutError
               _rc=_obj.nil?
            end


          end

          Scoutui::Logger::LogMgr.instance.asserts.info __FILE__ + (__LINE__).to_s + " Verify #{_e} - #{_msg} - #{_rc}"
          if Scoutui::Utils::TestUtils.instance.assertExpected?
            Testmgr::TestReport.instance.getReq(_req).get_child('visible_when').add(_rc, "Verify #{_e} - #{_msg}")
          end

          next
        end

        if !xpath.match(/\$\{.*\}/).nil?
      #    xpath = Scoutui::Base::UserVars.instance.get(xpath)
          xpath = Scoutui::Base::UserVars.instance.normalize(xpath)
        end


        if !xpath.match(/^page\([\w\d]+\)/).nil?


          # Check if this is a form

          page_elt = Scoutui::Utils::TestUtils.instance.getPageElement(xpath)
          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
          end

          Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " SubElts => #{sub_elts}" if Scoutui::Utils::TestUtils.instance.isDebug?

          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

          elsif sub_elts > 0
            Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " Validate form" if Scoutui::Utils::TestUtils.instance.isDebug?

            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"
                  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 if Scoutui::Utils::TestUtils.instance.isDebug?

                  #  _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?}" if Scoutui::Utils::TestUtils.instance.isDebug?
                end

                if Scoutui::Base::Assertions.instance.visible_when_always(_k, _v, _obj)
                  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 _v['visible_when'].match(/never/i)
                    Scoutui::Logger::LogMgr.instance.asserts.info "Verify #{_k} #{_locator} never 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} not visible")
                    end

                  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.warn __FILE__ + (__LINE__).to_s + " Invalid file: #{datafile} - abort processing."
                Scoutui::Logger::LogMgr.instance.warn __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 Scoutui::Utils::TestUtils.instance.isDebug?

              if _v.has_key?('locator')
                _locator = _v['locator'].to_s
                Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " " + _k.to_s + " => " + _locator if Scoutui::Utils::TestUtils.instance.isDebug?

              #  _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?}" if Scoutui::Utils::TestUtils.instance.isDebug?
              end

            end

            next
          end


        end

        obj = Scoutui::Base::QBrowser.getFirstObject(my_driver, xpath, Scoutui::Commands::Utils.instance.getTimeout())

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

        Scoutui::Logger::LogMgr.instance.asserts.info __FILE__ + (__LINE__).to_s + " Verify #{xpath} visible - #{obj.kind_of?(Selenium::WebDriver::Element).to_s}"


        if Scoutui::Utils::TestUtils.instance.assertExpected?
          Testmgr::TestReport.instance.getReq(_req).get_child('visible_when').add(!obj.nil?, __FILE__ + (__LINE__).to_s + " Verify #{xpath} visible")
        end

        if obj.nil?
          Scoutui::Logger::LogMgr.instance.warn " NOT FOUND : #{link_name} with xpath #{xpath}" if Scoutui::Utils::TestUtils.instance.isDebug?
        else
          Scoutui::Logger::LogMgr.instance.warn " link object(#{link_name} with xpath #{xpath}=> #{obj.displayed?}"  if Scoutui::Utils::TestUtils.instance.isDebug?
        end

      end
    end
  end

  Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " [end]: processExpected()"
end
processFile(eyeScout, test_settings, strategy=nil) click to toggle source

Scoutui::Base::VisualTestFramework.processFile(@drv, @eyes, @test_settings, @test_settings)

# File lib/scoutui/base/visual_test_framework.rb, line 1110
    def self.processFile(eyeScout, test_settings, strategy=nil)

      Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " [enter]:processFile(#{test_settings['dut']})"
      my_driver = eyeScout.drv()

      baseUrl = Scoutui::Base::UserVars.instance.getHost()
      datafile = test_settings['dut']

      Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " processFile(#{eyeScout}, #{baseUrl}, #{datafile})" if Scoutui::Utils::TestUtils.instance.isDebug?

      valid_file=false
      i=0
      begin
        dut_dupes = YAML.load_stream File.read(datafile)
        valid_file=true
      rescue => ex
        Scoutui::Utils::TestUtils.instance.setState(:abort, "Unable to read #{datafile}.")
        Scoutui::Logger::LogMgr.instance.fatal __FILE__ + (__LINE__).to_s + " #{ex.class}: Invalid file: #{datafile} - abort processing."
        Scoutui::Logger::LogMgr.instance.info ex.backtrace
      end

      return if !valid_file

      dut_dupes.each do |e|

        if Scoutui::Utils::TestUtils.instance.abort?
          Scoutui::Logger::LogMgr.instance.error __FILE__ + (__LINE__).to_s + " ABORT"
          return
        end

        totalWindows = my_driver.window_handles.length

        Scoutui::Logger::LogMgr.instance.debug '-' * 72
        Scoutui::Logger::LogMgr.instance.debug " [Pre-cmd]: Total Windows : #{totalWindows.to_s}"
        Scoutui::Logger::LogMgr.instance.debug " #{i.to_s}. Processing #{e.inspect}"
        i+=1

        Scoutui::Utils::TestUtils.instance.setReq('UI')
        Scoutui::Commands::Utils.instance.resetTimeout(Scoutui::Utils::TestUtils.instance.getDefaultWait)

        _action = e[STEP_KEY]["action"]

      # _name   = e[STEP_KEY]["name"]
        _name   = Scoutui::Base::UserVars.instance.normalize(e[STEP_KEY]["name"])
        _url    = e[STEP_KEY]["url"]
        _skip   = e[STEP_KEY]["skip"]
        _region = e[STEP_KEY]["region"]
        _reqid  = e[STEP_KEY]["reqid"]
        _testcase = e[STEP_KEY]["testcase"]
        _execute_when = e[STEP_KEY]["execute_when"]
        _use_frames = e[STEP_KEY]["frames"]
        _snapit = e[STEP_KEY]["snapit"]



        Scoutui::Commands::Utils.instance.reset(e)

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

        if e[STEP_KEY].has_key?("timeout")
         Scoutui::Commands::Utils.instance.setTimeout(e[STEP_KEY]["timeout"])
        end

        if Scoutui::Utils::TestUtils.instance.isDebug?
          Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " action: #{_action}"
          Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " name: #{_name}"
          Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " url : #{_url}"
          Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " skip: #{_skip}"
          Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " snapit: #{_snapit}"
          Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " region: #{_region}"
          Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " reqid: #{_reqid}"
        end

        if !_reqid.nil? && !_reqid.to_s.empty?
          Testmgr::TestReport.instance.getReq(_reqid)
          Scoutui::Utils::TestUtils.instance.setReq(_reqid)
        else
          Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + "  REQID was not provided"
        end

        if !(_testcase.nil? || _testcase.empty?)
          Scoutui::Utils::TestUtils.instance.setTC(_testcase)
        end


        if !_execute_when.nil? && !_execute_when.to_s.empty?

          if _execute_when.is_a?(String) && _execute_when.match(/^\s*(existsalert|existsalert|exists\(alert\))/i)

            if QBrowser.existsAlert?(my_driver)
              Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " Execution continues - alert IS present #{e[STEP_KEY]}"
            else
#              puts __FILE__ + (__LINE__).to_s + " + Execution skipped - alert is NOT present";; gets()
              next;
            end

          elsif _execute_when.is_a?(String) && _execute_when.match(/^\s*(\$\{.*\})\s*(==)(.*)$/)

            _match = _execute_when.match(/^\s*(\$\{.*\})\s*(==)(.*)$/)
            _var  = _match[1]
            _cond = _match[2]
            _val  = _match[3]

            _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}"

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

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

            if !_rc
              Scoutui::Logger::LogMgr.instance.info " Execute_When: #{_uservar_val} == #{_val} : false - skip #{e[STEP_KEY]}"
               next
            end

          elsif _execute_when.is_a?(String) && _execute_when.match(/^\s*[!]*isEnabled\((.*)\)\s*$/i)


            if !Scoutui::Base::Assertions.instance.isEnabled?(my_driver, _execute_when)
              Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " isEnabled => false"
              next
            end

          elsif _execute_when.is_a?(String) && _execute_when.match(/^\s*[!]*isSelected\((.*)\)\s*$/i)

            if !Scoutui::Base::Assertions.instance.isSelected?(my_driver, _execute_when)
              Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " isSelected => false"
              next
            end

          elsif _execute_when.is_a?(Array)
            Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " Process series of execute_when : #{_execute_when}"

            _executeIt=true

            _execute_when.each do |_a|
              Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " execute_when => #{_a.class} : #{_a}"

              _assertType=Scoutui::Base::Assertions.instance.isValidAssertType(_a)
              Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " assertType : #{_assertType}"

              if _assertType && _assertType[:cmd]=='url'
                _executeIt=Scoutui::Base::Assertions.instance.isUrlMatch(my_driver, _a)
              elsif _assertType && _assertType[:cmd]=='compare'
                _executeIt=Scoutui::Base::Assertions.instance.compareValue(_a)
              elsif _a.to_s.match(/^\s*(\$\{.*\})\s*(==|!=)(.*)$/)

                _match = _a.match(/^\s*(\$\{.*\})\s*(==|!=)(.*)$/)
                _var  = _match[1]
                _cond = _match[2]
                _val  = _match[3]

                _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=='=='
                  _executeIt=(_uservar_val.match(/#{_val}/) || _uservar_val==_val)
                else
                  _executeIt=(!_uservar_val.match(/#{_val}/) || _uservar_val!=_val)
                end


              elsif Scoutui::Base::Assertions.instance.isEnabledCmd?(_a)
                if !Scoutui::Base::Assertions.instance.isEnabled?(my_driver, _a)
                  Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " isEnabled #{_a} : failed"
                  _executeIt=false
                else
                  Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " IS_ENABLED : #{_a}";
                end


              elsif Scoutui::Base::Assertions.instance.isRoleCmd?(_a)

                if !Scoutui::Base::Assertions.instance.isRole?(_a)
                  Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " isRole #{_a} : failed"
                  _executeIt = false
                else
                  Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " execute => role matched"
                end

              elsif Scoutui::Base::Assertions.instance.isVisibleCmd?(_a)

                if !Scoutui::Base::Assertions.instance.isVisible?(my_driver, _a)
                  Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " visible #{_a} : failed"
                  _executeIt = false
                end

              elsif Scoutui::Base::Assertions.instance.isSelectedCmd?(_a)

                if !Scoutui::Base::Assertions.instance.isSelected?(my_driver, _a)
                  Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " isSelected => false"
                  _executeIt=false
                end

              elsif Scoutui::Base::Assertions.instance.isValueCmd?(_a)

                _tmpRc=Scoutui::Base::Assertions.instance.isValue?(my_driver, _a)

              #  if !Scoutui::Base::Assertions.instance.isValue?(my_driver, _a)
                if !_tmpRc.passed?
                  Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " value doesnt match"
                  _executeIt = false
                end

              end

              if !_executeIt
                break
              end

            end

            if !_executeIt
              Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " Dont execute"
              next
            end


          elsif _execute_when.is_a?(String)
            _rc=Scoutui::Base::Assertions.instance.isVisible(my_driver, _execute_when, _reqid, true)

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

            if !_rc
              Scoutui::Logger::LogMgr.instance.info " Execute_When: true - skip #{e[STEP_KEY]}"
              next
            end
          end

        end



        skipIt = (!_skip.nil?) && (_skip.to_s.strip.downcase=='true')
        Scoutui::Logger::LogMgr.instance.info "\to skip : #{skipIt}" if Scoutui::Utils::TestUtils.instance.isDebug?

        if skipIt
          Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " SKIP - #{_name}" if Scoutui::Utils::TestUtils.instance.isDebug?
          next
        end

        if e[STEP_KEY].has_key?('load') && e[STEP_KEY]['load'].has_key?('command')
          _id = e[STEP_KEY]['load']['id'].to_s
          _c = e[STEP_KEY]['load']['command'].to_s
          CmdShellMgr::DSL.instance.cmd(:cmd => "command(#{_id}, #{_c})")
          next
        end

        if e[STEP_KEY].has_key?('command')
          _id = e[STEP_KEY]['command']['id'].to_s
          _rc=CmdShellMgr::DSL.instance.cmd(:cmd => "execute(#{_id})")
          Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " rc => #{_rc}"
          next
        end

        if e[STEP_KEY].has_key?('getResults')
          _id = e[STEP_KEY]['getResults']['id'].to_s
          _rc = CmdShellMgr::DSL.instance.cmd(:cmd => "getResults(#{_id})")
          Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " rc => #{_rc}"

          if e[STEP_KEY]['getResults'].has_key?('capture')
            m2=CmdShellMgr::DSL.instance.cmd(:cmd => "getResult(#{_id}).capture(#{e[STEP_KEY]['getResults']['capture'].to_s})")
            Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " Capture => #{m2}"


            if e[STEP_KEY]['getResults'].has_key?('assignto')
              Scoutui::Base::UserVars.instance.setVar(e[STEP_KEY]['getResults']['assignto'], m2)
            end
          end


          next
        end


        # 5150
        if e[STEP_KEY].has_key?('executejs')

          fcnId = e[STEP_KEY]['id'].to_s

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

          _jsContent = Scoutui::Base::TestData.instance.getJS(fcnId)

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

          if _jsContent
            my_driver.execute_script(_jsContent)
          end

          e[STEP_KEY]['executejs'].each_key do |fcnToCall|
            Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " => #{fcnToCall}"


            _args=[]

            e[STEP_KEY]['executejs'][fcnToCall].each do |arg|
              Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " ||| arg:  #{arg}"

              if arg.match(/^\s*\//)
                _args << Scoutui::Base::QBrowser.getObject(my_driver, arg, Scoutui::Commands::Utils.instance.getTimeout)
              else
                _args << arg
              end

            end

            argString=""

            if e[STEP_KEY]['executejs'][fcnToCall].length > 1
              e[STEP_KEY]['executejs'][fcnToCall].length.times { |_t|

                argString+="arguments[#{_t}], "
              }
            else
               argString="arguments[0]"
            end


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

         #   _obj = Scoutui::Base::QBrowser.getObject(my_driver, '//body', Scoutui::Commands::Utils.instance.getTimeout)

          #  my_driver.execute_script("return #{fcnToCall}(arguments[0]);", _args[0])
            if _args.length==0
              my_driver.execute_script("#{_jsContent}; return #{fcnToCall}(arguments[0]);")
            elsif _args.length == 1
              my_driver.execute_script("#{_jsContent}; return #{fcnToCall}(arguments[0]);", _args[0])
            elsif _args.length==2
              my_driver.execute_script("#{_jsContent}; return #{fcnToCall}(arguments[0], arguments[1]);", _args[0], _args[1])
            elsif _args.length==3
              my_driver.execute_script("#{_jsContent}; return #{fcnToCall}(arguments[0], arguments[1], arguments[2]);", _args[0], _args[1], _args[2])
            elsif _args.length==4
              my_driver.execute_script("#{_jsContent}; return #{fcnToCall}(arguments[0], arguments[1], arguments[2], arguments[3]);", _args[0], _args[1], _args[2], _args[3])
            end

          # my_driver.execute_script("hlt = function(c) { c.style.border='solid 5px rgb(233, 16, 16)'; }; return hlt(arguments[0]);", _obj)

            # page:
            #     name: LoadJS
            # action: loadjs
            # files:
            ##     - "../commands/general.js"
            #_cmd='loadjs'
            #_pg={"page" => { "action" => "loadjs", "files" => ["../commands/general.js"] } }
            #_c = Scoutui::Commands::LoadJs.new(_pg)
            #_c.run(driver: my_driver, dut: _pg)


            # page:
            #     name: Run JS function
            # executejs:
            #     updateLoginBackground:
            #     - "//body"
            # - "signin signin-3 cnqr-theme-11"



          end


        end


        if !isRun(e).nil?


          tmpSettings=test_settings.dup
          tmpSettings["dut"]=Scoutui::Base::UserVars.instance.normalize(e[STEP_KEY]["run"].to_s)

          Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " ========> RUN #{tmpSettings['dut']} <================="


          Scoutui::Logger::LogMgr.instance.info " RUN Command file : #{tmpSettings["dut"]}"
          processFile(eyeScout, tmpSettings, strategy)
          Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " Completed execution of subfile"
          next

        end

        if !(_action.nil? || _action.to_s.empty?)

          Scoutui::Logger::LogMgr.instance.asserts.info "Verify #{_action} is a valid command - #{Scoutui::Commands::Utils.instance.isValid?(_action).to_s}"
          Testmgr::TestReport.instance.getReq('Command').get_child('isValid').add(Scoutui::Commands::Utils.instance.isValid?(_action), "Verify #{_action} is a valid command")

          begin

            if _action.is_a?(String) && _action=='stop'
              Scoutui::Logger::LogMgr.instance.info " STOP TEST"
              break;
            end

            _command = eyeScout.getStrategy().processCommand(_action, e)

            Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " _command.Result => #{_command}, Passed? : #{_command.passed?}"

            if my_driver.window_handles.length > totalWindows
              Scoutui::Logger::LogMgr.instance.info "[post-cmd] Total Windows : #{my_driver.window_handles.length.to_s}"
            end


          #  if !eyeScout.getStrategy().processCommand(_action, e)
            if !_command.wasExecuted?
              processCommand(_action, e, my_driver)
            else
              if Scoutui::Utils::TestUtils.instance.isFailFast? && !_command.passed?
                Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + "FAIL FAST => #{_command.passed?}"
                Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " Failfast.";
                Scoutui::Utils::TestUtils.instance.setState(:abort, "Step #{i.to_s} : #{_name.to_s} : #{_action.to_s}")
                takeScreenShot(my_driver, "step_#{i}.failed")
                return
              end
              Scoutui::Logger::LogMgr.instance.warn __FILE__ + (__LINE__).to_s + " Command #{_action} was already executed in Strategy"
            end

            processExpected(my_driver, e)
            processAssertions(my_driver, e)
            _assertResult=processAsserts(my_driver, e[STEP_KEY]["asserts"])

            Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " ======  assertResults : #{_assertResult}"



            if e[STEP_KEY].has_key?("highlight") && e[STEP_KEY]["highlight"].has_key?("locators")
              _cmd="Highlight"

              begin
                _c = Scoutui::Commands::Highlight.new('highlight')

                if e[STEP_KEY]["highlight"].has_key?("assert") && e[STEP_KEY]["highlight"]["assert"].to_s.match(/\s*true\s*$/)
                  _c.enableAsserts()
                else
                  _c.disableAsserts()
                end

                _pg={"page" => { "locators" => e[STEP_KEY]["highlight"]["locators"]} }
                _c.run(driver: my_driver, dut: _pg)

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

            end

            if !_assertResult && Scoutui::Utils::TestUtils.instance.isFailFast?
              ## Take failing snapshot

              _shotName="step_#{i}.failed"
              if !_name.nil?
                _shotName = "#{_shotName}.#{_name.to_s}"
              end

              takeScreenShot(my_driver, _shotName)

              Scoutui::Utils::TestUtils.instance.setState(:abort, "Step #{i.to_s}. #{_name.to_s}")
              return
            end


            ##
            # SaveAs
            ##
            if e[STEP_KEY].has_key?('saveas')
              # processSaveAs(e)

              _saveAs = e[STEP_KEY]['saveas']['file'].to_s

              Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " == Process SaveAs #{_saveAs}=="

              begin
                _f=File.open(_saveAs, 'w')

                if _saveAs.match(/.*\.json\s*$/)
                  _f.puts Scoutui::Utils::TestUtils.instance.expandVars(e[STEP_KEY]['saveas']['data']).to_json

                elsif _saveAs.match(/.*\.(yml|yaml)\s*$/i)
                  Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " Generate a YAML file"
                  _f.write(Scoutui::Utils::TestUtils.instance.expandVars(e[STEP_KEY]['saveas']['data'].to_yaml))
                else
                  Scoutui::Logger::LogMgr.instance.warn __FILE__ + (__LINE__).to_s + " Unknown file extension."
                end

              rescue => ex
                Scoutui::Logger::LogMgr.instance.warn __FILE__ + (__LINE__).to_s + " #{ex}"
                Scoutui::Logger::LogMgr.instance.warn  ex.backtrace
              ensure
                _f.close
              end

            end


            if Scoutui::Utils::TestUtils.instance.screenShots? || (Scoutui::Utils::TestUtils.instance.screenShotsOnFailure? && !_assertResult)
              _shotName="step_#{i}"
              if !_name.nil?
                _shotName = "#{_shotName}.#{_name.to_s}"
              end

              takeScreenShot(my_driver, _shotName)
            end

            if false && Scoutui::Utils::TestUtils.instance.screenShots?
              _saveScreenAs=Scoutui::Utils::TestUtils.instance.sanitize_filename(_name)
              Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " ScreenSave : #{_saveScreenAs}"


              if !File.directory?(Scoutui::Utils::TestUtils.instance.screenShotsDir)
                FileUtils::mkdir_p Scoutui::Utils::TestUtils.instance.screenShotsDir
              end

              _fullPath=Scoutui::Utils::TestUtils.instance.screenShotsDir + '/' + _saveScreenAs + '.png'
              my_driver.save_screenshot(_fullPath)
            end

            if isSnapIt(e)

              if QBrowser.existsAlert?(my_driver)
                Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " Snapit with existing Alert"
              end

              if !_region.nil?

                Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " snapit.region: #{_region}"
                _frames = Scoutui::Base::Assertions.instance._parseFrameLocator(_region)

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



                if _frames.has_key?('frame')
                  my_driver.switch_to.default_content
                  Scoutui::Commands::Utils.instance.resetFrameSearch
                  Scoutui::Commands::Utils.instance.setEnableFrameSearch(_frames['frame'])

                  _obj=Scoutui::Base::QBrowser.findElement(my_driver, _frames['locator]'], Scoutui::Commands::Utils.instance.getFrameSearch(),  Scoutui::Commands::Utils.instance.getTimeout)
                  Scoutui::Base::QBrowser.highlight(my_driver, obj)

                  Scoutui::Base::QBrowser.switch_frame(my_driver, _frames['frame'])

                  eyeScout.check_window(_name, _frames['locator'])
                else
                  eyeScout.check_window(_name, Scoutui::Base::UserVars.instance.normalize(_region))
                end


              else
                eyeScout.check_window(_name)
              end
            end

          rescue => ex
            "Backtrace:\n\t#{ex.backtrace.join("\n\t")}"

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

          end

          next
        end


        if e[STEP_KEY].has_key?("url")
          url = e[STEP_KEY]["url"].to_s
          eyeScout.getStrategy().processCommand('navigate(' + url + ')', e)
        end

        ## 5150 Do-Until
        doUntil = Scoutui::Commands::DoUntil.new(my_driver)
        _bUntil = doUntil.do_until(e[STEP_KEY])

        Scoutui::Logger::LogMgr.instance.info "\to Expected:  #{e[STEP_KEY]['expected'].class.to_s}"  if Scoutui::Utils::TestUtils.instance.isDebug?

        processExpected(my_driver, e)
        processAssertions(my_driver, e)
        _assertResult=processAsserts(my_driver, e[STEP_KEY]["asserts"])   # 5150

        if e[STEP_KEY].has_key?('accessible') && e[STEP_KEY]['accessible'].to_s.match(/true/)
          Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " ** Accessibility **"
          #STDIN.gets
        end

        Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " ======  assertResults : #{_assertResult}"

        if e[STEP_KEY].has_key?("highlight") && e[STEP_KEY]["highlight"].has_key?("locators")
          _cmd="Highlight"
          _c = Scoutui::Commands::Highlight.new('highlight')
          _c.run(driver: my_driver, dut: e[STEP_KEY])
        end


        if isSnapIt(e)
          if  !_region.nil?
            eyeScout.check_window(_name, Scoutui::Base::UserVars.instance.normalize(_region))
          else
            eyeScout.check_window(_name)
          end
        end

        Scoutui::Logger::LogMgr.instance.info "\to links : #{e[STEP_KEY]['links'].class.to_s}"  if Scoutui::Utils::TestUtils.instance.isDebug?

        if e[STEP_KEY].has_key?('links')
          links=e[STEP_KEY]['links']

          links.each_pair do |link_name, xpath|
            Scoutui::Logger::LogMgr.instance.info "\t\t#{link_name} => #{xpath}"  if Scoutui::Utils::TestUtils.instance.isDebug?

            obj = QBrowser.getObject(my_driver, xpath, Scoutui::Commands::Utils.instance.getTimeout)
            Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " [click]: link object => #{obj.to_s}"  if Scoutui::Utils::TestUtils.instance.isDebug?
            obj.click

            if !_region.nil?
              eyeScout.check_window(_name, _region)
            else
              eyeScout.check_window(link_name)
            end

          end
        end

      end


    end
processPageElement(my_driver, k, xpath) click to toggle source
# File lib/scoutui/base/visual_test_framework.rb, line 39
def self.processPageElement(my_driver, k, xpath)

  Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " processPageElement(#{xpath})"
  processed=false
  _obj=nil

  if !xpath.match(/^\s*page\(.*\)\s*$/).nil?

    processed=true

    # Check if this is a form

    page_elt = Scoutui::Utils::TestUtils.instance.getPageElement(xpath)
    Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " Process page request #{page_elt} => #{page_elt.class.to_s}"


    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
    end

    Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " SubElts => #{sub_elts}"

    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

      _obj = Scoutui::Base::QBrowser.getFirstObject(my_driver, xpath, Scoutui::Commands::Utils.instance.getTimeout)

      _req = nil

      if page_elt.has_key?('reqid')
        _req=page_elt['reqid'].to_s
      end

      Scoutui::Base::Assertions.instance.assertPageElement(k, page_elt, _obj, my_driver, _req)

      if page_elt.has_key?('asserts')
        Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " ** process Asserts #{page_elt['asserts']} **"
        #STDIN.gets
      end


    elsif sub_elts > 0
      Scoutui::Logger::LogMgr.instance.info __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})"

          _obj=nil

          if _v.is_a?(Array)
            Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " Arrays - TBD => #{_v}"
          end


          if _v.is_a?(String)
            Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " #{_v} is a string - next"
            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

          _req = nil

          if _v.has_key?('reqid')
            _req=_v['reqid'].to_s
            Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " temporary update REQID to #{_req}"
          end

          if _v.has_key?('locator')
            _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'])

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

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


          if _v.has_key?('asserts')
            Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " ** process Asserts **"
            _v['asserts'].each do | _ass|
              Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " => #{_ass}"
            end


            # Should be refactored (TBD)
            _backupReq = Scoutui::Utils::TestUtils.instance.getReq()
            Scoutui::Utils::TestUtils.instance.setReq(_req) if !_req.nil?

            _assertResult=processAsserts(my_driver, _v["asserts"])

            Scoutui::Utils::TestUtils.instance.setReq(_backupReq) if !_req.nil?

          end


          if Scoutui::Base::Assertions.instance.visible_when_visible(_k, _v, _obj, my_driver, _req)
            next
          elsif Scoutui::Base::Assertions.instance.visible_when_always(_k, _v, _obj, _req)
            next
          elsif Scoutui::Base::Assertions.instance.visible_when_never(_k, _v, _obj, _req)
            next
          elsif Scoutui::Base::Assertions.instance.visible_when_title(_k, _v, _obj, my_driver, _req)
            next
          elsif Scoutui::Base::Assertions.instance.visible_when_value(_k, _v, my_driver, _req)
            next
          elsif _v.has_key?('visible_when') && !_v['visible_when'].is_a?(Array)

            if _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}"
                Testmgr::TestReport.instance.getReq(_req).get_child('visible_when').add(!_obj.nil?, "Verify #{_k} #{_locator}  visible when role #{_role}")
              end

            end
          elsif _v.has_key?('visible_when') && _v['visible_when'].is_a?(Array)
            Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " visible_when : (Array) - TBD  #{_v['visible_when']}"

            _v['visible_when'].each do |_vwhen|
              Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " #{_vwhen}  #{_vwhen.class}"

              Scoutui::Base::Assertions.instance.assertPageElement(_k, _vwhen, _obj, my_driver, _req)


            end

          else
            Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " Unknown: #{_k} : #{_v}"
          end



        rescue => ex
          Scoutui::Logger::LogMgr.instance.warn __FILE__ + (__LINE__).to_s + " Error during processing: #{ex}"
          Scoutui::Logger::LogMgr.instance.warn __FILE__ + (__LINE__).to_s +  "Backtrace:\n\t#{ex.backtrace.join("\n\t")}"
        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 Scoutui::Utils::TestUtils.instance.isDebug?

        if _v.has_key?('locator')
          _locator = _v['locator'].to_s
          Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " " + _k.to_s + " => " + _locator if Scoutui::Utils::TestUtils.instance.isDebug?

          #  _locator = Scoutui::Utils::TestUtils.instance.getPageElement(_v['locator'])

          _obj = Scoutui::Base::QBrowser.getFirstObject(my_driver, _locator)

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

      end

      # next

    elsif page_elt.is_a?(Hash) && page_elt.has_key?('asserts')
      # 5150
      Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " ** asserts from PageElement verification **"
      Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " =============="; #STDIN.gets
    end


  end

  _obj

end
takeScreenShot(drv, _name) click to toggle source
# File lib/scoutui/base/visual_test_framework.rb, line 15
def self.takeScreenShot(drv, _name)
  _saveScreenAs=Scoutui::Utils::TestUtils.instance.sanitize_filename(_name)
  Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " ScreenSave : #{_saveScreenAs}"

  _dir = Scoutui::Utils::TestUtils.instance.screenShotsDir
  rc=false
  begin

    if !_dir.nil? && !File.directory?(_dir)
      FileUtils::mkdir_p Scoutui::Utils::TestUtils.instance.screenShotsDir
    end

    _dir='.' if _dir.nil?
    _fullPath=_dir + '/' + _saveScreenAs + '.png'
    rc=Scoutui::Base::QBrowser.saveScreenShot(drv, _fullPath)

  rescue => ex
    Scoutui::Logger::LogMgr.instance.warn __FILE__ + (__LINE__).to_s + " Error during processing screenshot with name #{_name.to_s}: #{ex}"
    Scoutui::Logger::LogMgr.instance.warn __FILE__ + (__LINE__).to_s +  "Backtrace:\n\t#{ex.backtrace.join("\n\t")}"
  end

  rc
end
verifyCondition(my_driver, xpath) click to toggle source
# File lib/scoutui/base/visual_test_framework.rb, line 347
def self.verifyCondition(my_driver, xpath)
  wasProcessed=false

  if !xpath.match(/^page\([\w\d]+\)/).nil?

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

    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?

    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

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

          wasProcessed=true

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

      end


    end

    wasProcessed
  end

end