scoutui 2.0.0 → 2.0.1

data/lib/scoutui/commands/click_object.rb

@@ -0,0 +1,45 @@
+require_relative './commands'
+
+module Scoutui::Commands
+
+  class ClickObject < Command
+
+
+    def execute(drv)
+      @drv=drv if !drv.nil?
+
+      _xpath = @cmd.match(/click\s*\((.*)\)/)[1].to_s.strip
+      Scoutui::Logger::LogMgr.instance.command.info __FILE__ + (__LINE__).to_s + " clickObject => #{_xpath}"  if Scoutui::Utils::TestUtils.instance.isDebug?
+
+      _xpath = Scoutui::Base::UserVars.instance.get(_xpath)
+
+      Scoutui::Logger::LogMgr.instance.command.info __FILE__ + (__LINE__).to_s + " | translate : #{_xpath}" if Scoutui::Utils::TestUtils.instance.isDebug?
+
+      _clicked=false
+
+      begin
+        obj = Scoutui::Base::QBrowser.getObject(@drv, _xpath)
+
+        if obj
+          obj.click
+          _clicked=true
+        end
+
+      rescue
+        ;
+      end
+
+      Scoutui::Logger::LogMgr.instance.asserts.info "Verify object to click exists #{_xpath} : #{obj.class.to_s} - #{!obj.nil?.to_s}"
+      Scoutui::Logger::LogMgr.instance.asserts.info "Verify clicked #{_xpath} - #{_clicked.to_s}"
+
+      Testmgr::TestReport.instance.getReq('UI').testcase('click').add(!obj.nil?, "Verify object to click exists #{_xpath} : #{obj.class.to_s}")
+      Testmgr::TestReport.instance.getReq('UI').testcase('click').add(_clicked, "Verify clicked #{_xpath}")
+
+      setResult(_clicked)
+    end
+
+  end
+
+
+
+end

data/lib/scoutui/commands/command.rb

@@ -0,0 +1,56 @@
+
+module Scoutui::Commands
+
+  class Command
+    attr_accessor :description
+    attr_accessor :drv
+    attr_accessor :cmd
+    attr_accessor :rc
+    attr_accessor :locator
+    attr_accessor :executed
+    attr_accessor :executed_result
+
+    def initialize(_cmd, _drv=nil)
+      Scoutui::Logger::LogMgr.instance.commands.debug __FILE__ + (__LINE__).to_s + "  Command.init: #{_cmd.to_s}"
+      @cmd=_cmd
+      @rc=nil
+      @drv=_drv
+      @locator=nil
+      @executed=false
+      @executed_result=nil
+    end
+
+    def setResult(r)
+      Scoutui::Logger::LogMgr.instance.commands.debug " setResult(#{r.to_s})"
+      @executed=true
+      @executed_result=r
+    end
+
+    def executedResult
+      @executed_result
+    end
+
+    def wasExecuted?
+      @executed
+    end
+
+    def setLocator(_locator)
+      @locator=_locator
+    end
+
+    def getLocator()
+      @locator
+    end
+
+    def result
+      @rc
+    end
+
+    def execute(_drv=nil, _dut=nil)
+      raise NotImplementedError
+    end
+
+  end
+
+
+end

data/lib/scoutui/commands/commands.rb

