eyes_core 3.14.0 → 3.14.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 65a63d6b6368ae920b07ea4b8af795628f19fb4f
-  data.tar.gz: a0336f5ed5f9dba8b367cd36bdec75cd5650db99
+  metadata.gz: 345d3a061eb0bf58d16612a3d980272c7403f6c1
+  data.tar.gz: 9e1616f8250a11e3ea2f0e01c8e03f97a9b5616f
 SHA512:
-  metadata.gz: 5243869f82ef38247c7c7422ff4062063e53c99ebca81bf45630d46c6752c6e77257817196c3929ee25ba47c8f560cfd44a194b31c041fa21dd850afd5dcf21c
-  data.tar.gz: 6b62b19d557bb951082b729f74028e87f7dc1becbf6aa1d016764524b092788a594c7a20b20634409df04d7f1269b08197a87b2976b8839023efc0bcd4221e64
+  metadata.gz: 4c89e9f459b886ae3d5e4925995b87284fd6eca7856da6732d8769533625674400500a19f38f1bbd03b7dad5b89341747cbeb9f2504088ec522dfaf144b80605
+  data.tar.gz: 0fdb85a76f80a5afd0809fc66356bb07e666ebb132b59f4f0464bcc4ffd641a64aee174b872b600074432d7491f1f02e1d27adbe4b44f60d402ff5e857fb7a50

data/lib/applitools/calabash/calabash_element.rb

@@ -0,0 +1,62 @@
+module Applitools
+  module Calabash
+    class CalabashElement
+      extend Forwardable
+      attr_reader :original_element, :element_query
+      def_delegators :@original_element, :[], :keys, :values
+
+      def initialize(element, element_query)
+        raise Applitools::EyesIllegalArgument, "Invalid element passed! (#{element})" unless valid_element?(element)
+        @original_element = element
+        @element_query = element_query
+      end
+
+      def left
+        self['rect']['x']
+      end
+
+      alias x left
+
+      def top
+        self['rect']['y']
+      end
+
+      alias y top
+
+      def width
+        self['rect']['width']
+      end
+
+      def height
+        self['rect']['height']
+      end
+
+      def location
+        Applitools::Location.from_struct(self)
+      end
+
+      def size
+        Applitools::RectangleSize.from_struct(self)
+      end
+
+      def region
+        Applitools::Region.from_location_size(location, size)
+      end
+
+      def to_s
+        @original_element
+      end
+
+      private
+
+      def valid_element?(element)
+        result = true
+        result &&= element.is_a?(Hash)
+        result &&= element.key?('rect')
+        result &&= (rect = element['rect']).is_a?(Hash)
+        result &&= (%w(height width y x center_x center_y) - rect.keys).empty?
+        result
+      end
+    end
+  end
+end

data/lib/applitools/calabash/calabash_screenshot_provider.rb

@@ -0,0 +1,81 @@
+module Applitools
+  module Calabash
+    class CalabashScreenshotProvider
+      WAIT_BEFORE_SCREENSHOT = 1
+      attr_reader :density, :context, :debug_screenshot_provider
+
+      def initialize(_options = {})
+        @density = 1
+      end
+
+      def with_density(value)
+        @density = value
+        self
+      end
+
+      def using_context(value)
+        @context = value
+        self
+      end
+
+      def with_debug_screenshot_provider(value)
+        Applitools::ArgumentGuard.is_a?(
+          value,
+          'debug_screenshot_provider',
+          Applitools::DebugScreenshotProvider
+        )
+        @debug_screenshot_provider = value
+        self
+      end
+
+      private
+
+      def save_debug_screenshot(screenshot, suffix)
+        suffix = suffix.join('_') if suffix.respond_to? :join
+        debug_screenshot_provider.save(screenshot, suffix || '') if debug_screenshot_provider
+      end
+    end
+
+    class AndroidScreenshotProvider < CalabashScreenshotProvider
+      include Singleton
+
+      def capture_screenshot(options = {})
+        sleep WAIT_BEFORE_SCREENSHOT
+        result = nil
+        Applitools::Calabash::Utils.using_screenshot(context) do |screenshot_path|
+          screenshot = ::ChunkyPNG::Image.from_file(screenshot_path)
+          save_debug_screenshot(screenshot, ['original', options[:debug_suffix]])
+          viewport_size = Applitools::Calabash::EyesSettings.instance.viewport_size
+          screenshot.crop!(0, 0, viewport_size[:width], viewport_size[:height])
+          save_debug_screenshot(screenshot, ['cropped', options[:debug_suffix]])
+          result = Applitools::Calabash::EyesCalabashAndroidScreenshot.new(
+            Applitools::Screenshot.from_image(
+              screenshot
+            ),
+            density: density
+          )
+        end
+        result
+      end
+    end
+
+    class IosScreenshotProvider < CalabashScreenshotProvider
+      include Singleton
+      def capture_screenshot(options = {})
+        sleep WAIT_BEFORE_SCREENSHOT
+        result = nil
+        Applitools::Calabash::Utils.using_screenshot(context) do |screenshot_path|
+          screenshot = ::ChunkyPNG::Image.from_file(screenshot_path)
+          save_debug_screenshot(screenshot, options[:debug_suffix])
+          result = Applitools::Calabash::EyesCalabashIosScreenshot.new(
+            Applitools::Screenshot.from_image(
+              screenshot
+            ),
+            scale_factor: density
+          )
+        end
+        result
+      end
+    end
+  end
+end

