eyes_selenium 1.6.0

data/lib/eyes_selenium/eyes/environment.rb

@@ -0,0 +1,14 @@
+class Applitools::Environment
+
+  attr_accessor :os, :hosting_app, :display_size
+  def initialize(os=nil, hosting_app=nil, display_size=nil)
+    @os = os
+    @hosting_app = hosting_app
+    @display_size = display_size
+  end
+
+  def to_hash
+    # display_size is an Applitools::ViewportSize object
+    { os: os, hostingApp: hosting_app, displaySize: display_size.to_hash}
+  end
+end

data/lib/eyes_selenium/eyes/eyes.rb

@@ -0,0 +1,182 @@
+class Applitools::Eyes
+  DEFAULT_MATCH_TIMEOUT = 2.0
+  AGENT_ID = 'eyes.selenium.ruby'
+
+  class << self
+    attr_accessor :config
+  end
+
+  @config = {
+    server_url: 'https://eyes.applitools.com',
+    user: AGENT_ID
+    # apikey: 'please supply an apikey in your initializer'
+  }
+
+  attr_reader :agent_connector, :disabled
+  attr_accessor :app_name, :test_name, :session, :is_open, :aborted, :viewport_size, :match_timeout, 
+                :failure_reports, :test_batch, :match_level, :driver, :host_os, :host_app, :branch_name, :parent_branch_name, 
+                :should_match_window_run_once_on_timeout, :session_start_info, :match_window_task
+
+  def config
+    self.class.config
+  end
+
+  def initialize(params={})
+    raise "Please supply an apikey: Eyes.config[:apikey] = ..." unless config[:apikey]
+
+    @disabled = params[:disabled]
+
+    @driver = create_driver(params)
+    return if disabled?
+
+    @agent_connector = Applitools::AgentConnector.new(config[:server_url], config[:user], config[:apikey])
+    @match_timeout = DEFAULT_MATCH_TIMEOUT
+    @failure_reports = Applitools::FailureReports::ON_CLOSE
+  end
+
+  def create_driver(params)
+    Applitools::Driver.new(browser: params.fetch(:browser, nil))
+  end
+
+  def open(params={})
+    return driver if disabled?
+
+    if open?
+      abort_if_not_closed
+      msg = 'a test is alread running'
+      EyesLogger.info(msg) and raise Applitools::EyesError.new(msg)
+    end
+
+    self.app_name = params.fetch(:app_name)
+    self.failure_reports = params.fetch(:failure_reports, self.failure_reports)
+    self.match_level = params.fetch(:match_level,MatchLevel::EXACT)
+    self.test_name = params.fetch(:test_name)
+    self.viewport_size = params.fetch(:viewport_size, nil)
+
+    self.is_open = true
+    driver
+  end
+
+  def open?
+    self.is_open
+  end
+
+  def check_window(tag)
+    return if disabled?
+    raise Applitools::EyesError.new("Eyes not open") if !open?
+    if !session
+      start_session
+      self.match_window_task = Applitools::MatchWindowTask.new(agent_connector, session, driver, match_timeout)
+    end
+
+    as_expected = match_window_task.match_window(tag, should_match_window_run_once_on_timeout)
+    if !as_expected
+      self.should_match_window_run_once_on_timeout = true
+      if !session.new_session?
+        #EyesLogger.info %( "mismatch! #{ tag ? "" : "(#{tag})" } )
+        if failure_reports.to_i == Applitools::FailureReports::IMMEDIATE
+          raise Applitools::TestFailedError.new("Mismatch found in '#{start_info.scenario_id_or_name}'"\
+                                                " of '#{start_info.app_id_or_name}'")
+        end
+      end
+    end
+  end
+
+  def close
+    return if disabled?
+    self.is_open = false
+    return Applitools::TestResults.new if !session
+
+    session_results_url = session.url
+    results = agent_connector.stop_session(session,false)
+    new_session = session.new_session?
+    self.session = nil
+
+    if new_session
+      instructions = "Please approve the new baseline at #{session_results_url}"
+      EyesLogger.info "--- New test ended.  #{instructions}"
+      message = "' #{session_start_info.scenario_id_or_name} of"\
+                " #{session_start_info.app_id_or_name}. #{instructions}"
+      raise Applitools::NewTestError.new(message, results)
+    elsif 0 < results.mismatches || 0 < results.missing 
+      EyesLogger.info "--- Failed test ended. See details at #{session_results_url}"
+      message = "' #{session_start_info.scenario_id_or_name} of"\
+                " #{session_start_info.app_id_or_name}'. See details at #{session_results_url}"
+      raise Applitools::TestFailedError.new(message, results)
+    end
+
+    EyesLogger.info "--- Test passed. See details at #{session_results_url}"
+  end
+
+  ## Use this method to perform seamless testing with selenium through eyes driver.
+  ## Using Selenium methods inside the 'test' block will send the messages to Selenium
+  ## after creating the Eyes triggers for them.
+  ##
+  ## Example:
+  #    eyes.test(app_name: 'my app1', test_name: 'my test') do |d|
+  #      get "http://www.google.com"
+  #      check_window("initial")
+  #    end
+  def test(params={}, &block)
+    begin
+      open(params)
+      yield(self, driver)
+      close
+    rescue Applitools::EyesError
+    ensure 
+      abort_if_not_closed
+      driver.quit
+    end
+  end
+
+
+    def abort_if_not_closed
+      return if disabled?
+      self.is_open = false
+      if session
+        begin
+          agent_connector.stop_session(session,true)
+        rescue Applitools::EyesError => e
+          EyesLogger.info "Failed to abort server session -> #{e.message} "
+        ensure
+          self.session = nil
+        end
+      end
+    end
+
+  private
+
+    def disabled? 
+      disabled
+    end
+
+    def start_session
+      assign_viewport_size
+      test_batch ||= Applitools::BatchInfo.new
+      app_env = Applitools::Environment.new(host_os, host_app, viewport_size)
+      application = driver.create_application
+      self.session_start_info = Applitools::StartInfo.new(AGENT_ID,
+        app_name, test_name, test_batch, app_env, application, 
+        match_level,nil, branch_name, parent_branch_name
+      )
+      self.session = agent_connector.start_session(session_start_info)
+      self.should_match_window_run_once_on_timeout = session.new_session?
+    end
+
+    def viewport_size?
+      self.viewport_size
+    end
+
+    def assign_viewport_size
+      if viewport_size?
+        self.viewport_size = Applitools::ViewportSize.new(driver, viewport_size)
+	self.viewport_size.set
+      else
+        self.viewport_size =  Applitools::ViewportSize.new(driver).extract_viewport_from_browser!
+      end
+    end
+
+    def to_hash
+      Hash[dimension.each_pair.to_a]
+    end
+end

