scoutui 2.0.1 → 2.0.2

data/lib/scoutui/commands/click_object.rb

@@ -4,36 +4,109 @@ module Scoutui::Commands
 
   class ClickObject < Command
 
+    def _whenClicked(page_elt)
+
+      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
+            puts __FILE__ + (__LINE__).to_s + " => #{_pg}"
+          end
+
+#         Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " IsVisible #{isVisible} - PAUSE"; gets
+
+        end
+
+      end
+
+    end
 
     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?
+      _req = Scoutui::Utils::TestUtils.instance.getReq()
+      _locator = @cmd.match(/click\s*\((.*)\)/)[1].to_s.strip
+      Scoutui::Logger::LogMgr.instance.command.info __FILE__ + (__LINE__).to_s + " clickObject => #{_locator}"
+
+      # _vars = _locator.scan(/(\$\{.*?\})/)
+      # _vars.each do | _v|
+      #   if _v.length==1
+      #
+      #     _u = Scoutui::Base::UserVars.instance.get(_v[0].to_s)
+      #     puts __FILE__ + (__LINE__).to_s + " Normalize(#{_v}) => #{_u}"
+      #
+      #     _locator.gsub!(_v[0].to_s, _u)
+      #   end
+      #
+      # end
 
-      _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?
+      # _locator = Scoutui::Base::UserVars.instance.get(_locator)
+      _locator = Scoutui::Base::UserVars.instance.normalize(_locator)
+
+      Scoutui::Logger::LogMgr.instance.command.info __FILE__ + (__LINE__).to_s + " | translate : #{_locator}" if Scoutui::Utils::TestUtils.instance.isDebug?
 
       _clicked=false
 
       begin
-        obj = Scoutui::Base::QBrowser.getObject(@drv, _xpath)
+        obj = Scoutui::Base::QBrowser.getObject(@drv, _locator, Scoutui::Commands::Utils.instance.getTimeout)
+
+
 
         if obj
-          obj.click
-          _clicked=true
+
+          # Refactor in qbrowser
+
+          wait = Selenium::WebDriver::Wait.new(:timeout =>  Scoutui::Commands::Utils.instance.getTimeout)
+
+          isDisplayed=false
+          isDisplayed = wait.until {
+            true if obj.displayed?
+          }
+
+          if isDisplayed
+            obj.click
+            _clicked=true
+
+            page_elt = Scoutui::Utils::TestUtils.instance.getPageElement(_locator)
+
+            Scoutui::Logger::LogMgr.instance.debug "PageElement(#{_locator}) => #{page_elt}"
+
+            _whenClicked(page_elt)
+          else
+            Scoutui::Logger::LogMgr.instance.warn __FILE__ + (__LINE__).to_s + " Unable to click object that is not displayed."
+          end
+
         end
 
-      rescue
-        ;
+      rescue => ex
+        Scoutui::Logger::LogMgr.instance.warn "Error during processing: #{$!}"
+        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 #{_xpath} : #{obj.class.to_s} - #{!obj.nil?.to_s}"
-      Scoutui::Logger::LogMgr.instance.asserts.info "Verify clicked #{_xpath} - #{_clicked.to_s}"
+      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 "Verify clicked #{_locator} - #{_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}")
+      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}")
 
       setResult(_clicked)
     end

data/lib/scoutui/commands/commands.rb

@@ -6,7 +6,7 @@ module Scoutui::Commands
 
 
   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)
@@ -14,35 +14,45 @@ module Scoutui::Commands
         Scoutui::Logger::LogMgr.instance.debug "Error during processing: #{$!}"
         Scoutui::Logger::LogMgr.instance.debug "Backtrace:\n\t#{e.backtrace.join("\n\t")}"
       end
-
     end
 
+    Scoutui::Logger::LogMgr.instance.debug " exit [processCommands]"
   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?
+    Scoutui::Logger::LogMgr.instance.commands.debug __FILE__ + (__LINE__).to_s + " enter [processCommand(#{_action})"
 
     _aborted=false
     _cmd=nil
