eyes_core 3.0.4

data/lib/applitools/core/eyes_screenshot.rb

@@ -0,0 +1,35 @@
+module Applitools
+  class EyesScreenshot
+    extend Forwardable
+    extend Applitools::Helpers
+
+    def_delegators 'Applitools::EyesLogger', :logger, :log_handler, :log_handler=
+    attr_accessor :image
+
+    COORDINATE_TYPES = {
+      screenshot_as_is: 'SCREENSHOT_AS_IS',
+      context_relative: 'CONTEXT_RELATIVE'
+    }.freeze
+
+    def initialize(screenshot)
+      Applitools::ArgumentGuard.is_a? screenshot, 'screenshot', Applitools::Screenshot
+      self.image = screenshot
+    end
+
+    abstract_method :sub_screenshot, false
+    abstract_method :convert_location, false
+    abstract_method :location_in_screenshot, false
+    abstract_method :intersected_region, false
+
+    def convert_region_location(region, from, to)
+      Applitools::ArgumentGuard.not_nil region, 'region'
+      Applitools::ArgumentGuard.is_a? region, 'region', Applitools::Region
+      return Region.new(0, 0, 0, 0) if region.empty?
+      Applitools::ArgumentGuard.not_nil from, 'from'
+      Applitools::ArgumentGuard.not_nil to, 'to'
+
+      updated_location = convert_location(region.location, from, to)
+      Region.new updated_location.x, updated_location.y, region.width, region.height
+    end
+  end
+end

data/lib/applitools/core/fixed_cut_provider.rb

@@ -0,0 +1,61 @@
+module Applitools
+  # Provides 'cut' method which is used to cut screen shots
+  class FixedCutProvider
+    # Creates a FixedCutProvider instance
+    # @param [Applitools::Region] crop_region Outside space of the region will be cropped
+    # @param [Integer] header A top field to crop
+    # @param [Integer] left A left field to crop
+    # @param [Integer] right A right field to crop
+    # @param [Integer] footer A bottom field to crop
+    # @example Creates cut provider by a Region
+    #   Applitools::FixedCutProvider.new Applitools::Region.new(20,20, 300, 300)
+    # @example Creates cut provider by a set of fields
+    #   Applitools::FixedCutProvider.new 20, 20, 300, 300
+    def initialize(*args)
+      self.region = nil
+      self.left = 0
+      self.header = 0
+      self.right = 0
+      self.footer = 0
+      case args.length
+      when 1
+        initialize_by_rectangle(args[0])
+      when 4
+        initialize_by_fields(*args)
+      end
+    end
+
+    def cut(image)
+      Applitools::Utils::ImageUtils.cut! image, crop_region(image)
+    end
+
+    private
+
+    attr_accessor :header, :footer, :left, :right, :region
+
+    def initialize_by_rectangle(region)
+      unless region.is_a? Applitools::Region
+        raise Applitools::EyesIllegalArgument.new 'Applitools::Region expected as argument ' /
+          " (#{region.class} is passed)."
+      end
+      self.region = region
+    end
+
+    def initialize_by_fields(header, footer, left, right)
+      self.header = header
+      self.footer = footer
+      self.left = left
+      self.right = right
+    end
+
+    def crop_region(image)
+      current_height = image.height
+      current_width = image.width
+      if region.nil?
+        Applitools::Region.new(left, header, current_width - left - right, current_height - header - footer)
+      else
+        region.dup
+      end
+    end
+  end
+end

data/lib/applitools/core/fixed_scale_provider.rb

@@ -0,0 +1,14 @@
+module Applitools
+  # @!visibility private
+  class FixedScaleProvider
+    attr_reader :scale_ratio, :scale_method
+    def initialize(scale_ratio, method = :speed)
+      @scale_ratio = scale_ratio
+      @scale_method = method
+    end
+
+    def scale_image(image)
+      Applitools::Utils::ImageUtils.scale!(image, scale_method, scale_ratio)
+    end
+  end
+end

data/lib/applitools/core/helpers.rb

@@ -0,0 +1,18 @@
+module Applitools
+  module Helpers
+    def abstract_attr_accessor(*names)
+      names.each do |method_name|
+        instance_variable_set "@#{method_name}", nil
+        abstract_method method_name, true
+        abstract_method "#{method_name}=", true
+      end
+    end
+
+    def abstract_method(method_name, is_private = true)
+      define_method method_name do |*_args|
+        raise Applitools::AbstractMethodCalled.new method_name, self
+      end
+      private method_name if is_private
+    end
+  end
+end

data/lib/applitools/core/location.rb