data/lib/eyes_selenium/eyes/eyes_keyboard.rb

@@ -0,0 +1,25 @@
+class Applitools::EyesKeyboard
+  attr_reader :keyboard, :driver
+  
+  def initialize(driver, keyboard)
+    @driver = driver
+    @keyboard = keyboard
+  end
+
+  def send_keys(*keys)
+    active_element = Applitools::Element.new(driver, driver.switch_to.active_element)
+    current_control = active_element.region
+    Selenium::WebDriver::Keys.encode(keys).each do |key|
+      driver.user_inputs << Applitools::TextTrigger.new(key.to_s, current_control)
+    end
+    keyboard.send_keys(*keys)
+  end
+
+  def press(key)
+    keyboard.press(key)
+  end
+
+  def release(key)
+    keyboard.release(key)
+  end
+end

data/lib/eyes_selenium/eyes/eyes_mouse.rb

@@ -0,0 +1,60 @@
+class Applitools::EyesMouse
+
+  attr_reader :driver, :mouse
+  def initialize(driver, mouse)
+    @driver = driver
+    @mouse = mouse
+  end
+  
+  def click(element = nil)
+    extract_trigger_and_perform(:click, element)
+  end
+
+  def double_click(element = nil)
+    extract_trigger_and_perform(:double_click, element)
+  end
+
+  def context_click(element = nil)
+    extract_trigger_and_perform(:right_click, element)
+  end
+
+  def down(element = nil)
+    extract_trigger_and_perform(:down, element)
+  end
+
+  def up(element = nil)
+    extract_trigger_and_perform(:up, element)
+  end
+
+  def move_to(element, right_by = nil, down_by = nil)
+    element = element.web_element if element.is_a?(Applitools::Element)
+    location = element.location
+    location.x = [0,location.x].max
+    location.y = [0,location.y].max
+    current_control = Applitools::Region.new(0,0, *location.values)
+    driver.user_inputs << Applitools::MouseTrigger.new(:move, current_control, location)
+    element = element.web_element if element.is_a?(Applitools::Element)
+    mouse.move_to(element,right_by, down_by)
+  end
+
+  def move_by(right_by, down_by)
+    right = [0,right_by].max
+    down = [0,down_by].max
+    location = Selenium::WebDriver::Location.new(right,down)
+    current_control = Applitools::Region.new(0,0, right, down)
+    driver.user_inputs << Applitools::MouseTrigger.new(:move, current_control, location)
+    mouse.move_by(right_by,down_by)
+  end
+
+  private
+
+    def extract_trigger_and_perform(method, element=nil, *args)
+      location = element.location
+      location.x = [0,location.x].max
+      location.y = [0,location.y].max
+      current_control = Applitools::Region.new(0,0, *location.values)
+      driver.user_inputs << Applitools::MouseTrigger.new(method, current_control, location)
+      element = element.web_element if element.is_a?(Applitools::Element)
+      mouse.send(method,element,*args)
+    end
+end

