class Scoutui::Eyes::EyeScout

Attributes

eyes[RW]
strategy[RW]
testResults[RW]

Public Class Methods

new(browserType) click to toggle source
# File lib/scoutui/eyes/eye_scout.rb, line 261
    def initialize(browserType)
      @testResults=nil

      browserType = Scoutui::Base::UserVars.instance.getBrowserType()
      viewport_size = Scoutui::Base::UserVars.instance.getViewPort()

      Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " browserType => #{browserType}"
      Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " viewport : #{viewport_size}"


      Testmgr::TestReport.instance.setDescription('ScoutUI Test')
      Testmgr::TestReport.instance.setEnvironment(:qa, Scoutui::Utils::TestUtils.instance.getHost())
      Testmgr::TestReport.instance.setHost(Scoutui::Base::UserVars.instance.get(:host))
      Testmgr::TestReport.instance.setBrowserUnderTest(browserType)
      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.addRequirement('DB')
      Testmgr::TestReport.instance.getReq('DB').add(Testmgr::TestCase.new('DB', "DB"))

      Testmgr::TestReport.instance.addRequirement('Execution')
      Testmgr::TestReport.instance.getReq('Execution').add(Testmgr::TestCase.new('Status', "Status"))

      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 + " eyes     => " + 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 + " eyes.title => " + Scoutui::Base::UserVars.instance.getVar('eyes.title')
        Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " eyes.app => " + Scoutui::Base::UserVars.instance.getVar('eyes.app')
        Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " eyes.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}"

        ## 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.warn __FILE__ + (__LINE__).to_s +  "Backtrace:\n\t#{ex.backtrace.join("\n\t")}"
      end

    end

Public Instance Methods

check_window(tag, region=nil) click to toggle source
# File lib/scoutui/eyes/eye_scout.rb, line 189
def check_window(tag, region=nil)
  Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " check_window(#{tag.to_s}, #{region})"  if Scoutui::Utils::TestUtils.instance.isDebug?

  return if !Scoutui::Utils::TestUtils.instance.eyesEnabled?

  if region.nil?
    Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " check_window(#{tag.to_s})"
    eyes().check_window(tag.to_s)
  else

    Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " check_window.fullshot"
    f = eyes().force_fullpage_screenshot

    if region.match(/^css\s*\=\s*/)
      _css = region.gsub(/^css\s*\=\s*/,"").to_s

      Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " snapshot(region.css) : #{_css}"
      eyes().check_region(:css, _css, tag)
    else
      Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + "check_window(:xpath, #{region}, #{tag})"
      eyes().check_region(:xpath, region, tag)
    end

    eyes().force_fullpage_screenshot = f
  end

end
closeOut() click to toggle source
# File lib/scoutui/eyes/eye_scout.rb, line 149
    def closeOut()

#      Scoutui::Base::QHarMgr.instance.stop('/tmp/scoutui.har')

      return if !Scoutui::Utils::TestUtils.instance.eyesEnabled?
      @testResults = eyes().close(false)

      Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " @eyes => #{eyes().to_s}"


      Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + "| app_name : #{eyes().app_name}"
      Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + "| match_level: #{eyes().match_level}"
      Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + "| viewport_size: #{eyes().viewport_size.to_s}"

      eyes().viewport_size.to_hash.each_pair do |k, v|
        Scoutui::Logger::LogMgr.instance.debug  "  o " + k.to_s + " : " + v.to_s
      end


      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)
         # Legacy_saveDiffs(eyes(), @testResults, _diffdir, ENV['APPLITOOLS_VIEW_KEY'])
          Scoutui::Eyes::Utils.instance.download_diffs(@testResults, ENV['APPLITOOLS_VIEW_KEY'], _diffdir)
        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
download_images(diff_urls, destination) click to toggle source
# File lib/scoutui/eyes/eye_scout.rb, line 112
def download_images(diff_urls, destination)
  Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " download_images(#{diff_urls}, #{destination}"

  diff_urls.each do |index, elem|
    save_name = sanitize_filename(elem[:tag]) + ".step_#{index}_diff.png"
    Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " => download : #{save_name}"

    File.open("#{destination}/#{save_name}", 'wb') do |file|
      file.write HTTParty.get(elem[:url])
    end
  end