data/lib/applitools/calabash/environment_detector.rb

@@ -0,0 +1,23 @@
+module Applitools
+  module Calabash
+    module EnvironmentDetector
+      extend self
+
+      def android?
+        return true if defined?(::Calabash::Android) == 'constant'
+        false
+      end
+
+      def ios?
+        return true if defined?(::Calabash::Cucumber) == 'constant'
+        false
+      end
+
+      def current_environment
+        return :android if android?
+        return :ios if ios?
+        raise Applitools::EyesError, 'No calabash environment found!'
+      end
+    end
+  end
+end

data/lib/applitools/calabash/eyes.rb

@@ -0,0 +1,182 @@
+module Applitools
+  module Calabash
+    class Eyes < Applitools::EyesBase
+      attr_accessor :device_pixel_ratio, :full_page_capture_algorithm, :base_agent_id, :title,
+        :debug_screenshot, :debug_screenshot_provider, :tag_for_debug
+      attr_reader :context
+
+      def initialize(server_url = Applitools::Connectivity::ServerConnector::DEFAULT_SERVER_URL)
+        super
+        self.base_agent_id = "eyes.calabash.ruby/#{Applitools::VERSION}".freeze
+        self.debug_screenshot = true
+        self.debug_screenshot_provider = Applitools::DebugScreenshotProvider.new
+                                                                            .tag_access { tag_for_debug }
+                                                                            .debug_flag_access { debug_screenshot }
+      end
+
+      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
+
+      def check(name, target)
+        self.tag_for_debug = get_tag_for_debug(name)
+        check_it(name, target, Applitools::MatchWindowData.new)
+      end
+
+      def inferred_environment
+        return @inferred_environment unless @inferred_environment.nil?
+        return unless device_pixel_ratio
+        "device pixel ratio: #{device_pixel_ratio}"
+      end
+
+      def add_context(value)
+        @context = value
+      end
+
+      def remove_context
+        @context = nil
+      end
+
+      def capture_screenshot
+        return screenshot_provider.capture_screenshot(debug_suffix: tag_for_debug) unless full_page_capture_algorithm
+        full_page_capture_algorithm.get_stitched_region
+      end
+
+      def screenshot_provider
+        env = Applitools::Calabash::EnvironmentDetector.current_environment
+        case env
+        when :android
+          Applitools::Calabash::AndroidScreenshotProvider.instance.with_density(device_pixel_ratio)
+                                                         .using_context(context)
+                                                         .with_debug_screenshot_provider(debug_screenshot_provider)
+        when :ios
+          Applitools::Calabash::IosScreenshotProvider.instance.with_density(device_pixel_ratio)
+                                                     .using_context(context)
+                                                     .with_debug_screenshot_provider(debug_screenshot_provider)
+        end
+      end
+
+      def check_it(name, target, match_window_data)
+        Applitools::ArgumentGuard.not_nil(name, 'name')
+
+        logger.info 'Full element requested' if target.options[:stitch_content]
+
+        self.full_page_capture_algorithm = target.options[:stitch_content] &&
+          get_full_page_capture_algorithm(target.region_to_check)
+
+        region_provider = if full_page_capture_algorithm
+                            entire_screenshot_region
+                          else
+                            get_region_provider(target)
+                          end
+
+        match_window_data.tag = name
+        update_default_settings(match_window_data)
+        match_window_data.read_target(target, nil)
+
+        self.viewport_size = Applitools::Calabash::EyesSettings.instance.viewport_size if viewport_size.nil?
+
+        if match_window_data.is_a? Applitools::MatchSingleCheckData
+          return check_single_base(
+            region_provider,
+            target.options[:timeout] || Applitools::EyesBase::USE_DEFAULT_TIMEOUT,
+            match_window_data
+          )
+        end
+
+        check_window_base(
+          region_provider,
+          target.options[:timeout] || Applitools::EyesBase::USE_DEFAULT_TIMEOUT,
+          match_window_data
+        )
+      end
+
+      def get_region_provider(target)
+        if (region_to_check = target.region_to_check).nil?
+          entire_screenshot_region
+        else
+          region_for_element(region_to_check)
+        end
+      end
+
+      def get_app_output_with_screenshot(*args)
+        # super do |screenshot|
+        #   screenshot.scale_it!
+        # end
+        super(*args, &:scale_it!)
+      end
+
+      def entire_screenshot_region
+        Object.new.tap do |prov|
+          prov.instance_eval do
+            define_singleton_method :region do
+              Applitools::Region::EMPTY
+            end
+
+            define_singleton_method :coordinate_type do
+              nil
+            end
+          end
+        end
+      end
+
+      def region_for_element(region_to_check)
+        Object.new.tap do |prov|
+          prov.instance_eval do
+            define_singleton_method :region do
+              case region_to_check
+              when Applitools::Calabash::CalabashElement
+                region_to_check.region
+              when Applitools::Region
+                region_to_check
+              else
+                raise Applitools::EyesError, "Incompatible region type: #{region_to_check.class}"
+              end
+              # region_to_check.respond_to?(:region) ? region_to_check.region : region_to_check
+            end
+            define_singleton_method :coordinate_type do
+              Applitools::Calabash::EyesCalabashScreenshot::DRIVER
+            end
+          end
+        end
+      end
+
+      def vp_size
+        viewport_size
+      end
+
+      def vp_size=(value, skip_check_if_open = false)
+        unless skip_check_if_open || open?
+          raise Applitools::EyesNotOpenException.new 'set_viewport_size: Eyes not open!'
+        end
+        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_full_page_capture_algorithm(element)
+        logger.info "Trying to get full page capture algorithm for element #{element}..."
+        environment = Applitools::Calabash::EnvironmentDetector.current_environment
+        element_class = Applitools::Calabash::Utils.send("grub_#{environment}_class_name", context, element).first
+        logger.info "Trying to get FullPageCaptureAlgorithm for #{element_class}..."
+        algo = Applitools::Calabash::FullPageCaptureAlgorithm.get_algorithm_class(environment, element_class)
+        if algo
+          logger.info "Using #{algo}"
+          algo = algo.new(screenshot_provider, element, debug_screenshot_provider: debug_screenshot_provider)
+        else
+          logger.info "FullPageCaptureAlgorithm for #{element_class} not found. Continue with :check_region instead"
+        end
+        algo
+      end
+
+      def get_tag_for_debug(name)
+        return "#{current_app_name} #{test_name}" if name.empty?
+        "#{current_app_name} #{test_name} - #{name}"
+      end
+    end
+  end
+end