-    _totalWindows = my_driver.window_handles.length
 
     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
 
       if Scoutui::Commands::Utils.instance.isPause?(_action)
         _cmd='pause'
         _c = Scoutui::Commands::Pause.new(nil)
         _c.execute(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.execute(my_driver)
 
+        if e["page"].has_key?('then')
+          Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " then => #{e['page']['then]']}"
+        end
+
       elsif Scoutui::Commands::Utils.instance.isExistsAlert?(_action)
         _cmd='ExistsAlert'
         _c = Scoutui::Commands::JsAlert::ExistsAlert.new(_action)
@@ -122,10 +132,13 @@ module Scoutui::Commands
     end
 
     if my_driver.window_handles.length > _totalWindows
-      Scoutui::Logger::LogMgr.instance.info " New Window generated"
+      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 did not abort")
+    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
   end
 

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

@@ -15,7 +15,7 @@ module Scoutui::Commands::JsAlert
 
       _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?
+      Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " ExistsAlert(#{_action})"
 
       alert=nil
 

data/lib/scoutui/commands/mouse_over.rb

@@ -3,24 +3,110 @@ module Scoutui::Commands
 
   class MouseOver < Command
 
+
+    def _whenHovered(page_elt)
+
+      if page_elt.is_a?(Hash) && page_elt.has_key?('when_hovered')
+        Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " Verify #{page_elt['when_hovered']}"
+
+        page_elt['when_hovered'].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 + " processPageElement(#{_pg})"
+
+
+          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
+            puts __FILE__ + (__LINE__).to_s + " => #{_pg}"
+          end
+
+  #       Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " IsVisible #{isVisible} - PAUSE"; gets
+
+        end
+
+      end
+
+    end
+
+
     def execute(drv=nil)
       _rc=false
       _req = Scoutui::Utils::TestUtils.instance.getReq()
 
+      Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " MouseOver.execute(#{@cmd})"
+
       @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
-        ;
+        _locator = @cmd.match(/mouseover\s*\((.*)\)/)[1].to_s.strip
+        obj = Scoutui::Base::QBrowser.getObject(@drv, _locator, Scoutui::Commands::Utils.instance.getTimeout)
+
+        if !obj.nil?
+          @drv.action.move_to(obj).perform
+          _rc=true
+
+
+          page_elt = Scoutui::Utils::TestUtils.instance.getPageElement(_locator)
+          Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " PageElement(#{_locator}) => #{page_elt}"
+          _whenHovered(page_elt)
+
+
+          #------------
+
+          appModel = Scoutui::Utils::TestUtils.instance.getAppModel()
+
+          triggers = appModel.itemize('visible_when', 'mouseover', _locator)
+          Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " triggers => #{triggers}"
+
+          if !(triggers.nil? || triggers.empty?)
+
+            triggers.each do |_pageObj|
+              _tObj=nil
+
+              if !_pageObj.match(/^page\([\w\d]+\)/).nil?
+      #         _tObj = Scoutui::Base::VisualTestFramework.processPageElement(@drv, 'peter', _pageObj)
+
+                _tLocator = Scoutui::Utils::TestUtils.instance.getPageElement(_pageObj)
+                _tObj = Scoutui::Base::QBrowser.getFirstObject(@drv, _tLocator['locator'])
+
+              else
+                _tObj = Scoutui::Base::QBrowser.getFirstObject(@drv, _pageObj, Scoutui::Commands::Utils.instance.getTimeout())
+              end
+
+              Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " HIT #{_pageObj} => #{!_tObj.nil?}"
+
+              Scoutui::Logger::LogMgr.instance.asserts.info "Verify #{_pageObj} is visible when mouseover #{_locator} - #{!_tObj.nil?.to_s}"
+              Testmgr::TestReport.instance.getReq(_req).get_child('mouseover').add(!_tObj.nil?, "Verify #{_pageObj} is visible when mouseover #{_locator}")
+            end
+
+          end
+
+
+
+        end
+
+      rescue => ex
+        Scoutui::Logger::LogMgr.instance.warn "Error during processing: #{$!}"
+        Scoutui::Logger::LogMgr.instance.warn "Backtrace:\n\t#{ex.backtrace.join("\n\t")}"
       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}")
+      Testmgr::TestReport.instance.getReq(_req).testcase('mouseover').add(!obj.nil?, "Verify object #{_locator} to mouseover exists : #{obj.class.to_s}")
+      Testmgr::TestReport.instance.getReq(_req).testcase('mousseover').add(_rc, "Verify mouseover #{_rc} performed for #{_locator}")
       setResult(_rc)
+
+
+
     end
 
 

data/lib/scoutui/commands/select_object.rb

@@ -23,7 +23,7 @@ module Scoutui::Commands
 
           Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + "Process SELECT #{_val} into  #{_xpath}"  if Scoutui::Utils::TestUtils.instance.isDebug?
 
-          obj = Scoutui::Base::QBrowser.getObject(@drv, _xpath)
+          obj = Scoutui::Base::QBrowser.getObject(@drv, _xpath, Scoutui::Commands::Utils.instance.getTimeout)
 
           if !obj.nil? && obj.tag_name.downcase.match(/(select)/)
 

data/lib/scoutui/commands/select_window.rb

