eyes_core 3.0.4

data/lib/applitools/core/region.rb

@@ -0,0 +1,180 @@
+module Applitools
+  class Region
+    attr_accessor :left, :top, :width, :height
+    alias x left
+    alias y top
+
+    class << self
+      def from_location_size(location, size)
+        new location.x, location.y, size.width, size.height
+      end
+    end
+
+    def initialize(left, top, width, height)
+      @left = left.round
+      @top = top.round
+      @width = width.round
+      @height = height.round
+    end
+
+    EMPTY = Region.new(0, 0, 0, 0)
+
+    def make_empty
+      @left = EMPTY.left
+      @top = EMPTY.top
+      @width = EMPTY.width
+      @height = EMPTY.height
+    end
+
+    def empty?
+      @left == EMPTY.left && @top == EMPTY.top && @width == EMPTY.width && @height == EMPTY.height
+    end
+
+    def size
+      Applitools::RectangleSize.new width, height
+    end
+
+    def location
+      Location.new left, top
+    end
+
+    def location=(other_location)
+      self.left = other_location.left
+      self.top = other_location.top
+    end
+
+    def right
+      left + width
+    end
+
+    def bottom
+      top + height
+    end
+
+    def intersecting?(other)
+      ((left <= other.left && other.left <= right) || (other.left <= left && left <= other.right)) &&
+        ((top <= other.top && other.top <= bottom) || (other.top <= top && top <= other.bottom))
+    end
+
+    def intersect(other)
+      unless intersecting?(other)
+        make_empty
+
+        return
+      end
+
+      i_left = left >= other.left ? left : other.left
+      i_right = right <= other.right ? right : other.right
+      i_top = top >= other.top ? top : other.top
+      i_bottom = bottom <= other.bottom ? bottom : other.bottom
+
+      @left = i_left
+      @top = i_top
+      @width = i_right - i_left
+      @height = i_bottom - i_top
+    end
+
+    def contains?(other_left, other_top)
+      other_left >= left && other_left <= right && other_top >= top && other_top <= bottom
+    end
+
+    def middle_offset
+      mid_x = width / 2
+      mid_y = height / 2
+      Applitools::Location.for(mid_x.round, mid_y.round)
+    end
+
+    def sub_regions(subregion_size, is_fixed_size = false)
+      return self.class.sub_regions_with_fixed_size self, subregion_size if is_fixed_size
+      self.class.sub_regions_with_varying_size self, subregion_size
+    end
+
+    def to_hash
+      {
+        left: left,
+        top: top,
+        height: height,
+        width: width
+      }
+    end
+
+    def to_s
+      "(#{left}, #{top}), #{width} x #{height}"
+    end
+
+    def size_equals?(region)
+      width == region.width && height == region.height
+    end
+
+    class << self
+      def sub_regions_with_fixed_size(container_region, sub_region)
+        Applitools::ArgumentGuard.not_nil container_region, 'container_region'
+        Applitools::ArgumentGuard.not_nil sub_region, 'sub_region'
+
+        Applitools::ArgumentGuard.greater_than_zero(sub_region.width, 'sub_region.width')
+        Applitools::ArgumentGuard.greater_than_zero(sub_region.height, 'sub_region.height')
+
+        sub_region_width = sub_region.width
+        sub_region_height = sub_region.height
+
+        # Normalizing.
+        sub_region_width = container_region.width if sub_region_width > container_region.width
+        sub_region_height = container_region.height if sub_region_height > container_region.height
+
+        if sub_region_width == container_region.width && sub_region_height == container_region.height
+          return Enumerator(1) do |y|
+            y << sub_region
+          end
+        end
+
+        current_top = container_region.top
+        bottom = container_region.top + container_region.height - 1
+        right = container_region.left + container_region.width - 1
+        Enumerator.new do |y|
+          while current_top <= bottom
+            current_top = (bottom - sub_region_height) + 1 if current_top + sub_region_height > bottom
+            current_left = container_region.left
+            while current_left <= right
+              current_left = (rught - sub_region_width) + 1 if current_left + sub_region_width > right
+              y << new(current_left, current_top, sub_region_width, sub_region_height)
+              current_left += sub_region_width
+            end
+            current_top += sub_region_height
+          end
+        end
+      end
+
+      def sub_regions_with_varying_size(container_region, sub_region)
+        Applitools::ArgumentGuard.not_nil container_region, 'container_region'
+        Applitools::ArgumentGuard.not_nil sub_region, 'sub_region'
+
+        Applitools::ArgumentGuard.greater_than_zero(sub_region.width, 'sub_region.width')
+        Applitools::ArgumentGuard.greater_than_zero(sub_region.height, 'sub_region.height')
+
+        current_top = container_region.top
+        bottom = container_region.top + container_region.height
+        right = container_region.left + container_region.width
+
+        Enumerator.new do |y|
+          while current_top < bottom
+            current_bottom = current_top + sub_region.height
+            current_bottom = bottom if current_bottom > bottom
+            current_left = container_region.left
+            while current_left < right
+              current_right = current_left + sub_region.width
+              current_right = right if current_right > right
+
+              current_height = current_bottom - current_top
+              current_width = current_right - current_left
+
+              y << new(current_left, current_top, current_width, current_height)
+
+              current_left += sub_region.width
+            end
+            current_top += sub_region.height
+          end
+        end
+      end
+    end
+  end
+end

