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