@@ -0,0 +1,43 @@
+
+module Scoutui::Commands
+
+  class SelectWindow < Command
+
+    def execute(drv=nil)
+      _rc=false
+      _req = Scoutui::Utils::TestUtils.instance.getReq()
+      _window_id=nil
+
+      @drv=drv if !drv.nil?
+
+      puts __FILE__ + (__LINE__).to_s + " SELECT WINDOW +++++++++++++++"
+
+      begin
+        _window_id = @cmd.match(/select_window\s*\((.*)\)/)[1].to_s.strip
+
+        puts __FILE__ + (__LINE__).to_s + " ==> WindowID : #{_window_id}"
+        puts __FILE__ + (__LINE__).to_s + " ==> handles  : #{@drv.window_handles.length.to_s}"
+
+        i=0
+        @drv.window_handles.each do |_w|
+          puts __FILE__ + (__LINE__).to_s + "#{i}. #{_w.class.to_s}"
+          @drv.switch_to.window(_w)
+          puts __FILE__ + (__LINE__).to_s + " Title : #{@drv.title.to_s}"
+        end
+
+        _rc=true
+      rescue => ex
+        Scoutui::Logger::LogMgr.instance.debug "Error during processing: #{$!}"
+        Scoutui::Logger::LogMgr.instance.debug "Backtrace:\n\t#{ex.backtrace.join("\n\t")}"
+      end
+
+      Testmgr::TestReport.instance.getReq(_req).testcase('select_window').add(_rc, "Verify select_window #{_window_id} command passed #{_rc}")
+      setResult(_rc)
+    end
+
+
+
+  end
+
+
+end

data/lib/scoutui/commands/strategy.rb

@@ -1,5 +1,5 @@
 require 'testmgr'
-
+require 'sauce_whisk'
 
 module Scoutui::Commands
 
@@ -24,6 +24,7 @@ module Scoutui::Commands
     end
 
     def navigate(url)
+      Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " [enter]:navigate(#{url})"
       rc = false
       begin
         processCommand('navigate(' + url + ')', nil)
@@ -38,9 +39,37 @@ module Scoutui::Commands
 
     def report()
       Testmgr::TestReport.instance.report()
+#      Testmgr::TestReport.instance.generateReport()
     end
 
     def quit()
+
+      begin
+        Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " quit()"
+
+
+        Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " ===== Page Coverage ====="
+        Scoutui::Utils::TestUtils.instance.getPageCoverage().each do |_c|
+          Scoutui::Logger::LogMgr.instance.debug "   #{_c}"
+        end
+
+        metrics=Testmgr::TestReport.instance.getMetrics()
+        Scoutui::Logger::LogMgr.instance.info "Metrics => #{metrics}"
+
+        if Scoutui::Utils::TestUtils.instance.sauceEnabled?
+          job_id = @drv.session_id
+
+          SauceWhisk::Jobs.change_status job_id, metrics[:rc]
+
+          Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " Update Sauce tests with job_id #{job_id} to #{metrics[:rc]}"
+        end
+
+      rescue => ex
+        Scoutui::Logger::LogMgr.instance.warn "Error during processing: #{$!}"
+        Scoutui::Logger::LogMgr.instance.warn "Backtrace:\n\t#{ex.backtrace.join("\n\t")}"
+      end
+
+
       @drv.quit()
     end
 
@@ -49,6 +78,7 @@ module Scoutui::Commands
     end
 
     def processCommand(_action, e=nil)
+      Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " [enter]:processCommand(#{_action})"
       Scoutui::Commands::processCommand(_action, e, getDriver())
     end
 
@@ -121,6 +151,8 @@ module Scoutui::Commands
           tmpCaps = caps
 
           if caps.has_key?(:browser) && caps[:browser].match(/edge/i)
+
+            Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " Capabilities[browser] : EDGE"
             caps = Selenium::WebDriver::Remote::Capabilities.edge()
           elsif caps.has_key?(:browser) && caps[:browser].match(/chrome/i)
             caps = Selenium::WebDriver::Remote::Capabilities.chrome()
@@ -130,10 +162,15 @@ module Scoutui::Commands
             caps = Selenium::WebDriver::Remote::Capabilities.internet_explorer()
           end
 
+
           tmpCaps.each_pair do |k, v|
+            Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " caps[#{k.to_s}] = #{v}"
             caps[k.to_s]=v
           end
 
+
+          Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " Remote Caps => #{caps}"
+
         elsif caps.has_key?(:deviceName) && caps[:deviceName].match(/(iphone|ipad)/i) && !caps[:deviceName].match(/simulator/i)
           caps = Selenium::WebDriver::Remote::Capabilities.iphone()
           caps['platform'] = 'OS X 10.10'
@@ -183,12 +220,12 @@ module Scoutui::Commands
             @drv=Selenium::WebDriver.for :remote, :url => sauce_endpoint, :http_client => client, :desired_capabilities => caps # setup(caps)
           end
 
-        rescue => e
+        rescue => ex
           Scoutui::Logger::LogMgr.instance.debug "Error during processing: #{$!}"
           Scoutui::Logger::LogMgr.instance.debug "Backtrace:\n\t#{ex.backtrace.join("\n\t")}"
         end
 
-        
+
       else
         Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " Create WebDriver: #{browserType.to_s}"
         @drv=Selenium::WebDriver.for browserType.to_sym, :profile => @profile