@@ -0,0 +1,133 @@
+require_relative('./command')
+
+module Scoutui::Commands
+
+  STEP_KEY='page'
+
+
+  def self.processCommands(commandList, my_driver)
+
+    commandList.each do |cmd|
+      begin
+        rc=processCommand(cmd[:command], cmd[:e], my_driver)
+      rescue => ex
+        Scoutui::Logger::LogMgr.instance.debug "Error during processing: #{$!}"
+        Scoutui::Logger::LogMgr.instance.debug "Backtrace:\n\t#{e.backtrace.join("\n\t")}"
+      end
+
+    end
+
+  end
+
+  def self.processCommand(_action, e, my_driver)
+    Scoutui::Logger::LogMgr.instance.commands.debug __FILE__ + (__LINE__).to_s + " ===  Process ACTION : #{_action}  ==="  if Scoutui::Utils::TestUtils.instance.isDebug?
+
+    _aborted=false
+    _cmd=nil
+    _totalWindows = my_driver.window_handles.length
+
+    rc=true
+    _req = Scoutui::Utils::TestUtils.instance.getReq()
+
+    begin
+
+      _c=nil
+
+      if Scoutui::Commands::Utils.instance.isPause?(_action)
+        _cmd='pause'
+        _c = Scoutui::Commands::Pause.new(nil)
+        _c.execute(e);
+
+      elsif Scoutui::Commands::Utils.instance.isClick?(_action)
+        _cmd='Click'
+        _c = Scoutui::Commands::ClickObject.new(_action)
+        _c.execute(my_driver)
+
+      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.isGetAlert?(_action)
+        _cmd='GetAlert'
+        _c = Scoutui::Commands::ExistsAlert.new(_action)
+        rc=_c.execute(my_driver)
+
+      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.execute(my_driver)
+
+      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.execute(my_driver)
+
+      elsif Scoutui::Commands::Utils.instance.isVerifyElt?(_action)
+        _cmd='VerifyElement'
+
+        _c = Scoutui::Commands::VerifyElement.new(_action)
+        _c.execute(my_driver)
+
+      elsif Scoutui::Commands::Utils.instance.isType?(_action)
+        _cmd='Type'
+        _c = Scoutui::Commands::Type.new(_action)
+        _c.execute(my_driver)
+      else
+        Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " Unknown command : #{_action}"
+        rc=false
+      end
+
+    rescue => e
+      Scoutui::Logger::LogMgr.instance.debug "Error during processing: #{$!}"
+      Scoutui::Logger::LogMgr.instance.debug "Backtrace:\n\t#{e.backtrace.join("\n\t")}"
+      puts "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"
+    end
+
+    Testmgr::TestReport.instance.getReq(_req).get_child(_cmd.downcase).add(!_aborted, "Verify command did not abort")
+    _c
+  end
+
+
+end

data/lib/scoutui/commands/exists_alert.rb

@@ -0,0 +1,54 @@
+
+
+module Scoutui::Commands
+
+  class ExistsAlert < Command
+
+
+    def execute(drv=nil)
+      @drv=drv if !drv.nil?
+
+      _action = @cmd.match(/(get_*alert|clickjsconfirm|clickjsprompt|clickjsalert)\s*\((.*)\)/i)[2].to_s.strip
+
+      Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " ExistsAlert(#{_action})"  if Scoutui::Utils::TestUtils.instance.isDebug?
+
+      rc=false
+
+      alert=nil
+
+      begin
+        alert=@drv.switch_to.alert
+
+        Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " | alert => #{alert.class.to_s}" if Scoutui::Utils::TestUtils.instance.isDebug?
+
+        if alert.is_a?(Selenium::WebDriver::Alert)
+          if _action.match(/accept/i)
+            alert.accept
+          elsif _action.match(/dismiss/i)
+            alert.dismiss
+          end
+
+          rc=true
+        end
+
+
+      rescue Selenium::WebDriver::Error::NoSuchAlertError
+        ;
+      end
+
+      _req = Scoutui::Utils::TestUtils.instance.getReq()
+
+      Testmgr::TestReport.instance.getReq(_req).testcase(_action).add(!alert.nil?, "Verify alert exists")
+      Testmgr::TestReport.instance.getReq(_req).testcase(_action).add(rc, "Verify processed alert")
+
+      Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " ExistsAlert() => #{rc.to_s}"  if Scoutui::Utils::TestUtils.instance.isDebug?
+      rc
+
+    end
+
+
+  end
+
+
+
+end

data/lib/scoutui/commands/fill_form.rb

@@ -0,0 +1,56 @@
+require_relative './commands'
+
+module Scoutui::Commands
+
+  class FillForm < Command
+    attr_accessor :form
+    attr_accessor :formLocator
+    attr_accessor :dut
+
+    def initialize(_cmd)
+      super(_cmd)
+
+      @dut=nil
+
+      Scoutui::Logger::LogMgr.instance.commands.debug __FILE__ + (__LINE__).to_s + " form => #{@cmd}"
+      @formLocator = @cmd.match(/fillform\((.*)\s*\)/)[1].to_s
+      @form = Scoutui::Utils::TestUtils.instance.getForm(@formLocator)
+      Scoutui::Logger::LogMgr.instance.commands.debug __FILE__ + (__LINE__).to_s + " Form => #{@form}"
+      @form.dump()
+    end
+
+    def fill(drv, dut)
+      @drv=drv if !drv.nil?
+
+      @form.fillForm(@drv, dut)
+    end
+
+    def execute(drv=nil)
+      @drv=drv if !drv.nil?
+
+
+      #_form = @cmd.match(/fillform\((.*)\s*\)/)[1].to_s
+      #  _dut = _action.match(/fillform\(.*,\s*(.*)\)/)[1].to_s
+
+      # dut = e['page']['dut']
+
+      #  Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " _dut => #{_dut}"
+      Scoutui::Logger::LogMgr.instance.commands.debug __FILE__ + (__LINE__).to_s + " DUT => #{@dut}"
+      _rc=false
+      begin
+        _f = Scoutui::Utils::TestUtils.instance.getForm(@formLocator)
+        _f.dump()
+        _f.verifyForm(@drv)
+        _f.fillForm(@drv, dut)
+        _rc=true
+      rescue
+        ;
+      end
+
+      setResult(_rc)
+    end
+
+  end
+
+
+end