data/lib/applitools/core/screenshot.rb

@@ -0,0 +1,49 @@
+module Applitools
+  class Screenshot < Delegator
+    extend Forwardable
+    def_delegators :header, :width, :height
+
+    class << self
+      def from_region(region)
+        new ChunkyPNG::Image.new(region.width, region.height).to_blob
+      end
+    end
+
+    def initialize(image)
+      @datastream = ::ChunkyPNG::Datastream.from_string image
+    end
+
+    def to_blob
+      @datastream.to_blob
+    end
+
+    def __getobj__
+      restore
+    end
+
+    def header
+      @datastream.header_chunk
+    end
+
+    def __setobj__(obj)
+      @datastream = obj.to_datastream
+      self
+    end
+
+    def method_missing(method, *args, &block)
+      if method =~ /^.+!$/
+        __setobj__ super
+      else
+        super
+      end
+    end
+
+    def respond_to_missing?(method_name, include_private = false)
+      super
+    end
+
+    def restore
+      ::ChunkyPNG::Image.from_datastream @datastream
+    end
+  end
+end

data/lib/applitools/core/session.rb

@@ -0,0 +1,15 @@
+module Applitools
+  class Session
+    attr_reader :id, :url
+
+    def initialize(session_id, session_url, new_session)
+      @id = session_id
+      @url = session_url
+      @new_session = new_session
+    end
+
+    def new_session?
+      @new_session
+    end
+  end
+end

data/lib/applitools/core/session_start_info.rb

@@ -0,0 +1,33 @@
+module Applitools
+  class SessionStartInfo
+    attr_accessor :app_id_or_name, :scenario_id_or_name
+
+    def initialize(options = {})
+      @agent_id = options[:agent_id]
+      @app_id_or_name = options[:app_id_or_name]
+      @ver_id = options[:ver_id]
+      @scenario_id_or_name = options[:scenario_id_or_name]
+      @batch_info = options[:batch_info]
+      @env_name = options[:env_name]
+      @environment = options[:environment]
+      @match_level = options[:match_level]
+      @branch_name = options[:branch_name]
+      @parent_branch_name = options[:parent_branch_name]
+    end
+
+    def to_hash
+      {
+        agent_id: @agent_id,
+        app_id_or_name: @app_id_or_name,
+        ver_id: @ver_id,
+        scenario_id_or_name: @scenario_id_or_name,
+        batch_info: @batch_info.to_hash,
+        env_name: @env_name,
+        environment: @environment.to_hash,
+        match_level: @match_level,
+        branch_name: @branch_name,
+        parent_branch_name: @parent_branch_name
+      }
+    end
+  end
+end

data/lib/applitools/core/test_results.rb

