eyes_calabash 3.14.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: a25fa4c2ac323fc0ab8684110da95963f9daee08
+  data.tar.gz: c6187489be17efc8972bccb1f4324b3f6351fad0
+SHA512:
+  metadata.gz: 9aa7045cce478a18199592bb2fb028c84f7c11a4cbf9c8bc9fe18c6e03de8ad069d5ae48d7fb985fd59df44922ea48ed88fa1d0c5da8fabe51e68116666e759e
+  data.tar.gz: e129f92a3324348e1da7c0d79beae7527b193631936ff9b930a55d94fe07512d8d55bca3696a4ec985630a66f572528fd4cb0134fbd97c5d51dbcc42cad50924

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

data/lib/applitools/calabash/eyes_calabash_screenshot.rb

@@ -0,0 +1,78 @@
+module Applitools
+  module Calabash
+    class EyesCalabashScreenshot < Applitools::EyesScreenshot
+      SCREENSHOT_AS_IS = Applitools::EyesScreenshot::COORDINATE_TYPES[:screenshot_as_is].freeze
+      CONTEXT_RELATIVE = Applitools::EyesScreenshot::COORDINATE_TYPES[:context_relative].freeze
+      DRIVER = 'DRIVER'.freeze
+
+      attr_reader :scale_factor
+
+      def initialize(image, options = {})
+        super image
+        @scale_factor = options[:scale_factor] || 1
+        # return if (location = options[:location]).nil?
+        # Applitools::ArgumentGuard.is_a? location, 'options[:location]', Applitools::Location
+        # @bounds = Applitools::Region.new location.x, location.y, image.width, image.height
+      end
+
+      def sub_screenshot(region, coordinates_type, throw_if_clipped = false, force_nil_if_clipped = false)
+        Applitools::ArgumentGuard.not_nil region, 'region'
+        Applitools::ArgumentGuard.not_nil coordinates_type, 'coordinates_type'
+
+        sub_screen_region = intersected_region region, coordinates_type, SCREENSHOT_AS_IS
+
+        if sub_screen_region.empty? || (throw_if_clipped && !region.size_equals?(sub_screen_region))
+          return nil if force_nil_if_clipped
+          raise Applitools::OutOfBoundsException, "Region #{sub_screen_region} (#{coordinates_type}) is out of " \
+          " screenshot bounds #{bounds}"
+        end
+
+        sub_screenshot_image = Applitools::Screenshot.from_any_image(
+          image.crop(
+            sub_screen_region.left, sub_screen_region.top, sub_screen_region.width, sub_screen_region.height
+          ).to_datastream.to_blob
+        )
+
+        self.class.new sub_screenshot_image, scale_factor: scale_factor
+      end
+
+      def location_in_screenshot(_location, _coordinates_type)
+        raise(
+          Applitools::EyesError,
+          'Call to :convert_location is prohibited for Applitools::Calabash::EyesCalabashScreenshot'
+        )
+      end
+
+      def intersected_region(region, from, to = CONTEXT_RELATIVE)
+        Applitools::ArgumentGuard.not_nil region, 'region'
+        Applitools::ArgumentGuard.not_nil from, 'coordinates Type (from)'
+        return Applitools::Region.new(0, 0, 0, 0) if region.empty?
+        intersected_region = convert_region_location region, from, to
+        intersected_region.intersect bounds
+        intersected_region
+      end
+
+      def convert_location(_location, _from, _to)
+        raise(
+          Applitools::EyesError,
+          'Call to :convert_location is prohibited for Applitools::Calabash::EyesCalabashScreenshot'
+        )
+      end
+
+      abstract_method :convert_region_location, false
+
+      def scale_it!
+        width = (image.width.to_f / scale_factor).to_i
+        height = (image.height.to_f / scale_factor).to_i
+        image.resample_bicubic!(width, height)
+        self
+      end
+
+      private
+
+      def bounds
+        @bounds ||= Applitools::Region.new(0, 0, image.width, image.height)
+      end
+    end
+  end
+end