data/lib/eyes_selenium/eyes/failure_reports.rb

@@ -0,0 +1,4 @@
+module Applitools::FailureReports
+  IMMEDIATE = 0
+  ON_CLOSE = 1
+end

data/lib/eyes_selenium/eyes/match_level.rb

@@ -0,0 +1,7 @@
+module MatchLevel
+  NONE = 0
+  LAYOUT = 1
+  CONTENT = 2
+  STRICT = 3
+  EXACT = 4
+end

data/lib/eyes_selenium/eyes/match_window_data.rb

@@ -0,0 +1,18 @@
+class Applitools::MatchWindowData
+
+  attr_reader :user_inputs, :app_output, :tag, :ignore_mismatch, :screenshot
+  def initialize(app_output,user_inputs=[], tag, ignore_mismatch, screenshot)
+    @user_inputs = user_inputs
+    @app_output = app_output
+    @tag = tag
+    @ignore_mismatch = ignore_mismatch
+    @screenshot = screenshot
+  end
+
+  # IMPORTANT This method returns a hash WITHOUT the screenshot property. This is on purspose! The screenshot should
+  # not be included as part of the json.
+  def to_hash
+    {userInputs: user_inputs.map(&:to_hash), appOutput: Hash[app_output.each_pair.to_a],
+     tag: @tag, ignoreMismatch: @ignore_mismatch}
+  end
+end

data/lib/eyes_selenium/eyes/match_window_task.rb

