eyes_calabash 3.14.1

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

data/lib/applitools/calabash/os_versions.rb

@@ -0,0 +1,23 @@
+module Applitools
+  module Calabash
+    module OsVersions
+      module Android
+        extend self
+        API_TO_NAME = {
+          4 => 'Android 1',
+          10 => 'Android 2',
+          13 => 'Android 3',
+          20 => 'Android 4',
+          22 => 'Android 5',
+          23 => 'Android 6',
+          25 => 'Android 7',
+          27 => 'Android 8'
+        }.freeze
+
+        def os_version(api_level)
+          API_TO_NAME[API_TO_NAME.keys.select { |v| api_level.to_i >= v }.last] || 'Android'
+        end
+      end
+    end
+  end
+end

data/lib/applitools/calabash/rspec_matchers.rb

@@ -0,0 +1,22 @@
+require 'rspec/expectations'
+
+RSpec::Matchers.define :match_baseline do |expected|
+  match do |actual|
+    result = Applitools::Calabash::EyesSettings.instance.eyes.check(expected, actual)
+    result.as_expected?
+  end
+
+  failure_message do |_actual|
+    "expected #{expected} to match a baseline"
+  end
+end
+
+RSpec::Matchers.define :be_success do
+  match do |actual|
+    actual.as_expected? == true
+  end
+
+  failure_message do |actual|
+    "Expected eyes session to be successful, but mismatches occur. \n#{actual}"
+  end
+end