class Scoutui::Commands::ClickObject

Public Instance Methods

_whenClicked(page_elt) click to toggle source
# File lib/scoutui/commands/click_object.rb, line 7
def _whenClicked(page_elt)

  return if page_elt.nil?

  if page_elt.is_a?(Hash) && page_elt.has_key?('when_clicked')
    Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " Verify #{page_elt['when_clicked']}"

    page_elt['when_clicked'].each do |_elt|

      _r = _elt.keys[0].to_s

      _pg = _elt[_r]

      #    _c = Scoutui::Commands::VerifyElement.new("verifyelement(" + _elt + ")")
      #    _c.execute(@drv)

      Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " _whenClicked -> assertions (#{_pg}, #{_r.to_s})"


      if _pg.is_a?(Array)
        _pg.each do |_pg2|
          isVisible=Scoutui::Base::Assertions.instance.isVisible(@drv, _pg2, _r)
        end
      elsif _pg.is_a?(String)
        isVisible=Scoutui::Base::Assertions.instance.isVisible(@drv, _pg, _r)
      else
        Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " => #{_pg}"
      end

    end

  end

end
execute(drv, e=nil) click to toggle source
# File lib/scoutui/commands/click_object.rb, line 44
def execute(drv, e=nil)

  retries  = Scoutui::Utils::TestUtils.instance.retries()
  retries = 1 if retries < 1

  waitTime = Scoutui::Utils::TestUtils.instance.getDefaultWait

  Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " click_object.execute: #{@cmd} with #{retries} retries"
  obj=nil

  @drv=drv if !drv.nil?

  bm=nil
  all_windows = @drv.window_handles.size

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

  _locator = @cmd.match(/^\s*click\s*\((.*)\)\s*$/i)[1].to_s.strip
  Scoutui::Logger::LogMgr.instance.command.info __FILE__ + (__LINE__).to_s + " clickObject => #{_locator}"

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

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

  _clicked=false

  _startTime=Time.now
  _endTime=nil
  _clickTime=0
  isEnabled=nil

  begin

      if _locator

        (0..retries).each do |_i|

          _retry = true
          Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " Retry #{_i} ======> click(#{_locator})"

          begin

            _startTime=Time.now

            wait = Selenium::WebDriver::Wait.new(:timeout =>  waitTime)
            isEnabled = wait.until {
              obj=Scoutui::Base::QBrowser.getElement(@drv, _locator, Scoutui::Commands::Utils.instance.getFrameSearch(),  Scoutui::Commands::Utils.instance.getTimeout)
              obj.is_a?(Selenium::WebDriver::Element) && obj.enabled? && obj.displayed?
            }

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

            if isEnabled # && obj.is_a?(Selenium::WebDriver::Element)

              begin
                @drv.action.move_to(obj).perform
              rescue => ex
                Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " #{ex.class.to_s}"
                Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s +  ex.backtrace.join("\n\t")
              end

              bm=Benchmark.measure {
                obj.click
              }

              _endTime=Time.now
              _clickTime = (_endTime - _startTime)

              setBenchmark(bm)
              _retry = false
              _clicked=true

              if e.is_a?(Hash) && e.has_key?('page') && e['page'].has_key?('highlight') && e['page']['highlight']
                #
                # page:
                #  highlight: true
                #
                obj=Scoutui::Base::QBrowser.highlight(@drv, obj)
                Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " highlight then click : #{obj}"
              end

              if e.is_a?(Hash) && e['page'].has_key?('then')
                thenClause = Scoutui::Commands::ThenClause.new(@drv)
                thenClause.execute(e);
              end

              doUntil = Scoutui::Commands::DoUntil.new(@drv)

              _tm= {:start => Time.now, :end => 0 }
              _bUntil = doUntil.do_until(e)
              _tm[:end]=Time.now
              Testmgr::TestReport.instance.getReq(_req).testcase('until').add(_bUntil, Scoutui::Base::UserVars.instance.normalize("Verify after click, do-until met #{_bUntil}"), (_tm[:end] - _tm[:start]))


            elsif obj.is_a?(Selenium::WebDriver::Element) && obj.displayed?
              Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + "  object is displayed, but not enabled"
            end

          rescue Selenium::WebDriver::Error::StaleElementReferenceError => ex
            Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " Retry #{_i} - Selenium::WebDriver::Error::UnknownError"
            Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s +  ex.backtrace.join("\n\t")
            _retry=true


          rescue Selenium::WebDriver::Error::TimeOutError => ex
            _retry=true

          rescue Selenium::WebDriver::Error::UnknownError => ex
            Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " Retry #{_i} - Selenium::WebDriver::Error::UnknownError"
            Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s +  ex.backtrace.join("\n\t")
            _retry=true
          end

          break if !_retry

          sleep(0.25)
        end

        Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " clicked(#{_locator}): #{_clicked}"
        Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " o isWebDriverElement : #{obj.is_a?(Selenium::WebDriver::Element)}"

      #  isEnabled = obj.enabled? if obj.is_a?(Selenium::WebDriver::Element)

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

      #  if obj.is_a?(Selenium::WebDriver::Element) && !obj.enabled?
        if !isEnabled.nil? && !isEnabled
          Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + "o Attemping to click a disabled element : #{_locator}"
        end

      #  puts __FILE__ + (__LINE__).to_s + " Pause for debug"; STDIN.gets

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

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

        if all_windows > @drv.window_handles.size
          Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " WINDOW was CLOSED.  Activate first window as our default";
          @drv.switch_to.window @drv.window_handles.first
          Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " Switched to first window"
        end

        _whenClicked(page_elt)

        if e.is_a?(Hash) && e.has_key?('page') && e['page'].has_key?('then')
          thenClause = Scoutui::Commands::ThenClause.new(@drv)
          Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " thenClause => #{thenClause.class}"
          thenClause.execute(e)
        end

      #  _then(e)

      else
        Scoutui::Logger::LogMgr.instance.warn __FILE__ + (__LINE__).to_s + " Unable to click object that is not displayed."
      end


  rescue => ex
    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


  Scoutui::Logger::LogMgr.instance.asserts.info "Verify object to click exists #{_locator} : #{obj.class.to_s} - #{!obj.nil?.to_s}"
  Scoutui::Logger::LogMgr.instance.asserts.info __FILE__ + (__LINE__).to_s + " Verify clicked #{_locator} - #{_clicked.to_s}"

  Testmgr::TestReport.instance.getReq(_req).testcase('click').add(!obj.nil?, "Verify object to click exists #{_locator} : #{obj.class.to_s}")
  Testmgr::TestReport.instance.getReq(_req).testcase('click').add(_clicked, "Verify clicked #{_locator}", _clickTime)


  if !_clicked
    Scoutui::Logger::LogMgr.instance.asserts.info __FILE__ + (__LINE__).to_s + "   FAILED CLICK: #{_locator}"
    # @drv.save_screenshot("/tmp/clickobject.failed.png")
  end

  setResult(_clicked)
end