@@ -0,0 +1,71 @@
+require 'oily_png'
+require 'base64'
+
+class Applitools::MatchWindowTask
+
+  MATCH_INTERVAL = 0.5
+  AppOutput = Struct.new(:title, :screenshot64)
+  
+  attr_reader :agent_connector, :session, :driver, :max_window_load_time
+
+  def initialize(agent_connector, session, driver, max_window_load_time)
+    @agent_connector = agent_connector
+    @session = session
+    @driver = driver
+    @max_window_load_time = max_window_load_time
+    @last_checked_window = nil # +ChunkyPNG::Canvas+
+    @current_screenshot = nil # +ChunkyPNG::Canvas+
+  end
+
+  def match_window(tag,run_once_after_wait=false)
+    res = if max_window_load_time.zero? 
+      run(tag)
+    elsif run_once_after_wait
+      run(tag, max_window_load_time)
+    else
+      run_with_intervals(tag, max_window_load_time)
+    end
+
+    driver.clear_user_inputs and return res
+  end
+
+  def run(tag, wait_before_run=nil)
+    sleep(wait_before_run) if wait_before_run
+    match(tag)
+  end
+
+  def run_with_intervals(tag, total_run_time)
+    iterations = (total_run_time / MATCH_INTERVAL - 1).to_i
+    iterations.times do
+      sleep(MATCH_INTERVAL)
+      return true if match(tag, true)
+    end
+
+    ## lets try one more time if we still don't have a match
+    match(tag)
+  end
+
+  private
+
+    def prep_match_data(tag, ignore_mismatch)
+      title = driver.title
+      current_screenshot_encoded = Base64.decode64(driver.screenshot_as(:base64))
+      @current_screenshot = ChunkyPNG::Image.from_blob(current_screenshot_encoded)
+      compressed_screenshot = Applitools::Utils::ImageDeltaCompressor.compress_by_raw_blocks(@current_screenshot,
+                                                                                  current_screenshot_encoded,
+                                                                                  @last_checked_window)
+      app_output = AppOutput.new(title, nil)
+
+      return Applitools::MatchWindowData.new(app_output, driver.user_inputs, tag, ignore_mismatch, compressed_screenshot)
+    end
+
+    def match(tag, ignore_mismatch=false)
+      data = prep_match_data(tag, ignore_mismatch)
+      as_expected = agent_connector.match_window(session, data)
+      # If the server stored this image, it will be used as a base for our next screenshot compression
+      if !ignore_mismatch
+        @last_checked_window = @current_screenshot
+      end
+      return as_expected
+    end
+end

data/lib/eyes_selenium/eyes/mouse_trigger.rb

@@ -0,0 +1,19 @@
+class Applitools::MouseTrigger
+
+  MouseAction = { click: 1, right_click: 2,  double_click: 3,  move: 4,  down: 5,  up: 6 }
+
+  attr_reader :mouse_action, :control, :location
+
+  def initialize(mouse_action, control, location)
+    @mouse_action = MouseAction[mouse_action]
+    @control = control
+    @location = location
+  end
+
+  def to_hash
+    {
+      "$type" => "Applitools.Models.MouseTrigger, Core", mouseAction: mouse_action,
+      control: control.to_hash, location: Hash[location.each_pair.to_a]
+    }
+  end
+end

data/lib/eyes_selenium/eyes/region.rb

@@ -0,0 +1,22 @@
+class Applitools::Region
+  attr_accessor :left, :top, :height, :width
+
+  def initialize(left, top, height, width)
+    @left = left
+    @top = top
+    @height = height
+    @width = width
+  end
+
+  def middle_offset
+    mid_x = width / 2
+    mid_y = height / 2
+    Selenium::WebDriver::Location.new mid_x, mid_y
+  end
+
+  def to_hash
+    {
+      "$type" => "Applitools.Utils.Geometry.MutableRegion, Core", left: left, top: top, height: height, width: width
+    }
+  end
+end

data/lib/eyes_selenium/eyes/screenshot_taker.rb

@@ -0,0 +1,18 @@
+require 'httparty'
+class Applitools::ScreenshotTaker
+  include HTTParty
+  headers 'Accept' => 'application/json'
+  headers 'Content-Type' => 'application/json'
+
+  attr_reader :driver_server_uri, :driver_session_id
+
+  def initialize(driver_server_uri, driver_session_id)
+    @driver_server_uri = driver_server_uri
+    @driver_session_id = driver_session_id
+  end
+
+  def screenshot
+    res = self.class.get(driver_server_uri.gsub(/\/$/,"") + "/session/#{driver_session_id}/screenshot").to_s
+    res.parsed_response['value']
+  end
+end