@@ -0,0 +1,84 @@
+require 'applitools/core/region'
+module Applitools
+  class Location
+    class << self
+      def from_any_attribute(*args)
+        if args.size == 2
+          new args[0], args[1]
+        elsif args.size == 1
+          value = args.shift
+          from_hash(value) if value.is_a? Hash
+          from_array(value) if value.is_a? Array
+          from_string(value) if value.is_a? String
+          from_struct(value) if value.respond_to?(:x) & value.respond_to?(:y)
+        end
+      end
+
+      alias for from_any_attribute
+
+      def from_hash(value)
+        new value[:x], value[:y]
+      end
+
+      def from_array(value)
+        new value.shift, value.shift
+      end
+
+      def from_string(value)
+        x, y = value.split(/x/)
+        new x, y
+      end
+
+      def from_struct(value)
+        new value.x, value.y
+      end
+    end
+
+    attr_reader :x, :y
+
+    alias left x
+    alias top y
+
+    def initialize(x, y)
+      @x = x
+      @y = y
+    end
+
+    TOP_LEFT = Location.new(0, 0)
+
+    def to_s
+      "#{x} x #{y}"
+    end
+
+    def ==(other)
+      return super.==(other) unless other.is_a?(Location)
+      @x == other.x && @y == other.y
+    end
+
+    alias eql? ==
+
+    def hash
+      @x.hash & @y.hash
+    end
+
+    def to_hash(options = {})
+      options[:region] ? { left: left, top: top } : { x: x, y: y }
+    end
+
+    def values
+      [x, y]
+    end
+
+    def offset(other)
+      @x += other.x
+      @y += other.y
+      self
+    end
+
+    def offset_negative(other)
+      @x -= other.x
+      @y -= other.y
+      self
+    end
+  end
+end

data/lib/applitools/core/match_result.rb

@@ -0,0 +1,16 @@
+module Applitools
+  class MatchResult
+    attr_reader :response_hash
+    attr_accessor :screenshot
+
+    def initialize(response_hash)
+      Applitools::ArgumentGuard.hash response_hash, 'response hash', ['asExpected']
+      @response_hash = response_hash
+    end
+
+    def as_expected?
+      return response_hash['asExpected'] if [TrueClass, FalseClass].include? response_hash['asExpected'].class
+      false
+    end
+  end
+end

data/lib/applitools/core/match_results.rb

@@ -0,0 +1,9 @@
+module Applitools
+  class MatchResults
+    attr_accessor :screenshot, :window_id, :as_expected
+
+    def as_expected?
+      as_expected
+    end
+  end
+end

data/lib/applitools/core/match_window_data.rb

@@ -0,0 +1,34 @@
+module Applitools
+  class MatchWindowData
+    attr_accessor :app_output, :user_inputs, :tag, :options, :ignore_mismatch
+
+    def initialize(user_inputs, app_output, tag, ignore_mismatch, options = {})
+      self.user_inputs = user_inputs
+      self.app_output = app_output
+      self.tag = tag
+      self.ignore_mismatch = ignore_mismatch
+      self.options = options
+    end
+
+    def screenshot
+      app_output.screenshot.image.to_blob
+    end
+
+    alias appOutput app_output
+    alias userInputs user_inputs
+    alias ignoreMismatch ignore_mismatch
+
+    def to_hash
+      ary = [:userInputs, :appOutput, :tag, :ignoreMismatch].map do |field|
+        result = send(field)
+        result = result.to_hash if result.respond_to? :to_hash
+        [field, result] if [String, Symbol, Hash, Array, FalseClass, TrueClass].include? result.class
+      end
+      Hash[ary]
+    end
+
+    def to_s
+      to_hash
+    end
+  end
+end

data/lib/applitools/core/match_window_task.rb

