eyes_core 4.6.3 → 6.0.0

data/lib/applitools/calabash/eyes.rb

@@ -1,194 +0,0 @@
-# frozen_string_literal: false
-
-module Applitools
-  module Calabash
-    class Eyes < Applitools::EyesBase
-      attr_accessor :device_pixel_ratio, :full_page_capture_algorithm, :base_agent_id, :title,
-        :debug_screenshots, :debug_screenshot_provider, :tag_for_debug
-      attr_reader :context
-
-      def initialize(server_url = Applitools::Connectivity::ServerConnector::DEFAULT_SERVER_URL)
-        super
-        self.runner = Applitools::ClassicRunner.new
-        self.base_agent_id = "eyes.calabash.ruby/#{Applitools::VERSION}".freeze
-        self.debug_screenshots = false
-        self.debug_screenshot_provider = Applitools::DebugScreenshotProvider.new
-                                                                            .tag_access { tag_for_debug }
-                                                                            .debug_flag_access { debug_screenshots }
-      end
-
-      def open(options = {})
-        Applitools::ArgumentGuard.hash options, 'open(options)', [:app_name, :test_name]
-        open_base options
-      end
-
-      def check(*args)
-        args.compact!
-        case (first_arg = args.shift)
-        when String
-          name = first_arg
-          target = args.shift
-        when Applitools::Selenium::Target
-          target = first_arg
-        when Hash
-          target = first_arg[:target]
-          name = first_arg[:name] || first_arg[:tag]
-        end
-
-        self.tag_for_debug = get_tag_for_debug(name)
-        check_it(name, target, Applitools::MatchWindowData.new(default_match_settings))
-      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
-        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)
-        result = super(*args, &:scale_it!)
-        self.screenshot_url = nil
-        result
-      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 "#{app_name} #{test_name}" if name.empty?
-        "#{app_name} #{test_name} - #{name}"
-      end
-    end
-  end
-end

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