scoutui 2.0.0 → 2.0.1

data/lib/scoutui/commands/verify_element.rb

@@ -0,0 +1,198 @@
+require_relative './commands'
+
+module Scoutui::Commands
+
+  class VerifyElement < Command
+
+    def _verify(elt)
+      begin
+
+        Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " VerifyElement._verify(#{elt})"
+
+        _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
+
+          _req = Scoutui::Utils::TestUtils.instance.getReq()
+
+          if _v.has_key?('locator')
+            _locator = _v['locator'].to_s
+            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(@drv, _locator, Scoutui::Commands::Utils.instance.getTimeout())
+
+            Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " HIT #{_locator} => #{!_obj.nil?}"
+          end
+
+          if _v.has_key?('visible_when')
+
+            if _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 _v['visible_when'].match(/never/i)
+              Scoutui::Logger::LogMgr.instance.asserts.info "Verify assertion #{_k} #{_locator} not visible - #{obj.nil?.to_s}"
+              Testmgr::TestReport.instance.getReq(_req).get_child('visible_when').add(obj.nil?, "Verify assertion #{_k} #{_locator} not visible")
+            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 _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.info __FILE__ + (__LINE__).to_s + " abort processing."
+        Scoutui::Logger::LogMgr.instance.debug "Error during processing: #{ex}"
+        puts __FILE__ + (__LINE__).to_s +  "\nBacktrace:\n\t#{ex.backtrace.join("\n\t")}"
+      end
+
+    end
+
+
+    def execute(drv)
+      @drv=drv if !drv.nil?
+      _e=getLocator()
+
+      if _e.nil?
+        _e = @cmd.match(/(verifyelt|verifyelement)\s*\((.*)\)/)[2].to_s.strip
+      end
+
+      Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " verifyElement => #{_e}"  if Scoutui::Utils::TestUtils.instance.isDebug?
+
+      _xpath = Scoutui::Base::UserVars.instance.get(_e)
+
+      Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " | translate : #{_xpath}" if Scoutui::Utils::TestUtils.instance.isDebug?
+
+
+      page_elt = Scoutui::Utils::TestUtils.instance.getPageElement(_xpath)
+
+      Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " Process page request #{page_elt} => #{page_elt.class.to_s}" if Scoutui::Utils::TestUtils.instance.isDebug?
+
+      xpath=nil
+
+      if page_elt.is_a?(Hash) && page_elt.has_key?('locator')
+
+        locator = Scoutui::Base::UserVars.instance.get(page_elt['locator'].to_s)
+
+
+        if page_elt.has_key?('visible_when') && page_elt['visible_when'].match(/title\(/)
+          current_title = @drv.title
+          expected_title = Regexp.new(page_elt['visible_when'].match(/title\((.*)\)/)[1].to_s)
+          rc=!expected_title.match(current_title).nil?
+
+
+
+          Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " Verify expected title (#{current_title}) matches (#{expected_title}) => " + rc.to_s
+
+#          Testmgr::TestReport.instance.getReq('UI').tc('visible_when').add(expected_title==current_title, "Verify title matches #{expected_title}")
+        end
+
+
+        if page_elt.has_key?('visible_when') && page_elt['visible_when'].match(/(text|value)\s*\(/)
+
+          rc=nil
+
+
+          condition = page_elt['visible_when'].match(/(value|text)\((.*)\)/)[1].to_s
+          tmpObj = page_elt['visible_when'].match(/(value|text)\((.*)\)/)[2].to_s
+          expectedVal = page_elt['visible_when'].match(/(value|text)\s*\(.*\)\s*\=\s*(.*)/)[2].to_s
+          Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " tmpObj => #{tmpObj} with expected value #{expectedVal}"
+
+          xpath = Scoutui::Base::UserVars.instance.get(tmpObj)
+
+          obj = Scoutui::Base::QBrowser.getObject(@drv, xpath)
+
+          if !obj.nil?
+          #  Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " value : #{obj.value.to_s}"
+            Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " text  : #{obj.text.to_s}"
+
+            if obj.tag_name.downcase.match(/(select)/)
+              _opt = Selenium::WebDriver::Support::Select.new(obj)
+              opts = _opt.selected_options
+              Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " selected => #{opts.to_s}"
+
+
+
+              opts.each do |o|
+                Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + "| <v, t>::<#{o.attribute('value').to_s},  #{o.text.to_s}>"
+
+                desc=nil
+
+
+                if condition=='text' && o.text==expectedVal
+                  desc=" Verify #{locator} is visible since condition (#{condition} #{xpath} is met."
+                elsif condition=='value' && o.attribute('value').to_s==expectedVal
+                  desc=" Verify #{locator} is visible since #{condition} of #{xpath} is #{expectedVal}"
+                end
+
+                if !desc.nil?
+                  locatorObj = Scoutui::Base::QBrowser.getObject(@drv, locator)
+
+                  Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " LocatorObj : #{locatorObj} : #{!locatorObj.nil? && locatorObj.displayed?}"
+
+
+                  Testmgr::TestReport.instance.getReq('UI').tc('visible_when').add(!locatorObj.nil? && locatorObj.displayed?, desc)
+                end
+
+              end
+
+
+
+            end
+
+            Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " value : #{obj.attribute('value').to_s}"
+          end
+
+
+
+
+        end
+
+      elsif page_elt.is_a?(Hash)
+
+        page_elt.each do |elt|
+
+          puts __FILE__ + (__LINE__).to_s + " ELT => #{elt} : #{elt.to_s}"
+          puts __FILE__ + (__LINE__).to_s + "     ELT[0] : #{elt[0]}"
+          puts __FILE__ + (__LINE__).to_s + "     ELT[1] : #{elt[1]}"
+
+          if elt.is_a?(Array)
+            _h={ elt[0] => elt[1] }
+
+            _verify(_h)
+          end
+
+        end
+
+
+      end
+
+      Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " xpath : #{xpath}"
+
+
+    end
+
+  end
+
+
+
+end

data/lib/scoutui/commands/verify_form.rb

@@ -0,0 +1,26 @@
+
+require_relative './commands'
+
+module Scoutui::Commands
+
+
+  class VerifyForm < Command
+
+
+    def execute(drv)
+      @drv=drv if !drv.nil?
+
+      _form = @cmd.match(/verifyform\((.*)\s*\)/)[1].to_s
+
+      Scoutui::Logger::LogMgr.instance.debug  __FILE__ + (__LINE__).to_s + " VerifyForm.execute : #{_form}"
+
+      _f = Scoutui::Utils::TestUtils.instance.getForm(_form)
+      _f.dump()
+      _f.verifyForm(@drv)
+
+    end
+
+  end
+
+
+end

data/lib/scoutui/eyes/eye_factory.rb

@@ -0,0 +1,76 @@
+
+require 'singleton'
+
+
+module Scoutui::Eyes
+
+
+  class EyeFactory
+    include Singleton
+
+    attr_accessor :eyesList
+
+    def initialize
+      @eyesList=Array.new()
+    end
+
+    def createScout()
+      browserType = Scoutui::Base::UserVars.instance.getBrowserType()
+      eyeScout = EyeScout.new(browserType)
+    end
+
+    def createEyes()
+
+      use_eyes = Scoutui::Utils::TestUtils.instance.eyesEnabled?
+
+      Scoutui::Logger::LogMgr.instance.info  __FILE__ + (__LINE__).to_s + " create(#{use_eyes})" if Scoutui::Utils::TestUtils.instance.isDebug?
+      eyes=nil
+
+
+      if use_eyes
+        license_key=nil
+
+        licFile=Scoutui::Utils::TestUtils.instance.getLicenseFile()
+
+        if !licFile.empty?
+
+          valid_json=false
+          begin
+            jFile = File.read(licFile)
+            jLicense=jsonData=JSON.parse(jFile)
+            license_key=jLicense['api_key'].to_s
+            valid_json=true
+          rescue => ex
+            ;
+          end
+
+        elsif ENV.has_key?('APPLITOOLS_API_KEY')
+          license_key=ENV['APPLITOOLS_API_KEY'].to_s
+        end
+
+
+        if !license_key.nil?
+          eyes=Applitools::Eyes.new()
+          eyes.api_key = license_key
+          eyes.force_fullpage_screenshot = true
+
+          match_level = Scoutui::Base::UserVars.instance.getVar('eyes.match_level')
+
+          eyes.match_level = Applitools::Eyes::MATCH_LEVEL[match_level.to_sym]
+        end
+
+        ## TBD - eyes.open()
+
+
+      end
+
+    #  eyes
+      @eyesList << eyes
+      @eyesList.last()
+    end
+
+  end
+
+
+
+end

data/lib/scoutui/eyes/eye_scout.rb

@@ -0,0 +1,239 @@
+require 'eyes_selenium'
+require 'testmgr'
+
+module Scoutui::Eyes
+
+
+  class EyeScout
+
+    attr_accessor :eyes
+    attr_accessor :testResults
+    attr_accessor :strategy
+
+    def teardown()
+      @strategy.quit()
+    end
+
+    def navigate(url)
+    @strategy.navigate(url)
+    end
+
+    def drv()
+      @strategy.getDriver()
+    end
+
+    def getStrategy()
+      @strategy
+    end
+
+    def eyes()
+      @eyes
+    end
+
+
+    #---- 5150 -----
+    def get_session_id(url)
+      Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " -- get_session_id(#{url}) =="
+      _s=/sessions\/(?<session>\d+)/.match(url)[1]
+
+    end
+
+    def get_diff_urls(session_id, view_key)
+      info = "https://eyes.applitools.com/api/sessions/#{session_id}/?ApiKey=#{view_key}&format=json"
+      diff_template = "https://eyes.applitools.com/api/sessions/#{session_id}/steps/%s/diff?ApiKey=#{view_key}"
+      diff_urls = Hash.new
+
+      Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " info => #{info}"
+      response = HTTParty.get(info)
+
+      Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " RESP => #{response.to_s}"
+
+      begin
+        data = JSON.parse(response.body)
+        index = 1
+        data['actualOutput'].each do |elem|
+          if !elem.nil? && (elem['isMatching'] == false)
+            #diff_urls[index] = diff_template % [index]
+            Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " #{index.to_s} :#{elem['tag'].to_s}"
+            #diff_urls[index] = diff_template % [index]
+            diff_urls[index] = { :tag => elem['tag'].to_s, :url => diff_template % [index] }
+            index+=1
+          end
+        end
+
+        diff_urls
+
+      rescue JSON::ParserError
+        ;
+      end
+
+    end
+
+    def sanitize_filename(filename)
+      # Split the name when finding a period which is preceded by some
+      # character, and is followed by some character other than a period,
+      # if there is no following period that is followed by something
+      # other than a period
+      fn = filename.split /(?<=.)\.(?=[^.])(?!.*\.[^.])/m
+
+      # We now have one or two parts (depending on whether we could find
+      # a suitable period). For each of these parts, replace any unwanted
+      # sequence of characters with an underscore
+      fn.map! { |s| s.gsub /[^a-z0-9\-]+/i, '_' }
+
+      # Finally, join the parts with a period and return the result
+      return fn.join '.'
+    end
+
+    def download_images(diff_urls, destination)
+      diff_urls.each do |index, elem|
+        save_name = sanitize_filename(elem[:tag]) + ".step_#{index}_diff.png"
+        File.open("#{destination}/#{save_name}", 'wb') do |file|
+          file.write HTTParty.get(elem[:url])
+        end
+      end
+    end
+
+    def saveDiffs(_eyes, results, outdir, view_key)
+      Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s +  "  saveDiffs(#{outdir.to_s})"
+
+      Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " | steps : #{results.steps.to_s}"
+      session_id = get_session_id(results.url)
+      Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " session => #{session_id}"
+
+      diffs = get_diff_urls(session_id, view_key)
+
+      diffs.each do |d|
+        Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " #{d.to_s}"
+      end
+
+      download_images(diffs, outdir)
+
+    end
+    #---- END 5150
+
+
+    def closeOut()
+
+#      Scoutui::Base::QHarMgr.instance.stop('/tmp/scoutui.har')
+
+      return if !Scoutui::Utils::TestUtils.instance.eyesEnabled?
+      @testResults = eyes().close(false)
+
+      Testmgr::TestReport.instance.getReq("EYES").testcase('Images').add(@testResults.steps.to_i > 0, "Verify at least 1 shot taken (#{@testResults.steps.to_s} shots)")
+      Testmgr::TestReport.instance.getReq("EYES").testcase('Images').add(@testResults.missing.to_i==0, "Verify Eyes did not miss any screens (#{@testResults.missing.to_s} screens)")
+
+      # 5150
+      _diffdir=Scoutui::Utils::TestUtils.instance.getDiffDir()
+      if ENV.has_key?('APPLITOOLS_VIEW_KEY') && !_diffdir.nil?
+
+        if Dir.exists?(_diffdir)
+          saveDiffs(eyes(), @testResults, _diffdir, ENV['APPLITOOLS_VIEW_KEY'])
+        else
+          Scoutui::Logger::LogMgr.instance.warn " Specified Visual Diff folder does not exist - #{_diffdir.to_s}.  Unable to download diffs"
+        end
+
+      else
+        Scoutui::Logger::LogMgr.instance.info " Unable to download diff images - APPLITOOLS_VIEW_KEY not defined"
+      end
+
+
+      eyes().abort_if_not_closed if !eyes().nil?
+    end
+
+    def check_window(tag, region=nil)
+      Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " check_window(#{tag.to_s})"  if Scoutui::Utils::TestUtils.instance.isDebug?
+
+      return if !Scoutui::Utils::TestUtils.instance.eyesEnabled?
+
+      if region.nil?
+        eyes().check_window(tag.to_s)
+      else
+        f = eyes().force_fullpage_screenshot
+        eyes().check_region(:xpath, region, tag)
+        eyes().force_fullpage_screenshot = f
+      end
+
+    end
+
+    def generateReport()
+
+      if Scoutui::Utils::TestUtils.instance.eyesEnabled?
+        Scoutui::Logger::LogMgr.instance.debug " testResults.methods = #{@testResults.methods.sort.to_s}"
+        Scoutui::Logger::LogMgr.instance.info " Eyes.TestResults.Missing    : #{@testResults.missing.to_s}"
+        Scoutui::Logger::LogMgr.instance.info " Eyes.TestResults.Matches    : #{@testResults.matches.to_s}"
+        Scoutui::Logger::LogMgr.instance.info " Eyes.TestResults.Mismatches : #{@testResults.mismatches.to_s}"
+        Scoutui::Logger::LogMgr.instance.info " Eyes.TestResults.Passed     : #{@testResults.passed?.to_s}"
+        Scoutui::Logger::LogMgr.instance.info " Eyes.TestResults.Steps      : #{@testResults.steps.to_s}"
+      end
+
+      Scoutui::Logger::LogMgr.instance.info " TestReport => #{@testResults}"
+   #  Testmgr::TestReport.instance.generateReport()
+      Testmgr::TestReport.instance.report()
+    end
+
+    def getResults()
+      @testResults
+    end
+
+
+
+    def initialize(browserType)
+      @testResults=nil
+
+      browserType = Scoutui::Base::UserVars.instance.getBrowserType()
+      viewport_size = Scoutui::Base::UserVars.instance.getViewPort()
+
+      Testmgr::TestReport.instance.setDescription('ScoutUI Test')
+      Testmgr::TestReport.instance.setEnvironment(:qa, Scoutui::Utils::TestUtils.instance.getHost())
+      Testmgr::TestReport.instance.addRequirement('UI')
+      Testmgr::TestReport.instance.getReq('UI').add(Testmgr::TestCase.new('visible_when', "visible_when"))
+      Testmgr::TestReport.instance.addRequirement('Command')
+      Testmgr::TestReport.instance.getReq('Command').add(Testmgr::TestCase.new('isValid', "isValid"))
+
+      Testmgr::TestReport.instance.getReq('UI').add(Testmgr::TestCase.new('expectJsAlert', 'expectJsAlert'))
+
+      if Scoutui::Utils::TestUtils.instance.isDebug?
+        Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " setup() : #{browserType}"
+        Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " sauce    => " + Scoutui::Utils::TestUtils.instance.eyesEnabled?.to_s
+        Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " viewport => #{viewport_size}"
+        Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " eyes cfg => #{@eyesRecord}"
+        Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " title => " + Scoutui::Base::UserVars.instance.getVar('eyes.title')
+        Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " app => " + Scoutui::Base::UserVars.instance.getVar('eyes.app')
+        Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " match_level => " + Scoutui::Base::UserVars.instance.getVar('eyes.match_level')
+      end
+
+      begin
+
+#        Scoutui::Base::QHarMgr.instance.start()
+#        @profile.proxy = Scoutui::Base::QHarMgr.instance.getSeleniumProfile()
+
+        @strategy = Scoutui::Commands::Strategy.new()
+
+        @eyes=Scoutui::Eyes::EyeFactory.instance.createEyes()
+
+        Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " eyes => #{eyes}" if Scoutui::Utils::TestUtils.instance.isDebug?
+
+        ## TBD - move the following into eye_scout ??
+        if Scoutui::Utils::TestUtils.instance.eyesEnabled?
+          @driver = @eyes.open(
+              app_name:  Scoutui::Base::UserVars.instance.getVar('eyes.app'),   # @eyesRecord['app'],
+              test_name: Scoutui::Base::UserVars.instance.getVar('eyes.title'), # @eyesRecord['title'],
+              viewport_size: viewport_size,
+              #    viewport_size: {width: 800, height: 600},
+              driver: @strategy.getDriver())
+        end
+
+      rescue => ex
+        Scoutui::Logger::LogMgr.instance.info ex.backtrace
+      end
+
+    end
+
+
+  end
+
+
+
+
+end