data/lib/scoutui/commands/jsalert/action_jsalert.rb

@@ -0,0 +1,58 @@
+require 'testmgr'
+
+module Scoutui::Commands::JsAlert
+
+  class ExistsAlert < Scoutui::Commands::Command
+
+
+    def execute(drv=nil)
+      @drv=drv if !drv.nil?
+
+      _rc=nil
+      _alertExists=false
+
+      Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " command => #{@cmd.to_s}"
+
+      _action=@cmd.match(/(exist[s]*_*alert|existAlert|existsAlert|existsJsAlert|existsJsConfirm|existsJsPrompt)\s*\((.*)\)/i)[2].to_s.strip
+
+      Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " ExistsAlert(#{_action})"  if Scoutui::Utils::TestUtils.instance.isDebug?
+
+      alert=nil
+
+      begin
+        alert=@drv.switch_to.alert
+        Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " | alert => #{alert.class.to_s}" if Scoutui::Utils::TestUtils.instance.isDebug?
+
+        _alertExists = alert.is_a?(Selenium::WebDriver::Alert)
+        if _alertExists && !(_action.nil? && _action.empty?)
+          _r = Regexp.new _action.to_s
+
+          Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " _r => #{_r}"
+          Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " _t => #{alert.text.to_s}"
+          _rc=!alert.text.to_s.match(_r).nil?
+        end
+
+      rescue Selenium::WebDriver::Error::NoSuchAlertError
+        alert=nil
+      end
+
+      Testmgr::TestReport.instance.getReq('UI').testcase('expectJsAlert').add(_alertExists, "Verify JsAlert is present")
+
+      if !(_action.nil? && _action.empty?)
+        Testmgr::TestReport.instance.getReq('UI').get_child('expectJsAlert').add(_rc, "Verify JsAlert contains text #{_action}")
+
+
+        setResult(_rc)
+      end
+
+      Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " ExistsAlert() => #{alert.class.to_s}    rc:#{_rc.to_s}"  if Scoutui::Utils::TestUtils.instance.isDebug?
+
+
+    end
+
+
+  end
+
+
+
+end

data/lib/scoutui/commands/mouse_over.rb

@@ -0,0 +1,31 @@
+
+module Scoutui::Commands
+
+  class MouseOver < Command
+
+    def execute(drv=nil)
+      _rc=false
+      _req = Scoutui::Utils::TestUtils.instance.getReq()
+
+      @drv=drv if !drv.nil?
+
+      begin
+        _xpath = @cmd.match(/mouseover\s*\((.*)\)/)[1].to_s.strip
+        obj = Scoutui::Base::QBrowser.getObject(@drv, _xpath)
+        @drv.action.move_to(obj).perform
+        _rc=true
+      rescue
+        ;
+      end
+
+      Testmgr::TestReport.instance.getReq(_req).testcase('mouseover').add(!obj.nil?, "Verify object #{_xpath} to mouseover exists : #{obj.class.to_s}")
+      Testmgr::TestReport.instance.getReq(_req).testcase('mousseover').add(_rc, "Verify mouseover #{_rc}")
+      setResult(_rc)
+    end
+
+
+
+  end
+
+
+end

data/lib/scoutui/commands/pause.rb

@@ -0,0 +1,26 @@
+
+
+module Scoutui::Commands
+
+  class Pause < Command
+
+    def execute(e=nil)
+      rc=true
+      h=""
+      begin
+        if e.is_a?(Hash) && e.has_key?('page')
+          h=e['page']['name'].to_s
+        end
+        puts "====== PAUSE - HIT ENTER #{h} ========="
+        gets()
+      rescue => ex
+        puts "Error during processing: #{$!}"
+        puts "Backtrace:\n\t#{ex.backtrace.join("\n\t")}"
+        rc=false
+      end
+      setResult(rc)
+    end
+  end
+
+
+end