end
drv() click to toggle source
# File lib/scoutui/eyes/eye_scout.rb, line 21
def drv()
  @strategy.getDriver()
end
generateReport() click to toggle source
# File lib/scoutui/eyes/eye_scout.rb, line 217
    def generateReport()

      Scoutui::Logger::LogMgr.instance.info "SCOUTUI VERSION : " + Scoutui::VERSION

      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.isNew      : #{@testResults.is_new.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

      Testmgr::TestReport.instance.getReq("Execution").testcase('Status').add(!Scoutui::Utils::TestUtils.instance.abort?, "Verify execution did not abort. #{Scoutui::Utils::TestUtils.instance.currentMessage}")

      Scoutui::Logger::LogMgr.instance.info " TestReport.Tap => #{@testResults.to_json}"

      Testmgr::TestReport.instance.report()

      if Scoutui::Utils::TestUtils.instance.abort?
        Scoutui::Logger::LogMgr.instance.warn __FILE__ + (__LINE__).to_s + " Aborted:"

        Scoutui::Utils::TestUtils.instance.abortMessage.each do |msg|
          Scoutui::Logger::LogMgr.instance.fatal msg
        end
      end

      Testmgr::TestReport.instance.junitReport(Scoutui::Utils::TestUtils.instance.getReporter())

#     Testmgr::TestReport.instance.generateReport()

      metrics=Testmgr::TestReport.instance.getMetrics()
      puts __FILE__ + (__LINE__).to_s + "Metrics => #{metrics}"

      Scoutui::Utils::TestUtils.instance.setMetrics(metrics)
    end
getResults() click to toggle source
# File lib/scoutui/eyes/eye_scout.rb, line 255
def getResults()
  @testResults
end
getStrategy() click to toggle source
# File lib/scoutui/eyes/eye_scout.rb, line 25
def getStrategy()
  @strategy
end
get_accountid(url) click to toggle source
# File lib/scoutui/eyes/eye_scout.rb, line 40
    def get_accountid(url)
      Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " -- get_account_id(#{url}) =="

      uri = URI(url)
      queryString = CGI::parse(uri.query)

      accountid = queryString['accountId'] || queryString['accountid']

      Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " => accountId : #{accountid}"

#      _s=/sessions\/(?<accountid>\d+)/.match(url)[1]

      accountid.is_a?(Array) ? accountid[0] : accountid
    end
get_diff_urls(session_id, account_id, view_key) click to toggle source
# File lib/scoutui/eyes/eye_scout.rb, line 58
def get_diff_urls(session_id, account_id, view_key)

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

  info = "https://eyes.applitools.com/api/sessions/#{session_id}?ApiKey=#{view_key}&format=json"
 #info = "https://eyes.applitools.com/api/sessions/#{session_id}?accountId=#{account_id}&format=json"
  diff_template = "https://eyes.applitools.com/api/sessions/#{session_id}/steps/%s/diff?ApiKey=#{view_key}"
  diff_template = "https://eyes.applitools.com/api/sessions/#{session_id}?accountId=#{account_id}&format=json"

  Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " diff_template => #{diff_template}"
  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
get_session_id(url) click to toggle source
# File lib/scoutui/eyes/eye_scout.rb, line 35
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
navigate(url) click to toggle source
sanitize_filename(filename) click to toggle source
# File lib/scoutui/eyes/eye_scout.rb, line 96
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
saveDiffs(_eyes, results, outdir, view_key) click to toggle source
# File lib/scoutui/eyes/eye_scout.rb, line 127
def saveDiffs(_eyes, results, outdir, view_key)
  Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s +  "  saveDiffs(#{outdir.to_s})"
  Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + "  results => #{results.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}"

  account_id = get_accountid(results.url)

  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
teardown() click to toggle source
# File lib/scoutui/eyes/eye_scout.rb, line 13
def teardown()
  @strategy.quit()
end