eyes_selenium_ruby 1.1.0

data/lib/eyes_selenium_ruby/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_ruby/eyes/failure_reports.rb

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

data/lib/eyes_selenium_ruby/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_ruby/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, ignore_mismatch: @ignore_mismatch}
+  end
+end

data/lib/eyes_selenium_ruby/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)
+      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
+    end
+end

data/lib/eyes_selenium_ruby/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_ruby/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_ruby/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

data/lib/eyes_selenium_ruby/eyes/session.rb

@@ -0,0 +1,14 @@
+class Applitools::Session
+  attr_reader :eyes, :id, :url
+  attr_accessor :new_session
+  def initialize(session_id, session_url, new_session)
+    @new_session = new_session
+    @id = session_id
+    @url = session_url
+  end
+
+  def new_session?
+    self.new_session
+  end
+end
+

data/lib/eyes_selenium_ruby/eyes/start_info.rb

@@ -0,0 +1,33 @@
+class Applitools::StartInfo
+
+  ATTRIBUTES = %w[ app_id_or_name ver_id scenario_id_or_name batch_info
+                environment application match_level branch_name parent_branch_name ]
+
+  ATTRIBUTES.each do |attr|
+    attr_accessor attr
+  end
+
+  ## add a config file with this stuff, and use hash arg
+  def initialize(app_id_or_name, scenario_id_or_name, batch_info, environment,
+                 application, match_level, ver_id=nil, branch_name=nil, 
+                 parent_branch_name=nil)
+    @app_id_or_name = app_id_or_name
+    @ver_id = ver_id
+    @scenario_id_or_name = scenario_id_or_name
+    @batch_info = batch_info
+    @environment = environment
+    @application = application
+    @match_level = match_level
+    @branch_name = branch_name
+    @parent_branch_name = parent_branch_name
+  end
+
+  def to_hash
+    {  
+      AppIdOrName: app_id_or_name, VerId: ver_id, ScenarioIdOrName: scenario_id_or_name,
+      BatchInfo: batch_info.to_hash, Environment: environment.to_hash, 
+      Application: application.to_hash, matchLevel: match_level, branchName: branch_name,
+      parentBranchName: parent_branch_name
+    }
+  end
+end

data/lib/eyes_selenium_ruby/eyes/target_app.rb

@@ -0,0 +1,17 @@
+class Applitools::TargetApp
+
+  attr_reader :url, :session_id, :user_agent
+
+  def initialize(url, session_id, user_agent)
+    @url = url
+    @session_id = session_id
+    @user_agent = user_agent
+  end
+
+  def to_hash
+    {
+      "$type" => "Applitools.Framework.TargetWebDriverApplication, Core", 
+      url: URI.encode(url.to_s), sessionId: session_id, userAgent: user_agent
+    }
+  end
+end

data/lib/eyes_selenium_ruby/eyes/test_results.rb

@@ -0,0 +1,21 @@
+class Applitools::TestResults
+  attr_reader :steps, :matches, :mismatches, :missing, :exact_matches, :strict_matches,
+              :context_matches, :layout_matches, :none_matches
+  def initialize(steps=0, matches=0, mismatches=0, missing=0,
+                 exact_matches=0, strict_matches=0, content_matches=0, 
+                 layout_matches=0, none_matches=0)
+    @steps = steps
+    @matches = matches
+    @mismatches =  mismatches
+    @missing =  missing
+    @exact_matches =  exact_matches
+    @strict_matches = strict_matches
+    @content_matches =  content_matches
+    @layout_matches =  layout_matches
+    @none_matches =  none_matches
+  end
+
+  def to_s
+    "[ steps: #{steps}, matches: #{matches}, mismatches: #{mismatches}, missing: #{missing} ]"
+  end
+end

data/lib/eyes_selenium_ruby/eyes/text_trigger.rb

@@ -0,0 +1,15 @@
+class Applitools::TextTrigger
+  
+  attr_reader :text, :control
+
+  def initialize(text, control)
+    @text = text
+    @control = control
+  end
+
+  def to_hash
+    {
+      "$type" => "Applitools.Models.TextTrigger, Core", text: text, control: control.to_hash
+    }
+  end
+end

data/lib/eyes_selenium_ruby/eyes/viewport_size.rb

