eyes_core 5.0.0 → 6.0.1

data/lib/applitools/calabash/eyes_calabash_android_screenshot.rb

@@ -1,68 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'eyes_calabash_screenshot'
-module Applitools
-  module Calabash
-    class EyesCalabashAndroidScreenshot < ::Applitools::Calabash::EyesCalabashScreenshot
-      extend Forwardable
-      def_delegators 'Applitools::EyesLogger', :logger
-
-      ANDROID_DENSITY = {
-        120 => 0.75,
-        160 => 1,
-        213 => 1.33,
-        240 => 1.5,
-        320 => 2,
-        480 => 3,
-        560 => 3.5,
-        640 => 4
-      }.freeze
-
-      DENSITY_DEFAULT = 160
-
-      class UnknownDeviceDensity < ::Applitools::EyesError; end
-
-      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)
-        logger.warn("Trying to set unknown device density - #{value}") unless
-            ANDROID_DENSITY.keys.include?(value.to_i)
-        @scale_factor = value.to_f / DENSITY_DEFAULT
-      end
-    end
-  end
-end

data/lib/applitools/calabash/eyes_calabash_ios_screenshot.rb

@@ -1,30 +0,0 @@
-# frozen_string_literal: true
-
-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

@@ -1,80 +0,0 @@
-# frozen_string_literal: false
-
-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

@@ -1,51 +0,0 @@
-# frozen_string_literal: true
-
-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) if eyes && eyes.running_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

@@ -1,45 +0,0 @@
-# frozen_string_literal: true
-
-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/android_scroll_view.rb

@@ -1,95 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'base'
-module Applitools
-  module Calabash
-    module FullPageCaptureAlgorithm
-      module CalabashAndroidScreenshot
-        def calabash_android_screenshot(screenshot, density)
-          Applitools::Calabash::EyesCalabashAndroidScreenshot.new(
-            screenshot, density: density
-          )
-        end
-      end
-      class AndroidScrollView < Base
-        include CalabashAndroidScreenshot
-        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
-
-          calabash_android_screenshot(
-            Applitools::Screenshot.from_image(stitched_image),
-            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

@@ -1,51 +0,0 @@
-# frozen_string_literal: true
-
-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

@@ -1,150 +0,0 @@
-# frozen_string_literal: true
-
-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/full_page_capture_algorithm.rb

@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-
-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/os_versions.rb

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-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

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-require 'rspec/expectations'
-
-RSpec::Matchers.define :match_baseline do |expected|
-  match do |actual|
-    eyes = Applitools::Calabash::EyesSettings.instance.eyes
-    result = eyes.check(expected, actual)
-    eyes.new_session? || 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

data/lib/applitools/calabash/steps/android_eyes_session.rb

@@ -1,37 +0,0 @@
-# frozen_string_literal: true
-
-Then(/^set OS$/) do
-  sdk_version = begin
-                  perform_action('android_sdk_version')
-                rescue HTTPClient::KeepAliveDisconnected
-                  reinstall_apps
-                  start_test_server_in_background
-                  perform_action('android_sdk_version')
-                end
-  if sdk_version['success']
-    Applitools::Calabash::EyesSettings.instance.eyes.host_os = Applitools::Calabash::OsVersions::Android.os_version(
-      sdk_version['message']
-    )
-  end
-end
-
-Then(/^set device pixel ratio$/) do
-  display_info = `#{default_device.adb_command} shell dumpsys display`
-  # size_match = /deviceWidth=(?<width>\d+), deviceHeight=(?<height>\d+)/.match(display_info)
-  density_match = /DisplayDeviceInfo.*density (?<density>\d+)/.match(display_info)
-  Applitools::Calabash::EyesSettings.instance.eyes.device_pixel_ratio = density_match[:density].to_i
-end
-
-Then(/^set device physical size$/) do
-  result = /mDefaultViewport=.*deviceWidth=(?<width>\d+).*deviceHeight=(?<height>\d+).*\n/.match(
-    `#{default_device.adb_command} shell dumpsys display |grep mDefaultViewport`
-  )
-  step %(eyes viewport size is "#{result[:width].to_i}x#{result[:height].to_i}")
-end
-
-Then(/^set device size$/) do
-  result = /^.*app=(?<width>\d+)x(?<height>\d+)/.match(
-    `#{default_device.adb_command} shell dumpsys window displays |grep cur | tr -d ' '`
-  )
-  step %(eyes viewport size is "#{result[:width].to_i}x#{result[:height].to_i}")
-end