@@ -0,0 +1,86 @@
+require 'base64'
+module Applitools
+  class MatchWindowTask
+    MATCH_INTERVAL = 0.5
+    AppOuptut = Struct.new(:title, :screenshot64)
+
+    attr_reader :logger, :running_session, :default_retry_timeout, :app_output_provider
+
+    def initialize(logger, running_session, retry_timeout, app_output_provider)
+      @logger = logger
+      @running_session = running_session
+      # @driver = driver
+      @default_retry_timeout = retry_timeout
+      @app_output_provider = app_output_provider
+
+      ArgumentGuard.not_nil logger, 'logger'
+      ArgumentGuard.not_nil running_session, 'running_session'
+      ArgumentGuard.not_nil app_output_provider, 'app_output_provider'
+      ArgumentGuard.greater_than_or_equal_to_zero retry_timeout, 'retry_timeout'
+
+      return if app_output_provider.respond_to? :app_output
+      raise Applitools::EyesIllegalArgument.new 'MatchWindowTask.new(): app_output_provider doesn\'t' /
+        ' respond to :app_output'
+    end
+
+    def match_window(options = {})
+      user_inputs = options[:user_inputs]
+      last_screenshot = options[:last_screenshot]
+      region_provider = options[:region_provider]
+      tag = options[:tag]
+      should_match_window_run_once_on_timeout = options[:should_match_window_run_once_on_timeout]
+      ignore_mismatch = options[:ignore_mismatch]
+      retry_timeout = options[:retry_timeout]
+
+      retry_timeout = default_retry_timeout if retry_timeout < 0
+
+      logger.info "retry_timeout = #{retry_timeout}"
+      elapsed_time_start = Time.now
+
+      if retry_timeout.zero? || should_match_window_run_once_on_timeout
+        sleep retry_timeout if should_match_window_run_once_on_timeout
+        app_output = app_output_provider.app_output region_provider, last_screenshot
+        match_result = perform_match user_inputs: user_inputs, app_output: app_output, tag: tag,
+          ignore_mismatch: ignore_mismatch
+      else
+        app_output = app_output_provider.app_output region_provider, last_screenshot
+        start = Time.now
+        match_result = perform_match user_inputs: user_inputs, app_output: app_output, tag: tag, ignore_mismatch: true
+        retry_time = Time.now - start
+
+        while retry_time < retry_timeout && !match_result.as_expected?
+          sleep MATCH_INTERVAL
+          app_output = app_output_provider.app_output region_provider, last_screenshot
+          match_result = perform_match user_inputs: user_inputs, app_output: app_output, tag: tag, ignore_mismatch: true
+          retry_time = Time.now - start
+        end
+
+        unless match_result.as_expected?
+          app_output = app_output_provider.app_output region_provider, last_screenshot
+          match_result = perform_match user_inputs: user_inputs, app_output: app_output, tag: tag,
+            ignore_mismatch: ignore_mismatch
+        end
+      end
+
+      elapsed_time = (Time.now - elapsed_time_start) / 1000
+
+      logger.info "Completed in #{format('%.2f', elapsed_time)} seconds"
+
+      match_result.screenshot = app_output.screenshot
+      match_result
+    end
+
+    private
+
+    def perform_match(options = {})
+      user_inputs = options[:user_inputs]
+      app_output = options[:app_output]
+      tag = options[:tag]
+      ignore_mismatch = options[:ignore_mismatch]
+      data = Applitools::MatchWindowData.new user_inputs, app_output, tag, ignore_mismatch,
+        tag: tag, user_inputs: user_inputs, ignore_mismatch: ignore_mismatch, ignore_match: false,
+        force_mistmatch: false, force_match: false
+      Applitools::Connectivity::ServerConnector.match_window running_session, data
+    end
+  end
+end

data/lib/applitools/core/mouse_trigger.rb

@@ -0,0 +1,39 @@
+require 'applitools/core/trigger'
+module Applitools
+  class MouseTrigger < Trigger
+    TRIGGER_TYPE = :Mouse
+
+    ##
+    # A hash contains available mouse actions: +:click+, +:right_click+, +:double_click+, +:move+, +:down+, +:up+
+
+    MOUSE_ACTION = {
+      click: 'Click',
+      right_click: 'RightClick',
+      double_click: 'DoubleClick',
+      move: 'Move',
+      down: 'Down',
+      up: 'Up'
+    }.freeze
+
+    attr_reader :mouse_action, :control, :location
+
+    def initialize(mouse_action, control, location)
+      @mouse_action = mouse_action
+      @control = control
+      @location = location
+    end
+
+    def to_hash
+      {
+        triggerType: trigger_type,
+        mouseAction: MOUSE_ACTION[mouse_action],
+        control: control.to_hash,
+        location: location.to_hash
+      }
+    end
+
+    def to_s
+      "#{mouse_action} [#{control}] #{location.x}, #{location.y}"
+    end
+  end
+end

data/lib/applitools/core/rectangle_size.rb

@@ -0,0 +1,46 @@
+module Applitools
+  RectangleSize = Struct.new(:width, :height) do
+    class << self
+      def from_any_argument(value)
+        return from_string(value) if value.is_a? String
+        return from_hash(value) if value.is_a? Hash
+        return from_struct(value) if value.respond_to?(:width) & value.respond_to?(:height)
+        return value if value.is_a? self
+        nil
+      end
+
+      alias_method :for, :from_any_argument
+
+      def from_string(value)
+        width, height = value.split(/x/)
+        new width, height
+      end
+
+      def from_hash(value)
+        new value[:width], value[:height]
+      end
+
+      def from_struct(value)
+        new value.width, value.height
+      end
+    end
+
+    def to_s
+      "#{width}x#{height}"
+    end
+
+    def -(other)
+      self.width = width - other.width
+      self.height = height - other.height
+      self
+    end
+
+    def +(other)
+      self.width = width + other.width
+      self.height = height + other.height
+      self
+    end
+
+    alias_method :to_hash, :to_h
+  end
+end