@@ -0,0 +1,109 @@
+class Applitools::ViewportSize
+
+  GET_VIEWPORT_HEIGHT_JAVASCRIPT_FOR_NORMAL_BROWSER = "return window.innerHeight"
+  GET_VIEWPORT_WIDTH_JAVASCRIPT_FOR_NORMAL_BROWSER  = "return window.innerWidth"
+
+  DOCUMENT_CLEAR_SCROLL_BARS_JAVASCRIPT = "var doc = document.documentElement;" +
+                                          "var previousOverflow = doc.style.overflow;"
+  DOCUMENT_RESET_SCROLL_BARS_JAVASCRIPT = "doc.style.overflow = previousOverflow;"
+  DOCUMENT_RETURN_JAVASCRIPT            = "return __applitools_result;"
+
+  GET_VIEWPORT_WIDTH_JAVASCRIPT_FOR_BAD_BROWSERS = 
+                  DOCUMENT_CLEAR_SCROLL_BARS_JAVASCRIPT        +
+                  "var __applitools_result = doc.clientWidth;" +
+                  DOCUMENT_RESET_SCROLL_BARS_JAVASCRIPT        +
+                  DOCUMENT_RETURN_JAVASCRIPT
+
+  GET_VIEWPORT_HEIGHT_JAVASCRIPT_FOR_BAD_BROWSERS = 
+                  DOCUMENT_CLEAR_SCROLL_BARS_JAVASCRIPT         +
+                  "var __applitools_result = doc.clientHeight;" +
+                  DOCUMENT_RESET_SCROLL_BARS_JAVASCRIPT         +
+                  DOCUMENT_RETURN_JAVASCRIPT
+
+  Dimension = Struct.new(:width, :height)
+  def Dimension.to_h
+    {width: width, height: height}
+  end
+
+  attr_reader :driver
+  attr_accessor :dimension
+  def initialize(driver, dimension=nil)
+    @driver = driver
+    @dimension = dimension
+  end
+
+  def extract_viewport_width
+     begin
+       return driver.execute_script(GET_VIEWPORT_WIDTH_JAVASCRIPT_FOR_NORMAL_BROWSER)
+     rescue => e 
+       EyesLogger.info "getViewportSize(): Browser does not support innerWidth (#{e.message})"
+     end
+
+    driver.execute_script(GET_VIEWPORT_WIDTH_JAVASCRIPT_FOR_BAD_BROWSERS)
+  end
+
+  def extract_viewport_height
+     begin
+       return driver.execute_script(GET_VIEWPORT_HEIGHT_JAVASCRIPT_FOR_NORMAL_BROWSER)
+     rescue  => e 
+       EyesLogger.info "getViewportSize(): Browser does not support innerHeight (#{e.message})"
+     end
+
+    driver.execute_script(GET_VIEWPORT_WIDTH_JAVASCRIPT_FOR_BAD_BROWSERS)
+  end
+
+  def extract_viewport_from_browser!
+    self.dimension = extract_viewport_from_browser
+  end
+
+  def extract_viewport_from_browser
+    width  = extract_viewport_width 
+    height = extract_viewport_height
+    Dimension.new(width,height)
+  rescue => e
+    EyesLogger.info "getViewportSize(): only window size is available (#{e.message})"
+    width, height = *browser_size.values
+    Dimension.new(width,height)
+  end
+  alias_method :viewport_size, :extract_viewport_from_browser
+
+  def set
+    if !dimension.respond_to?(:width) && !dimension.respond_to?(:height)
+      raise ArgumentError, "expected #{dimension.inspect}:#{dimension.class}" +
+                                      " to respond to #width and #height"
+    end
+
+    self.browser_size = dimension
+    verify_size(:browser_size)
+
+    cur_viewport_size = extract_viewport_from_browser
+    self.browser_size = Dimension.new(
+                          (2 * browser_size.width) - cur_viewport_size.width,
+                          (2 * browser_size.height) - cur_viewport_size.height
+                        )
+    verify_size(:viewport_size)
+  end
+
+  def verify_size(to_verify, sleep_time=1, retries=3)
+    retries.times do
+      sleep(sleep_time) 
+      cur_size = send(to_verify)
+      return if cur_size.values == dimension.values
+    end
+
+    EyesLogger.info(err_msg = "Failed setting #{to_verify} to #{required_dimensions.values}")
+    raise Applitools::TestFailedError.new(err_msg)
+  end
+
+  def browser_size
+    driver.manage.window.size
+  end
+
+  def browser_size=(other)
+    self.driver.manage.window.size = other
+  end
+
+  def to_hash
+    Hash[dimension.each_pair.to_a]
+  end
+end

data/lib/eyes_selenium_ruby/eyes_logger.rb

@@ -0,0 +1,18 @@
+require 'logger'
+
+module EyesLogger
+  def self.logger(to=STDOUT, level=Logger::INFO)
+    return @@log if defined?(@@log)
+    @@log = Logger.new(to)
+    @@log.level = level
+    @@log
+  end
+
+  def self.info(msg)
+    logger.info(msg)
+  end
+
+  def self.debug(msg)
+    logger.debug(msg)
+  end
+end