data/lib/applitools/calabash/eyes_calabash_android_screenshot.rb

@@ -0,0 +1,56 @@
+require_relative 'eyes_calabash_screenshot'
+module Applitools
+  module Calabash
+    class EyesCalabashAndroidScreenshot < ::Applitools::Calabash::EyesCalabashScreenshot
+      ANDROID_DENSITY = {
+        120 => 0.75,
+        160 => 1,
+        213 => 1.33,
+        240 => 1.5,
+        320 => 2,
+        480 => 3
+      }.freeze
+
+      def initialize(*args)
+        options = if args.last.is_a? Hash
+                    args.pop
+                  else
+                    {}
+                  end
+        super(*args)
+        @scale_factor = nil
+        self.density = options[:density] if options[:density]
+        @scale_factor ||= options[:scale_factor]
+        @scale_factor = 1 unless @scale_factor
+      end
+
+      def convert_region_location(region, from, to)
+        case from
+        when DRIVER
+          case to
+          when SCREENSHOT_AS_IS
+            region
+          else
+            raise Applitools::EyesError, "from: #{from}, to: #{to}"
+          end
+        when CONTEXT_RELATIVE
+          case to
+          when SCREENSHOT_AS_IS
+            region.scale_it!(1.to_f / scale_factor) # !!!!!!
+            region
+          else
+            raise Applitools::EyesError, "from: #{from}, to: #{to}"
+          end
+        else
+          raise Applitools::EyesError, "from: #{from}, to: #{to}"
+        end
+        region
+      end
+
+      def density=(value)
+        raise Applitools::EyesIllegalArgument, "Unknown density = #{value}" unless ANDROID_DENSITY[value.to_i]
+        @scale_factor = ANDROID_DENSITY[value.to_i]
+      end
+    end
+  end
+end

data/lib/applitools/calabash/eyes_calabash_ios_screenshot.rb

@@ -0,0 +1,28 @@
+require_relative 'eyes_calabash_screenshot'
+module Applitools
+  module Calabash
+    class EyesCalabashIosScreenshot < Applitools::Calabash::EyesCalabashScreenshot
+      def convert_region_location(region, from, to)
+        case from
+        when DRIVER
+          case to
+          when SCREENSHOT_AS_IS
+            region.scale_it!(scale_factor)
+          else
+            raise Applitools::EyesError, "from: #{from}, to: #{to}"
+          end
+        when CONTEXT_RELATIVE
+          case to
+          when SCREENSHOT_AS_IS
+            region
+          else
+            raise Applitools::EyesError, "from: #{from}, to: #{to}"
+          end
+        else
+          raise Applitools::EyesError, "from: #{from}, to: #{to}"
+        end
+        region
+      end
+    end
+  end
+end