eyes_core 3.14.0 → 3.14.1

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

data/lib/applitools/calabash/eyes_hooks.rb

@@ -0,0 +1,51 @@
+if respond_to?(:Before)
+  Before('@eyes') do |scenario|
+    get_scenario_tags(scenario)
+    before_feature(scenario) if scenario.feature.children.first == scenario.source.last
+  end
+
+  Before('@eyes') do |scenario|
+    Applitools::Calabash::EyesSettings.instance.eyes.add_context(self)
+    step %(eyes test name is "#{@eyes_current_tags[:test_name] || scenario.name}")
+    step %(open eyes)
+  end
+end
+
+if respond_to?(:After)
+  After('@eyes') do |scenario|
+    after_feature(scenario) if scenario.feature.children.last == scenario.source.last
+  end
+
+  After('@eyes') do |_scenario|
+    eyes = Applitools::Calabash::EyesSettings.instance.eyes
+    Applitools::Calabash::EyesSettings.instance.eyes.remove_context if eyes && eyes.open?
+    step %(terminate eyes session)
+  end
+end
+
+def before_feature(scenario)
+  @before_hook_scenario = scenario
+  eyes_settings = Applitools::Calabash::EyesSettings.instance
+
+  step %(eyes API key "#{@eyes_current_tags[:api_key] || ENV['APPLITOOLS_API_KEY']}") unless
+    eyes_settings.applitools_api_key
+
+  step %(eyes application name is "#{@eyes_current_tags[:app_name] || scenario.feature.name}")
+
+  step %(set it up) if eyes_settings.needs_setting_up
+
+  step %(create eyes)
+end
+
+def after_feature(_scenario)
+
+end
+
+def get_scenario_tags(scenario)
+  @eyes_current_tags = {}
+  eyes_tag_name_regexp = /@eyes_(?<tag_name>[a-z,A-Z, \_]+) \"(?<value>.*)\"/
+  scenario.tags.each do |t|
+    match_data = t.name.match eyes_tag_name_regexp
+    @eyes_current_tags[match_data[:tag_name].to_sym] = match_data[:value] if match_data
+  end
+end

data/lib/applitools/calabash/eyes_settings.rb

@@ -0,0 +1,43 @@
+require 'singleton'
+require 'securerandom'
+module Applitools
+  module Calabash
+    class EyesSettings
+      attr_accessor :eyes, :applitools_api_key, :app_name, :test_name, :viewport_size
+      attr_accessor :tmp_dir, :screenshot_dir, :log_dir, :log_file
+      attr_accessor :needs_setting_up
+
+      include Singleton
+
+      def initialize
+        @tmp_dir = 'tmp'
+        @screenshot_dir = 'screenshots'
+        @log_dir = 'logs'
+        @log_file = 'applitools.log'
+        @needs_setting_up = true
+      end
+
+      def options_for_open
+        result = { app_name: app_name, test_name: test_name }
+        return result unless viewport_size
+        result.merge!(viewport_size: viewport_size)
+      end
+
+      def screenshot_prefix
+        File.join(Dir.getwd, tmp_dir, screenshot_dir, '')
+      end
+
+      def log_prefix
+        File.join(Dir.getwd, log_dir)
+      end
+
+      def screenshot_names
+        @names ||= Enumerator.new do |y|
+          loop do
+            y << { prefix: screenshot_prefix, name: "#{SecureRandom.uuid}.png" }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/applitools/calabash/full_page_capture_algorithm.rb

@@ -0,0 +1,24 @@
+Applitools::Calabash.require_dir 'calabash/full_page_capture_algorithm'
+
+module Applitools
+  module Calabash
+    module FullPageCaptureAlgorithm
+      ANDROID_ALGORITHMS = {
+        'android.widget.ScrollView' => Applitools::Calabash::FullPageCaptureAlgorithm::AndroidScrollView
+      }.freeze
+      IOS_ALGORITHMS = {
+        'UITableView' => Applitools::Calabash::FullPageCaptureAlgorithm::IosUITableView
+      }.freeze
+      class << self
+        def get_algorithm_class(env, klass)
+          case env
+          when :ios
+            IOS_ALGORITHMS[klass]
+          when :android
+            ANDROID_ALGORITHMS[klass]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/applitools/calabash/full_page_capture_algorithm/android_scroll_view.rb

