module Scoutui::Commands

Ref

http://stackoverflow.com/questions/15164742/combining-implicit-wait-and-explicit-wait-together-results-in-unexpected-wait-ti#answer-15174978

selenium.googlecode.com/svn-history/r15117/trunk/docs/api/rb/Selenium/WebDriver/Support/Select.html#selected_options-instance_method

Constants

SIMPLE_CMDS
STEP_KEY

Public Class Methods

processCommand(_action, e, my_driver) click to toggle source
# File lib/scoutui/commands/commands.rb, line 232
def self.processCommand(_action, e, my_driver)
  Scoutui::Logger::LogMgr.instance.commands.debug __FILE__ + (__LINE__).to_s + " enter [processCommand(#{_action}, #{e})"

  _aborted=false
  _cmd=nil

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

  begin

    _totalWindows = my_driver.window_handles.length
    Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " Current Total Windows : #{_totalWindows}"

    _c=nil

    ##
    # Check if an alert exists.
    ##
    begin
      my_driver.switch_to.alert
      Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " Alert currently active."
    rescue Selenium::WebDriver::Error::NoSuchAlertError
      my_driver.switch_to.default_content
    rescue Selenium::WebDriver::Error::WebDriverError
      # Support for phantomjs/ghostdriver per switch_to.alert()
      Scoutui::Logger::LogMgr.instance.warn __FILE__ + (__LINE__).to_s + " WebDriverError.switch_to.alert"
    end

    if Scoutui::Commands::Utils.instance.isWhileDo?(_action)
      Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " === WhileDo ==="
      _cmd='whileDo'
      _c = Scoutui::Commands::WhileDo.new(my_driver)
      _c.execute(e['page']['action'])
      Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + "   WHileDo Pause post-execute"; #STDIN.gets

    elsif Scoutui::Commands::Utils.instance.isDoUntil?(_action)

      Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " == process DoUntil : #{e}"
      _cmd='doUntil'
      _c = Scoutui::Commands::DoUntil.new(my_driver)
      _c.do_until(e['page']['action'])


      Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " Pause on DO_UNTIL => #{_c}  passed? : #{_c.passed?}"; # STDIN.gets


    elsif Scoutui::Commands::Utils.instance.isPause?(_action)
      _cmd='pause'
      _c = Scoutui::Commands::Pause.new(nil)
      _c.execute(e);

    elsif Scoutui::Commands::Utils.instance.isExecuteCommands?(_action)
      _cmd='executecommands'
      _c = Scoutui::Commands::ExecuteCommands.new(e)
      _c.run(driver: my_driver, dut: e)

    elsif Scoutui::Commands::Utils.instance.isDefineCommands?(_action)
      _cmd='definecommands'
      _c = Scoutui::Commands::DefineCommands.new(e)
      _c.run(driver: my_driver, dut: e)

    elsif Scoutui::Commands::Utils.instance.isLoadDB?(_action)
      _cmd='loaddb'
      _c = Scoutui::Commands::LoadDB.new(e)
      _c.run(driver: my_driver, dut: e)

    elsif Scoutui::Commands::Utils.instance.isConnect?(_action)
      _cmd='connect'
      _c = Scoutui::Commands::Connect.new(e)
      _c.run(driver: my_driver, dut: e)

    elsif Scoutui::Commands::Utils.instance.isLoadData?(_action)
      _cmd='loaddata'
      _c = Scoutui::Commands::LoadData.new(e)
      _c.run(driver: my_driver, dut: e)

    elsif Scoutui::Commands::Utils.instance.isLoadJs?(_action)
      _cmd='loadjs'
      _c = Scoutui::Commands::LoadJs.new(e)
      _c.run(driver: my_driver, dut: e)

    elsif Scoutui::Commands::Utils.instance.isLoadRequirements?(_action)
      _cmd='loadrequirements'
      _c = Scoutui::Commands::LoadRequirements.new(e)
      _c.run(driver: my_driver, dut: e)
    elsif Scoutui::Commands::Utils.instance.isAssignments?(_action)
      _cmd='assignments'
      if e['page'].has_key?('vars')
        e['page']['vars'].each do |_a|

          Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " process assign var: #{_a}"
          Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + "  Process Assignment.var : #{_a}"

          begin
            _caborted=false

            if !Scoutui::Commands::Utils.instance.isAssignVar?(_a)
              _m=_a.match(/([\w\_])+\=(.*)/)
              _a="assign(#{_m[1]},#{_m[2]})"
            end

            _c = Scoutui::Commands::AssignVar.new(_a)
            _rc=_c.run(driver: my_driver, dut: e)
         #  _c.setResult(_rc)

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

          _testcase = Scoutui::Utils::TestUtils.instance.getTC() || _cmd.downcase

          Testmgr::TestReport.instance.getReq(_req).get_child(_testcase).add(!_caborted, "Assert command assign did not abort")
        end
      end


    elsif Scoutui::Commands::Utils.instance.isAssignVar?(_action)
      Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " == AssignVar : #{_action}"
      _cmd='assignvar'
      _c = Scoutui::Commands::AssignVar.new(_action)
      _c.run(driver: my_driver, dut: e)

    elsif Scoutui::Commands::Utils.instance.isDumpVars?(_action)
      _cmd='dumpvars'
      _c = Scoutui::Commands::DumpVars.new(_action)
      _c.run(driver: my_driver, dut: e)

    elsif Scoutui::Commands::Utils.instance.isSelectWindow?(_action)
      _cmd='SelectWindow'
      _c = Scoutui::Commands::SelectWindow.new(_action)
      _c.execute(my_driver)
    elsif Scoutui::Commands::Utils.instance.isClick?(_action)
      _cmd='Click'
      _c = Scoutui::Commands::ClickObject.new(_action)
      _c.run(driver: my_driver, dut: e)

    elsif Scoutui::Commands::Utils.instance.isExistsAlert?(_action)
      _cmd='ExistsAlert'
      _c = Scoutui::Commands::JsAlert::ExistsAlert.new(_action)
      rc=_c.execute(my_driver)

    elsif Scoutui::Commands::Utils.instance.isFrame?(_action)
      _cmd='IsFrame'
      _c = Scoutui::Commands::SwitchFrame.new(_action)
      rc=_c.execute(my_driver, e)

    elsif Scoutui::Commands::Utils.instance.isGetAlert?(_action)
      _cmd='GetAlert'
      _c = Scoutui::Commands::ExistsAlert.new(_action)
      rc=_c.execute(my_driver)


    elsif Scoutui::Commands::Utils.instance.isHighlight?(_action)
      _cmd="Highlight"
      _c = Scoutui::Commands::Highlight.new(_action)
      _c.run(driver: my_driver, dut: e)

    elsif  Scoutui::Commands::Utils.instance.isMouseOver?(_action)
      _cmd='MouseOver'
      _c = Scoutui::Commands::MouseOver.new(_action)
      _c.execute(my_driver)

    elsif Scoutui::Commands::Utils.instance.isSelect?(_action)
      _cmd='Select'
      _c = Scoutui::Commands::SelectObject.new(_action)
      _c.run(driver: my_driver, dut: e)

    elsif Scoutui::Commands::Utils.instance.isFillForm?(_action)

      _cmd='FillForm'
       _c = Scoutui::Commands::FillForm.new(_action)

       _rc=false
       begin
        _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.debug __FILE__ + (__LINE__).to_s + " DUT => #{dut}"
        _f = Scoutui::Utils::TestUtils.instance.getForm(_form)
        _f.dump()
        _f.verifyForm(my_driver)
        _f.fillForm(my_driver, dut)
         _rc=true
       rescue
         ;
       end

      _c.setResult(_rc)

    elsif Scoutui::Commands::Utils.instance.isSubmitForm?(_action)
      _cmd='SubmitForm'
      _c = Scoutui::Commands::SubmitForm.new(_action)
      _c.execute(my_driver)


    elsif Scoutui::Commands::Utils.instance.isNavigate?(_action)
      _cmd='Navigate'
      _c = Scoutui::Commands::UpdateUrl.new(_action)
      _c.run(driver: my_driver)


    elsif Scoutui::Commands::Utils.instance.isUploadFiles?(_action)
      _cmd='UploadFiles'
      _c = Scoutui::Commands::UploadFiles.new(_action)
      rc=_c.execute(my_driver, e)

    elsif Scoutui::Commands::Utils.instance.isVerifyElt?(_action)
      _cmd='VerifyElement'
      _c = Scoutui::Commands::VerifyElement.new(_action)
      _c.run(driver: my_driver)

    elsif Scoutui::Commands::Utils.instance.isSleep?(_action)
      _cmd='Sleep'
      _c = Scoutui::Commands::Sleep.new(_action)
      _c.run(driver: my_driver)

    elsif Scoutui::Commands::Utils.instance.isType?(_action)
      _cmd='Type'
      _c = Scoutui::Commands::Type.new(_action)
      _c.run(driver: my_driver, dut: e)
    else
      Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " Unknown command : #{_action}"
      rc=false
    end

  rescue => e
    Scoutui::Logger::LogMgr.instance.debug "#{e.class.to_s} Error during processing: #{$!}"
    Scoutui::Logger::LogMgr.instance.debug "Backtrace:\n\t#{e.backtrace.join("\n\t")}"
    Scoutui::Logger::LogMgr.instance.debug  "Backtrace:\n\t#{e.backtrace.join("\n\t")}"
    _aborted=true
    rc=false
  end

  if my_driver.window_handles.length > _totalWindows
    Scoutui::Logger::LogMgr.instance.info " New Window generated from command #{_cmd}."
  end

  Testmgr::TestReport.instance.getReq(_req).get_child(_cmd.downcase).add(!_aborted, "Verify command #{_cmd} did not abort")

  Scoutui::Logger::LogMgr.instance.commands.debug __FILE__ + (__LINE__).to_s + " exit [processCommand(#{_action})  => #{_c}"

  _c