@@ -0,0 +1,55 @@
+require 'yaml'
+
+module Applitools
+  class TestResults
+    attr_accessor :is_new, :url
+    attr_reader :steps, :matches, :mismatches, :missing
+
+    def initialize(results = {})
+      @steps = results.fetch('steps', 0)
+      @matches = results.fetch('matches', 0)
+      @mismatches = results.fetch('mismatches', 0)
+      @missing = results.fetch('missing', 0)
+      @is_new = nil
+      @url = nil
+      @original_results = results
+    end
+
+    def passed?
+      return !(mismatches > 0) && !(missing > 0) unless new?
+      false
+    end
+
+    def failed?
+      return (mismatches > 0) || (missing > 0) unless new?
+      false
+    end
+
+    def new?
+      is_new
+    end
+
+    def ==(other)
+      if other.is_a? self.class
+        result = true
+        %i(is_new url steps matches mismatches missing).each do |field|
+          result &&= send(field) == other.send(field)
+        end
+        return result if result
+      end
+      false
+    end
+
+    alias is_passed passed?
+
+    def to_s(advanced = false)
+      is_new_str = ''
+      is_new_str = is_new ? 'New test' : 'Existing test' unless is_new.nil?
+
+      return @original_results.to_yaml if advanced
+
+      "#{is_new_str} [ steps: #{steps}, matches: #{matches}, mismatches: #{mismatches}, missing: #{missing} ], " \
+        "URL: #{url}"
+    end
+  end
+end

data/lib/applitools/core/text_trigger.rb

@@ -0,0 +1,24 @@
+require 'applitools/core/trigger'
+module Applitools
+  class TextTrigger < Trigger
+    TRIGGER_TYPE = :Text
+    attr_reader :text, :control
+
+    def initialize(text, control)
+      @text = text
+      @control = control
+    end
+
+    def to_hash
+      {
+        triggerType: trigger_type,
+        text: text,
+        control: control.to_hash
+      }
+    end
+
+    def to_s
+      "Text [#{@control}] #{@text}"
+    end
+  end
+end

data/lib/applitools/core/trigger.rb

@@ -0,0 +1,8 @@
+module Applitools
+  class Trigger
+    TRIGGER_TYPE = :unknown
+    def trigger_type
+      self.class::TRIGGER_TYPE
+    end
+  end
+end

data/lib/applitools/extensions.rb

@@ -0,0 +1,18 @@
+# @!visibility private
+class Module
+  def alias_attribute(new_name, old_name)
+    module_eval <<-STR, __FILE__, __LINE__ + 1
+      def #{new_name}
+        self.#{old_name}
+      end
+
+      def #{new_name}?
+        self.#{old_name}?
+      end
+
+      def #{new_name}=(v)
+        self.#{old_name}
+      end
+    STR
+  end
+end

data/lib/applitools/eyes_logger.rb

@@ -0,0 +1,45 @@
+require 'logger'
+
+module Applitools::EyesLogger
+  class NullLogger < Logger
+    def initialize(*_args) end
+
+    def add(*_args, &_block) end
+  end
+
+  extend Forwardable
+  extend self
+
+  MANDATORY_METHODS = [:debug, :info, :close].freeze
+  OPTIONAL_METHODS = [:warn, :error, :fatal].freeze
+
+  def_delegators :@log_handler, *MANDATORY_METHODS
+
+  @log_handler = NullLogger.new
+
+  def log_handler=(log_handler)
+    raise Applitools::EyesError.new('log_handler must implement Logger!') unless valid?(log_handler)
+
+    @log_handler = log_handler
+  end
+
+  def log_handler
+    @log_handler
+  end
+
+  def logger
+    self
+  end
+
+  OPTIONAL_METHODS.each do |method|
+    define_singleton_method(method) do |msg|
+      @log_handler.respond_to?(method) ? @log_handler.send(method, msg) : @log_handler.info(msg)
+    end
+  end
+
+  private
+
+  def valid?(log_handler)
+    MANDATORY_METHODS.all? { |method| log_handler.respond_to?(method) }
+  end
+end

data/lib/applitools/images/eyes.rb