@@ -0,0 +1,85 @@
+require_relative 'base'
+module Applitools
+  module Calabash
+    module FullPageCaptureAlgorithm
+      class AndroidScrollView < Base
+        def initialize(*args)
+          super
+          @entire_content = nil
+          @stitched_image = nil
+          @original_position = nil
+        end
+
+        def get_stitched_region(scroll_to_top = true)
+          create_entire_image
+          store_original_position
+          scroll_top if scroll_to_top
+
+          scroll_it! do |scrollable_element|
+            put_it_on_canvas!(
+              screenshot_provider.capture_screenshot.sub_screenshot(
+                eyes_window,
+                Applitools::Calabash::EyesCalabashScreenshot::DRIVER,
+                false,
+                false
+              ).image.image,
+              element.location.offset_negative(scrollable_element.location)
+            )
+          end
+
+          restore_original_position
+
+          Applitools::Calabash::EyesCalabashAndroidScreenshot.new(
+            Applitools::Screenshot.from_image(stitched_image),
+            density: screenshot_provider.density
+          )
+        end
+
+        private
+
+        def scrollable_element
+          child_query = "#{element.element_query} child * index:0"
+          Applitools::Calabash::Utils.get_android_element(context, child_query, 0)
+        end
+
+        def scroll_top
+          logger.info 'Scrolling up...'
+          context.query(element.element_query, scrollTo: [0, 0])
+          logger.info 'Done!'
+        end
+
+        def store_original_position
+          current_scrollable_element = scrollable_element
+          @original_position = Applitools::Location.new(current_scrollable_element.left, current_scrollable_element.top)
+        end
+
+        def restore_original_position
+          return unless @original_position
+          offset = @original_position.offset_negative(scrollable_element.location)
+          context.query(element.element_query, scrollBy: [-offset.x, -offset.y])
+          @original_position = nil
+        end
+
+        def scroll_it!
+          scroll_vertical = true
+          loop do
+            scrollable = scrollable_element if scroll_vertical
+            vertical_offset = element.location.offset_negative(scrollable.location).top
+            scroll_vertical = false if vertical_offset + 1 >= scrollable.height - element.height
+            yield(scrollable) if block_given?
+            context.query(element.element_query, scrollBy: [0, element.height]) if scroll_vertical
+            return unless scroll_vertical
+          end
+        end
+
+        def entire_size
+          entire_content.size
+        end
+
+        def eyes_window
+          @eyes_window ||= Applitools::Region.from_location_size(element.location, element.size)
+        end
+      end
+    end
+  end
+end

data/lib/applitools/calabash/full_page_capture_algorithm/base.rb

@@ -0,0 +1,49 @@
+module Applitools
+  module Calabash
+    module FullPageCaptureAlgorithm
+      class Base
+        extend Applitools::Helpers
+        extend Forwardable
+        def_delegators 'Applitools::EyesLogger', :logger, :log_handler, :log_handler=
+
+        attr_reader :context, :element, :screenshot_provider, :stitched_image, :debug_screenshot_provider
+
+        DEFAULT_SLEEP_INTERVAL = 1
+
+        def initialize(screenshot_provider, element, options = {})
+          Applitools::ArgumentGuard.is_a?(element, 'element', Applitools::Calabash::CalabashElement)
+          @screenshot_provider = screenshot_provider
+          @element = element
+          @context = screenshot_provider.context
+          return unless options[:debug_screenshot_provider]
+          Applitools::ArgumentGuard.is_a?(
+            options[:debug_screenshot_provider],
+            'options[:debug_screenshot_provider]',
+            Applitools::DebugScreenshotProvider
+          )
+          @debug_screenshot_provider = options[:debug_screenshot_provider]
+        end
+
+        private
+
+        def create_entire_image
+          current_entire_size = entire_size
+          @stitched_image = ::ChunkyPNG::Image.new(current_entire_size.width, current_entire_size.height)
+        end
+
+        def entire_content
+          @entire_content ||= scrollable_element
+        end
+
+        abstract_method(:entire_size, true)
+        abstract_method(:scrollable_element, true)
+        abstract_method(:eyes_window, true)
+
+        def put_it_on_canvas!(image, offset)
+          debug_screenshot_provider.save(image, "#{offset.x} x #{offset.y}") if debug_screenshot_provider
+          stitched_image.replace!(image, offset.x, offset.y)
+        end
+      end
+    end
+  end
+end

data/lib/applitools/calabash/full_page_capture_algorithm/ios_ui_table_view.rb