data/lib/eyes_selenium_ruby/utils/image_delta_compressor.rb

@@ -0,0 +1,147 @@
+=begin
+Applitools SDK class.
+
+Provides image compression based on image sequences and deflate
+=end
+require 'oily_png'
+require 'base64'
+
+class Applitools::Utils::ImageDeltaCompressor
+
+  # Compresses the target image based on the source image.
+  # +target+:: +ChunkyPNG::Canvas+ The image to compress based on the source image.
+  # +target_encoded+:: +Array+ The uncompressed image as binary string.
+  # +source+:: +ChunkyPNG::Canvas+ The source image used as a base for compressing the target image.
+  # +block_size+:: +Integer+ The width/height of each block.
+  # ++
+  # Returns +String+ The binary result (either the compressed image, or the uncompressed image if the compression
+  # is greater in length)
+  def self.compress_by_raw_blocks(target, target_encoded, source, block_size = 10)
+    # If we can't compress for any reason, return the target image as is.
+    if source.nil? || (source.height != target.height) || (source.width != target.width)
+      # Returning a COPY of the target binary string
+      return String.new(target_encoded) 
+    end
+
+    # Preparing the variables we need
+    target_pixels = target.to_rgb_stream.unpack('C*')
+    source_pixels = source.to_rgb_stream.unpack('C*')
+    image_size = Dimension.new(target.width, target.height)
+    block_columns_count = (target.width / block_size) + ((target.width % block_size) == 0 ? 0 : 1)
+    block_rows_count = (target.height / block_size) + ((target.height % block_size) == 0 ? 0 : 1)
+
+    # IMPORTANT: The "-Zlib::MAX_WBITS" tells ZLib to create raw deflate compression, without the
+    # "Zlib headers" (this isn't documented in the Zlib page, I found this in some internet forum).
+    compressor = Zlib::Deflate.new(Zlib::BEST_COMPRESSION, -Zlib::MAX_WBITS)
+
+    compression_result = ''
+
+    # Writing the data header
+    compression_result += @@PREAMBLE.encode("UTF-8")
+    compression_result += [@@FORMAT_RAW_BLOCKS].pack("C")
+    compression_result += [0].pack("S>") #Source id, Big Endian
+    compression_result += [block_size].pack("S>") #Big Endian
+
+
+    # We perform the compression for each channel
+    3.times do |channel|
+      block_number = 0
+      block_rows_count.times do |block_row|
+        block_columns_count.times do |block_column|
+          actual_channel_index = 2 - channel # Since the image bytes are BGR and the server expects RGB...
+          compare_result = compare_and_copy_block_channel_data(source_pixels, target_pixels, image_size, 3, block_size,
+                                                               block_column, block_row, actual_channel_index)
+
+          if !compare_result.identical
+            channel_bytes = compare_result.channel_bytes
+            string_to_compress = [channel].pack('C')
+            string_to_compress += [block_number].pack('L>')
+            string_to_compress += channel_bytes.pack('C*')
+            compression_result += compressor.deflate(string_to_compress)
+
+            # If the compressed data so far is greater than the uncompressed
+            # representation of the target, just return the target.
+            if compression_result.length > target_encoded.length
+              compressor.close
+              # Returning a COPY of the target bytes
+              return String.new(target_encoded)
+            end
+          end
+          block_number += 1
+        end
+      end
+    end
+    # Compress and flush any remaining uncompressed data in the input buffer.
+    compression_result += compressor.finish
+    compressor.close
+    # Returning the compressed result as a byte array
+    return compression_result
+  end
+
+
+  ### PRIVATE
+  private
+
+  @@PREAMBLE = "applitools"
+  @@FORMAT_RAW_BLOCKS = 3
+
+  Dimension = Struct.new(:width, :height)
+  CompareAndCopyBlockChannelDataResult = Struct.new(:identical, :channel_bytes)
+
+
+  # Computes the width and height of the image data contained in the block
+  # at the input column and row.
+  # +image_size+:: +Dimension+ The image size in pixels.
+  # +block_size+:: The block size for which we would like to compute the image data width and height.
+  # +block_column+:: The block column index.
+  # +block_row+:: The block row index.
+  # ++
+  # Returns the width and height of the image data contained in the block are returned as a +Dimension+.
+  def self.get_actual_block_size(image_size, block_size, block_column, block_row)
+    actual_width = [image_size.width - (block_column * block_size), block_size].min
+    actual_height = [image_size.height - (block_row * block_size), block_size].min
+    Dimension.new(actual_width, actual_height)
+  end
+
+  # Compares a block of pixels between the source and target and copies the target's block bytes to the result.
+  # +source_pixels+:: +Array+ of bytes, representing the pixels of the source image.
+  # +target_pixels+:: +Array+ of bytes, representing the pixels of the target image.
+  # +image_size+:: +Dimension+ The size of the source/target image (remember they must be the same size).
+  # +pixel_length+:: +Integer+ The number of bytes composing a pixel
+  # +block_size+:: +Integer+ The width/height of the block (block is a square, theoretically).
+  # +block_column+:: +Integer+ The block column index (when looking at the images as a grid of blocks).
+  # +block_row+:: +Integer+ The block row index (when looking at the images as a grid of blocks).
+  # +channel+:: +Integer+ The index of the channel we're comparing.
+  # ++
+  # Returns +CompareAndCopyBlockChannelDataResult+ object containing a flag saying whether the blocks are identical
+  # and a copy of the target block's bytes.
+  def self.compare_and_copy_block_channel_data(source_pixels, target_pixels, image_size, pixel_length, block_size,
+      block_column, block_row, channel)
+    identical = true
+
+    actual_block_size = get_actual_block_size(image_size, block_size, block_column, block_row)
+
+    # Getting the actual amount of data in the block we wish to copy
+    actual_block_height = actual_block_size.height
+    actual_block_width = actual_block_size.width
+
+    stride = image_size.width * pixel_length
+
+    # Iterating the block's pixels and comparing the source and target
+    channel_bytes = []
+    actual_block_height.times do |h|
+      offset = (((block_size * block_row) + h) * stride) + (block_size * block_column * pixel_length) + channel
+      actual_block_width.times do |w|
+        source_byte = source_pixels[offset]
+        target_byte = target_pixels[offset]
+        if source_byte != target_byte
+          identical = false
+        end
+        channel_bytes << target_byte
+        offset += pixel_length
+      end
+    end
+    # Returning the compare-and-copy result
+    CompareAndCopyBlockChannelDataResult.new(identical, channel_bytes)
+  end
+end