@@ -0,0 +1,204 @@
+require 'applitools/core/eyes_base'
+
+# Eyes Images SDK
+#
+module Applitools::Images
+  # A class to perform visual validation on images. Allows to handle user data like +Mouse trigger+ and +Text trigger+
+  # @example
+  #   eyes = Applitools::Images::Eyes.new
+  #   eyes.open(app_name: 'App name', test_name: 'Test name')
+  #   eyes.check_image(eyes.check_image(image_path: '~/test/some_screenshot.png', tag: 'My Test')
+  #   eyes.close(true)
+  class Eyes < Applitools::EyesBase
+    # @!visibility private
+    attr_accessor :base_agent_id, :screenshot, :inferred_environment, :title
+
+    # @!visibility private
+    def capture_screenshot
+      @screenshot
+    end
+
+    # Creates a new eyes object
+    # @example
+    #   eyes = Applitools::Images::Eyes.new
+    # @param server_url The Eyes Server URL
+    def initialize(server_url = Applitools::Connectivity::ServerConnector::DEFAULT_SERVER_URL)
+      super
+      self.base_agent_id = 'eyes.images.ruby/1.0.0'
+    end
+
+    # Starts a test.
+    # @param [Hash] options
+    # @option options [String] :app_name the name of the application under trest. Required.
+    # @option options [String] :test_name the test name. Required
+    # @option options [String | Hash] :viewport_size viewport size for the baseline, may be passed as a
+    #   string (<tt>'800x600'</tt>) or as a hash (<tt>{width: 800, height: 600}</tt>).
+    #   If ommited, the viewport size will be grabbed from the actual image size
+    # @example
+    #   eyes.open app_name: 'my app', test_name: 'my test'
+    def open(options = {})
+      Applitools::ArgumentGuard.hash options, 'open(options)', [:app_name, :test_name]
+      options[:viewport_size] = Applitools::RectangleSize.from_any_argument options[:viewport_size]
+      open_base options
+    end
+
+    # Opens eyes using passed options, yields the block and then closes eyes session.
+    # Use Applitools::Images::Eyes method inside the block to perform the test. If the block throws an exception,
+    # eyes session will be closed correctly.
+    # @example
+    #  eyes.test(app_name: 'Eyes.Java', test_name: 'home2') do
+    #    eyes.check_image(image_path: './images/viber-home.png')
+    #    eyes.check_image(image_path: './images/viber-bada.png')
+    #  end
+    def test(options = {}, &_block)
+      open(options)
+      yield
+      close
+    ensure
+      abort_if_not_closed
+    end
+
+    # Matches the input image with the next expected image. Takes a hash as an argument. Returns +boolean+
+    # as result of matching.
+    # @param [Hash] options
+    # @option options [Applitools::Screenshot] :image
+    # @option options [String] :image_bytes image in PNG format. Can be obtained as ChunkyPNG::Image.to_blob()
+    # @option options [String] :image_path
+    # @option options [String] :tag An optional tag to be associated with the validation checkpoint.
+    # @option options [Boolean] :ignore_mismatch If set to +true+ the server should ignore a negative
+    #   result for the visual validation. (+false+ by default)
+    # @example Image is a file
+    #   eyes.check_image(image_path: '~/test/some_screenshot.png', tag: 'My Test')
+    # @example Image is a +Applitools::Screenshot+ instance
+    #   eyes.check_image(image: my_image, tag: 'My Test')
+    # @example Image is a +String+
+    #   eyes.check_image(image_bytes: string_represents_image, tag: 'My Test')
+    # @example Ignore mismatch
+    #   eyes.check_image(image: my_image, tag: 'My Test', ignore_mismatch: true)
+    def check_image(options)
+      options = { tag: nil, ignore_mismatch: false }.merge options
+
+      if disabled?
+        logger.info "check_image(image, #{options[:tag]}, #{options[:ignore_mismatch]}): Ignored"
+        return false
+      end
+
+      image = get_image_from_options options
+
+      logger.info "check_image(image, #{options[:tag]}, #{options[:ignore_mismatch]})"
+      if image.is_a? Applitools::Screenshot
+        self.viewport_size = Applitools::RectangleSize.new image.width, image.height if viewport_size.nil?
+        self.screenshot = EyesImagesScreenshot.new image
+      end
+      self.title = options[:tag] || ''
+      region_provider = Object.new
+      region_provider.instance_eval do
+        define_singleton_method :region do
+          Applitools::Region::EMPTY
+        end
+
+        define_singleton_method :coordinate_type do
+          nil
+        end
+      end
+      mr = check_window_base region_provider, options[:tag], options[:ignore_mismatch],
+        Applitools::EyesBase::USE_DEFAULT_TIMEOUT
+      mr.as_expected?
+    end
+
+    # Performs visual validation for the current image.
+    # @param [Hash] options
+    # @option options [Applitools::Region] :region A region to validate within the image
+    # @option options [Applitools::Screenshot] :image Image to validate
+    # @option options [String] :image_bytes Image in +PNG+ format. Can be obtained as ChunkyPNG::Image.to_blob()
+    # @option options [String] :image_path Path to image file
+    # @option options [String] :tag An optional tag to be associated with the validation checkpoint.
+    # @option options [Boolean] :ignore_mismatch If set to +true+ the server would ignore a negative
+    #   result for the visual validation
+    # @example Image is a file
+    #   eyes.check_region(image_path: '~/test/some_screenshot.png', region: my_region, tag: 'My Test')
+    # @example Image is a Applitools::Screenshot instance
+    #   eyes.check_region(image: my_image, tag: 'My Test', region: my_region)
+    # @example Image is a +String+
+    #   eyes.check_region(image_bytes: string_represents_image, tag: 'My Test', region: my_region)
+    def check_region(options)
+      options = { tag: nil, ignore_mismatch: false }.merge options
+
+      if disabled?
+        logger.info "check_region(image, #{options[:tag]}, #{options[:ignore_mismatch]}): Ignored"
+        return false
+      end
+
+      Applitools::ArgumentGuard.not_nil options[:region], 'options[:region] can\'t be nil!'
+      image = get_image_from_options options
+
+      logger.info "check_region(image, #{options[:region]}, #{options[:tag]}, #{options[:ignore_mismatch]})"
+
+      if image.is_a? Applitools::Screenshot
+        self.viewport_size = Applitools::RectangleSize.new image.width, image.height if viewport_size.nil?
+        self.screenshot = EyesImagesScreenshot.new image
+      end
+      self.title = options[:tag] || ''
+
+      region_provider = Object.new
+      region_provider.instance_eval do
+        define_singleton_method :region do
+          options[:region]
+        end
+        define_singleton_method :coordinate_type do
+          Applitools::EyesScreenshot::COORDINATE_TYPES[:screenshot_as_is]
+        end
+      end
+      mr = check_window_base region_provider, options[:tag], options[:ignore_mismatch],
+        Applitools::EyesBase::USE_DEFAULT_TIMEOUT
+      mr.as_expected?
+    end
+
+    # Adds a mouse trigger
+    # @param [Symbol] action A mouse action. Can be one of  +:click+, +:right_click+, +:double_click+, +:move+,
+    #   +:down+, +:up+
+    # @param [Applitools::Region] control The control on which the trigger is activated
+    #   (context relative coordinates).
+    # @param [Applitools::Location] cursor The cursor's position relative to the control.
+    def add_mouse_trigger(action, control, cursor)
+      add_mouse_trigger_base action, control, cursor
+    end
+
+    # Adds a keyboard trigger
+    # @param [Applitools::Region] control the control's context-relative region.
+    # @param text The trigger's text.
+    def add_text_trigger(control, text)
+      add_text_trigger_base control, text
+    end
+
+    private
+
+    def vp_size
+      viewport_size
+    end
+
+    def vp_size=(value)
+      Applitools::ArgumentGuard.not_nil 'value', value
+      @viewport_size = Applitools::RectangleSize.for value
+    end
+
+    alias get_viewport_size vp_size
+    alias set_viewport_size vp_size=
+
+    def get_image_from_options(options)
+      if options[:image].nil? && !options[:image].is_a?(Applitools::Screenshot)
+        if !options[:image_path].nil? && !options[:image_path].empty?
+          image = Applitools::Screenshot.new ChunkyPNG::Datastream.from_file(options[:image_path]).to_s
+        elsif options[:image_bytes].nil? && !options[:image_bytes].empty?
+          image = Applitools::Screenshot.new options[:image_bytes]
+        end
+      else
+        image = options[:image]
+      end
+
+      Applitools::ArgumentGuard.not_nil image, 'options[:image] can\'t be nil!'
+
+      image
+    end
+  end
+end