@@ -0,0 +1,148 @@
+require_relative 'base'
+
+module Applitools
+  module Calabash
+    module FullPageCaptureAlgorithm
+      class IosUITableView < Base
+        NSSIZE = /^.*: {(?<width>\d+), (?<height>\d+)}$/
+        NEXT_REQUEST_DELAY = 0.5
+        CROP_SHADOW_BOUNDS = 5
+
+        def initialize(*args)
+          super
+          @entire_content = nil
+          @stitched_image = nil
+          @original_position = nil
+          @entire_size = nil
+          @eyes_window = nil
+        end
+
+        def get_stitched_region(scroll_to_top = true)
+          create_entire_image
+          store_original_position
+          scroll_left_top if scroll_to_top
+
+          scroll_it! do |position, cut_vertical, cut_horizontal|
+            current_region = cutted_eyes_window(cut_vertical ? :top : :none)
+            current_region = cutted_eyes_window(cut_horizontal ? :left : :none, current_region)
+
+            current_position = updated_position(cut_vertical ? :top : :none, position.dup)
+            current_position = updated_position(cut_horizontal ? :left : :none, current_position)
+
+            put_it_on_canvas!(
+              screenshot_provider.capture_screenshot.sub_screenshot(
+                current_region,
+                Applitools::Calabash::EyesCalabashScreenshot::DRIVER,
+                false,
+                false
+              ).image.image,
+              current_position.scale_it!(screenshot_provider.density)
+            )
+          end
+
+          Applitools::Calabash::EyesCalabashIosScreenshot.new(
+            Applitools::Screenshot.from_image(stitched_image),
+            scale_factor: screenshot_provider.density
+          )
+        end
+
+        def cutted_eyes_window(side, region = eyes_window)
+          case side
+          when :top
+            Applitools::Region.new(
+              region.left,
+              region.top + CROP_SHADOW_BOUNDS,
+              region.width,
+              region.height - CROP_SHADOW_BOUNDS
+            )
+          when :left
+            Applitools::Region.new(
+              region.left + CROP_SHADOW_BOUNDS,
+              region.top,
+              region.width - CROP_SHADOW_BOUNDS,
+              region.height
+            )
+          else
+            region.dup
+          end
+        end
+
+        def updated_position(side, position)
+          case side
+          when :top
+            position.offset Applitools::Location.new(0, CROP_SHADOW_BOUNDS)
+          when :left
+            position.offset Applitools::Location.new(CROP_SHADOW_BOUNDS, 0)
+          else
+            position
+          end
+        end
+
+        def scrollable_element
+          Applitools::Calabash::Utils.get_ios_element(context, element.element_query, 0)
+        end
+
+        def entire_size
+          @entire_size ||= query_entire_size
+        end
+
+        def query_entire_size
+          result = NSSIZE.match(Applitools::Calabash::Utils.request_element(context, element, :contentSize).first)
+          Applitools::RectangleSize.new(
+            result[:width].to_i, result[:height].to_i
+          ).scale_it!(screenshot_provider.density)
+        end
+
+        def query_current_position
+          result = Applitools::Calabash::Utils.request_element(context, element, :contentOffset).first
+          Applitools::Location.new(
+            result['X'].to_i,
+            result['Y'].to_i
+          )
+        end
+
+        def store_original_position
+          current_scrollable_element = Applitools::Calabash::Utils.request_element(context, element, :contentSize).first
+          @original_position = Applitools::Location.new(
+            current_scrollable_element['X'],
+            current_scrollable_element['Y']
+          )
+        end
+
+        def restore_original_position; end
+
+        def scroll_it!
+          scroll_in_one_dimension(:down) do |pos, is_first_vertical|
+            scroll_in_one_dimension(:right, pos) do |position, is_first_horizontal|
+              yield(position, !is_first_vertical, !is_first_horizontal) if block_given?
+            end
+          end
+        end
+
+        def scroll_in_one_dimension(direction, position = nil)
+          previous_position = position || query_current_position
+          is_first = true
+          loop do
+            yield(previous_position, is_first) if block_given?
+            is_first = false if is_first
+            context.scroll(element.element_query, direction)
+            sleep NEXT_REQUEST_DELAY
+            new_position = query_current_position
+            return if previous_position == new_position
+            previous_position = new_position
+          end
+        end
+
+        def scroll_left_top
+          scroll_in_one_dimension(:up) do |position, _is_first, _direction|
+            scroll_in_one_dimension(:left, position)
+          end
+        end
+
+        def eyes_window
+          @eyes_window ||= Applitools::Region.from_location_size(element.location, element.size)
+        end
+      end
+    end
+  end
+end