data/lib/eyes_selenium_ruby/utils.rb

@@ -0,0 +1,5 @@
+module Applitools
+  module Utils
+    require 'eyes_selenium_ruby/utils/image_delta_compressor'
+  end
+end

data/lib/eyes_selenium_ruby/version.rb

@@ -0,0 +1,3 @@
+module Applitools
+  VERSION = "1.1.0"
+end

data/lib/eyes_selenium_ruby.rb

@@ -0,0 +1,41 @@
+require 'json'
+require 'eyes_selenium_ruby/eyes_logger'
+require 'json'
+module Applitools
+  include EyesLogger
+  class EyesError < StandardError; end
+  class EyesAbort < EyesError; end
+
+  class TestFailedError < StandardError
+    attr_accessor :test_results
+    def initialize(message, test_results=nil)
+      super(message)
+      @test_results = test_results
+    end
+  end
+  class NewTestError < TestFailedError; end
+
+  require 'eyes_selenium_ruby/utils'
+  require "eyes_selenium_ruby/eyes/agent_connecter"
+  require "eyes_selenium_ruby/eyes/target_app"
+  require 'eyes_selenium_ruby/eyes/batch_info'
+  require "eyes_selenium_ruby/eyes/driver"
+  require 'eyes_selenium_ruby/eyes/element'
+  require 'eyes_selenium_ruby/eyes/environment'
+  require 'eyes_selenium_ruby/eyes/eyes'
+  require 'eyes_selenium_ruby/eyes/eyes_keyboard'
+  require 'eyes_selenium_ruby/eyes/eyes_mouse'
+  require 'eyes_selenium_ruby/eyes/failure_reports'
+  require 'eyes_selenium_ruby/eyes/match_level'
+  require 'eyes_selenium_ruby/eyes/match_window_data'
+  require 'eyes_selenium_ruby/eyes/match_window_task'
+  require 'eyes_selenium_ruby/eyes/mouse_trigger'
+  require 'eyes_selenium_ruby/eyes/region'
+  require 'eyes_selenium_ruby/eyes/screenshot_taker'
+  require 'eyes_selenium_ruby/eyes/session'
+  require 'eyes_selenium_ruby/eyes/start_info'
+  require 'eyes_selenium_ruby/eyes/test_results'
+  require 'eyes_selenium_ruby/eyes/text_trigger'
+  require "eyes_selenium_ruby/version"
+  require 'eyes_selenium_ruby/eyes/viewport_size'
+end