end
processCommands(commandList, my_driver) click to toggle source
# File lib/scoutui/commands/commands.rb, line 217
def self.processCommands(commandList, my_driver)
  Scoutui::Logger::LogMgr.instance.debug " enter [processCommands]"
  commandList.each do |cmd|
    begin
      rc=processCommand(cmd[:command], cmd[:e], my_driver)
    rescue => ex
      Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " Error during processing: #{$!}"
      Scoutui::Logger::LogMgr.instance.debug "Backtrace:\n\t#{e.backtrace.join("\n\t")}"
    end
  end

  Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " exit [processCommands]"
end
simpleCommands(drv, thenList) click to toggle source
# File lib/scoutui/commands/commands.rb, line 20
def self.simpleCommands(drv, thenList)

  rc=true

  begin

    thenList.each do |_subcmd|


      if _subcmd.is_a?(String)

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

        if _subcmd.match(/^\s*press\(__TAB__\)$/)
          drv.action.send_keys(:tab).perform

        elsif Scoutui::Commands::Utils.instance.isHighlight?(_subcmd)

          processCommand(_subcmd, nil, drv)

        elsif _subcmd.match(/^\s*press\(__SHIFT_TAB__\)\s*$/)
          drv.action.key_down(:shift).send_keys(:tab).perform;
          drv.action.key_up(:shift).perform;

        elsif _subcmd.match(/^\s*press\(__DELETE__\)\s*$/)

          drv.action.send_keys(:delete).perform
          _activeElt = drv.switch_to.active_element

        elsif _subcmd.match(/^\s*press\((__ESC__|__ESCAPE__)\)$/)
          drv.action.send_keys(:escape).perform

        elsif _subcmd.match(/^\s*press\(__HOLD_SHIFT__\)\s*$/)
          drv.action.key_down(:shift).perform
          Scoutui::Base::TestContext.instance.set(:shift_down, true)

        elsif _subcmd.match(/^\s*press\(__RELEASE_SHIFT__\)\s*$/)
          drv.action.key_up(:shift).perform
          Scoutui::Base::TestContext.instance.set(:shift_down, false)

        elsif _subcmd.match(/^\s*press\(__HOLD_COMMAND__\)$/)
          drv.action.key_down(:command).perform
          Scoutui::Base::TestContext.instance.set(:command_down, true)

        elsif _subcmd.match(/^\s*press\(__RELEASE_COMMAND__\)$/)
          drv.action.key_up(:command).perform
          Scoutui::Base::TestContext.instance.set(:command_down, false)

        elsif _subcmd.match(/^\s*press\(__CONTROL__\)\s*$/)

          drv.driver.action.key_down(:control).perform
          drv.action.key_up(:control).perform

          # Check for list of elements to click

        elsif _subcmd.match(/^\s*press\(__DOWN__\)\s*$/)
          drv.action.send_keys(:arrow_down).perform
          _activeElt = drv.switch_to.active_element
          Scoutui::Logger::LogMgr.instance.debug  __FILE__ + (__LINE__).to_s + " activeElt.Value: #{_activeElt.attribute('value').to_s}  Text: #{_activeElt.attribute('text').to_s}"

        elsif _subcmd.match(/^\s*press\(__LEFT__\)\s*$/)
          drv.action.send_keys(:arrow_left).perform

        elsif _subcmd.match(/^\s*press\(__RIGHT__\)\s*$/)
          drv.action.send_keys(:arrow_right).perform

        elsif _subcmd.match(/^\s*press\(__UP__\)$/)
          drv.action.send_keys(:arrow_up).perform

        elsif _subcmd.match(/^\s*press\(__SPACE__\)$/)
          drv.action.send_keys(:space).perform

        elsif _subcmd.match(/^\s*press\(__ENTER__\)\s*$/)
          drv.action.send_keys(:enter).perform


        elsif _subcmd.match(/^\s*[fF]ocused\.[Cc]lick\s*$/i)
          _rc=true
          _text=""
          _tagName=""
          begin
            _activeElt = drv.switch_to.active_element
            _tagName=_activeElt.tag_name.to_s
            _text=_activeElt.text

            _activeElt.click
          rescue => ex
            _rc=false
          end

          Testmgr::TestReport.instance.getReq('Simple').get_child('focused.Click').add(_rc, "#{_subcmd.to_s} #{_tagName} #{_text}")

        elsif _subcmd.match(/^\s*[fF]ocused\.[Hh]ighlight(\(.*\))*/i)

          _activeElt = drv.switch_to.active_element

          _id = _activeElt.attribute('id')
          _type = _activeElt.attribute('type')
          _onclick=_activeElt.attribute('onclick')

          if !_id.nil?
            Scoutui::Logger::LogMgr.instance.debug  __FILE__ + (__LINE__).to_s + " => highlight id : #{_id}"
          end

          Scoutui::Logger::LogMgr.instance.debug  __FILE__ + (__LINE__).to_s +  " => type    : #{_type}" if !_type.nil?
          Scoutui::Logger::LogMgr.instance.debug  __FILE__ + (__LINE__).to_s +  " => onclick : #{_onclick}" if !_onclick.nil?

          if !_activeElt.nil?

            _color='red'
            if _subcmd.match(/^\s*[fF]ocused\.[Hh]ighlight\s*\((.*)\)/)
              _color=_subcmd.match(/^\s*[fF]ocused\.[Hh]ighlight\s*\((.*)\)/)[1].to_s
            end

           # Scoutui::Base::QBrowser.highlight(drv, _activeElt, style={"color" => 'rgb(255,16,16)', "border" => 2}, false)
            Scoutui::Base::QBrowser.highlight(drv, _activeElt, style={"color" => _color, "border" => 2}, false)
          end

        elsif _subcmd.match(/^\s*[fF]ocused\.[Hh]over\s*$/i)

          _activeElt = drv.switch_to.active_element
          drv.action.move_to(_activeElt).perform

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

          _activeElt = drv.switch_to.active_element

          if _subcmd.match(/^\s*[fF]ocused.[Tt]ype!\(.*\)$/)
            _activeElt.clear
          end

          _text=_subcmd.match(/^\s*[fF]ocused.[Tt]ype[!]*\((.*)\)$/)[1].to_s

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


          _activeElt.send_keys(_text)

        elsif _subcmd.match(/^\s*[cC]lick\((.*)\)\s*$/)
          # Click on the locator

          _c=Scoutui::Commands.processCommand(_subcmd, nil, drv)
          Scoutui::Logger::LogMgr.instance.debug  __FILE__ + (__LINE__).to_s + " click : #{_c.passed?}"
          Testmgr::TestReport.instance.getReq('Simple').get_child('click').add(_c.passed?, "#{_subcmd.to_s}")


          #_c = Scoutui::Commands::ClickObject.new(_subcmd)
          #_c.run(driver: drv)

        elsif Scoutui::Commands::Utils.instance.isPause?(_subcmd)
          processCommand(_subcmd, nil, drv)

        elsif _subcmd.match(/^\s*select\((.*)\)\s*$/)

          _c=Scoutui::Commands.processCommand(_subcmd, nil, drv)
          Scoutui::Logger::LogMgr.instance.debug  __FILE__ + (__LINE__).to_s + " passsed? : #{_c.passed?}"
          Testmgr::TestReport.instance.getReq('Simple').get_child('select').add(_c.passed?, "#{_subcmd.to_s}")

     #     _c = Scoutui::Commands::SelectObject.new(_subcmd)
     #     _c.run(driver: drv)

        elsif _subcmd.match(/^\s*press\((.*)\)\s*$/)
          _locator = _subcmd.match(/^\s*press\((.*)\)\s*$/)[1].to_s
          _locator = Scoutui::Base::UserVars.instance.normalize(_locator)
          obj = Scoutui::Base::QBrowser.getElement(drv, _locator, Scoutui::Commands::Utils.instance.getFrameSearch(),  Scoutui::Commands::Utils.instance.getTimeout)
          obj.click

        elsif Scoutui::Commands::Utils.instance.isAssignVar?(_subcmd)
          _cmd='assignvar'
          _c = Scoutui::Commands::AssignVar.new(_subcmd)
          _c.run(driver: drv)

        elsif Scoutui::Commands::Utils.instance.isType?(_subcmd)
          _cmd='Type'
          _c = Scoutui::Commands::Type.new(_subcmd)
          _c.run(driver: drv)

        end


      end

    end

  rescue => ex
    Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " Error during processing: #{$!}"
    Scoutui::Logger::LogMgr.instance.debug "Backtrace:\n\t#{e.backtrace.join("\n\t")}"
    rc=false

  end

  rc

end