eyes_core 3.5.4 → 3.6.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 60dfb90fc4e333a0418bb6303774911f4727ca95
-  data.tar.gz: 72d6bc32da94dc2b3971051690cd1ed1cad58ab4
+  metadata.gz: 68baf2041ed67e8172284b1f19af46f53c13fce9
+  data.tar.gz: 1322f93d66d26b704a028619fe7cdaed92642f1f
 SHA512:
-  metadata.gz: 3dfc94e4c741333627a7d792dd1e12e90007a89171f70499b561f7884cca4b074348beb2ec51cbbc84f96f8a6958ab821118e97bd49e87cb18a0a99373627487
-  data.tar.gz: 66dc4259c574d5c4fce41e972f998fb89402061eb9eb5b64b6792537720f7b068f811018fda534e5e59ae87557f0356c5c1676ada68500e43203762a02bda4dd
+  metadata.gz: eb6c546e62d31ab27177debff341f5c127b462bb04bc2b58024d119004789715a5f0848d349c95414a2acb72e57b55745e45ff2668fd4a9f946614764b57e1c4
+  data.tar.gz: 86b3512f290b6b6cd5220285e7a19a31b0091600a67b08306aebd332a71035acd86c8cb9583490f2d4f21de4281a9fbabdb2c1557a0dadd0dfaadbc7e4ed7fe4

data/lib/applitools/connectivity/server_connector.rb

@@ -10,10 +10,12 @@ module Applitools::Connectivity
 
     DEFAULT_SERVER_URL = 'https://eyessdk.applitools.com'.freeze
 
+
     SSL_CERT = File.join(File.dirname(File.expand_path(__FILE__)), '../../../certs/cacert.pem').to_s.freeze
     DEFAULT_TIMEOUT = 300
 
     API_SESSIONS_RUNNING = '/api/sessions/running/'.freeze
+    API_SINGLE_TEST = '/api/sessions/'.freeze
 
     HTTP_STATUS_CODES = {
       created: 201,
@@ -31,6 +33,7 @@ module Applitools::Connectivity
           " (#{@server_url.class} is passed)"
       end
       @endpoint_url = URI.join(@server_url, API_SESSIONS_RUNNING).to_s
+      @single_check_endpoint_url = URI.join(@server_url, API_SINGLE_TEST).to_s
     end
 
     def set_proxy(uri, user = nil, password = nil)
@@ -49,13 +52,24 @@ module Applitools::Connectivity
       # Notice that this does not include the screenshot.
       json_data = Oj.dump(Applitools::Utils.camelcase_hash_keys(data.to_hash)).force_encoding('BINARY')
       body = [json_data.length].pack('L>') + json_data + data.screenshot
-      # Applitools::EyesLogger.debug json_data
       Applitools::EyesLogger.debug 'Sending match data...'
+      #Applitools::EyesLogger.debug json_data
       res = post(URI.join(endpoint_url, session.id.to_s), content_type: 'application/octet-stream', body: body)
       raise Applitools::EyesError.new("Request failed: #{res.status} #{res.headers}") unless res.success?
       Applitools::MatchResult.new Oj.load(res.body)
     end
 
+    def match_single_window(data)
+      # Notice that this does not include the screenshot.
+      json_data = Oj.dump(data.to_hash).force_encoding('BINARY')
+      body = [json_data.length].pack('L>') + json_data + data.screenshot
+      # Applitools::EyesLogger.debug json_data
+      Applitools::EyesLogger.debug 'Sending match data...'
+      res = long_post(@single_check_endpoint_url, content_type: 'application/octet-stream', body: body)
+      raise Applitools::EyesError.new("Request failed: #{res.status} #{res.headers} #{res.body}") unless res.success?
+      Applitools::TestResults.new Oj.load(res.body)
+    end
+
     def start_session(session_start_info)
       res = post(endpoint_url, body: Oj.dump(startInfo:
                                                  Applitools::Utils.camelcase_hash_keys(session_start_info.to_hash)))

data/lib/applitools/core/app_environment.rb

@@ -11,10 +11,10 @@ module Applitools
 
     def to_hash
       {
-        os: @os,
-        hosting_app: @hosting_app,
-        display_size: @display_size.to_hash,
-        inferred: @inferred
+        'os' => @os,
+        'hostingApp' => @hosting_app,
+        'displaySize' => @display_size.to_hash,
+        'inferred' => @inferred
       }
     end
 

data/lib/applitools/core/batch_info.rb

@@ -10,9 +10,9 @@ module Applitools
 
     def to_hash
       {
-        id: @id,
-        name: @name,
-        started_at: @started_at.iso8601
+        'id' => @id,
+        'name' => @name,
+        'startedAt' => @started_at.iso8601
       }
     end
 

data/lib/applitools/core/eyes_base.rb

@@ -54,6 +54,7 @@ module Applitools
       @user_inputs = UserInputArray.new
       self.app_output_provider = Object.new
       self.verbose_results = false
+      self.failed = false
       @inferred_environment = nil
 
       get_app_output_method = ->(r, s) { get_app_output_with_screenshot r, s }
@@ -172,7 +173,7 @@ module Applitools
       raise e
     end
 
-    def check_window_base(region_provider, tag, ignore_mismatch, retry_timeout, options = {})
+    def check_window_base(region_provider, retry_timeout, match_window_data)
       if disabled?
         logger.info "#{__method__} Ignored"
         result = Applitools::MatchResults.new
@@ -183,7 +184,7 @@ module Applitools
       raise Applitools::EyesError.new 'Eyes not open' unless open?
       Applitools::ArgumentGuard.not_nil region_provider, 'region_provider'
 
-      logger.info "check_window_base(#{region_provider}, #{tag}, #{ignore_mismatch}, #{retry_timeout})"
+      logger.info "check_window_base(#{region_provider}, #{match_window_data.tag}, #{match_window_data.ignore_mismatch}, #{retry_timeout})"
 
       tag = '' if tag.nil?
 
@@ -200,18 +201,11 @@ module Applitools
       end
 
       logger.info 'Calling match_window...'
-      result = @match_window_task.match_window(
-        user_inputs: user_inputs,
+      result = @match_window_task.match_window(match_window_data,
         last_screenshot: last_screenshot,
         region_provider: region_provider,
-        tag: tag,
         should_match_window_run_once_on_timeout: should_match_window_run_once_on_timeout,
-        ignore_mismatch: ignore_mismatch,
         retry_timeout: retry_timeout,
-        ignore: options[:ignore],
-        trim: options[:trim],
-        match_level: options[:match_level],
-        exact: options[:exact]
       )
       logger.info 'match_window done!'
 
@@ -219,13 +213,13 @@ module Applitools
         clear_user_inputs
         self.last_screenshot = result.screenshot
       else
-        unless ignore_mismatch
+        unless match_window_data.ignore_mismatch
           clear_user_inputs
           self.last_screenshot = result.screenshot
         end
 
         self.should_match_window_run_once_on_timeout = true
-
+        self.failed = true
         logger.info "Mistmatch! #{tag}" unless running_session.new_session?
 
         if failure_reports == :immediate
@@ -238,6 +232,77 @@ module Applitools
       result
     end
 
+
+    def check_single_base(region_provider, retry_timeout, match_window_data)
+      if disabled?
+        logger.info "#{__method__} Ignored"
+        result = Applitools::MatchResults.new
+        result.as_expected = true
+        return result
+      end
+
+      raise Applitools::EyesError.new 'Eyes not open' unless open?
+      Applitools::ArgumentGuard.not_nil region_provider, 'region_provider'
+
+      logger.info "check_single_base(#{region_provider}, #{match_window_data.tag}, #{match_window_data.ignore_mismatch}, #{retry_timeout})"
+
+      tag = '' if tag.nil?
+
+      session_start_info = SessionStartInfo.new agent_id: base_agent_id, app_id_or_name: app_name,
+         scenario_id_or_name: test_name, batch_info: batch,
+         env_name: baseline_name, environment: app_environment,
+         default_match_settings: default_match_settings,
+         branch_name: branch_name, parent_branch_name: parent_branch_name
+
+      match_window_data.start_info = session_start_info
+      match_window_data.update_baseline_if_new = save_new_tests
+      match_window_data.update_baseline_if_different = save_failed_tests
+      match_window_task = Applitools::MatchSingleTask.new(
+          logger,
+          match_timeout,
+          app_output_provider
+      )
+
+      logger.info 'Calling match_window...'
+      result = match_window_task.match_window(match_window_data,
+                                               last_screenshot: last_screenshot,
+                                               region_provider: region_provider,
+                                               should_match_window_run_once_on_timeout: should_match_window_run_once_on_timeout,
+                                               retry_timeout: retry_timeout,
+      ) do |match_results|
+        results = match_results.original_results
+        not_aborted = !results['isAborted']
+        new_and_saved = results['isNew'] && save_new_tests
+        different_and_saved = results['isDifferent'] && save_failed_tests
+        not_a_mismatch = !results['isDifferent'] && !results['isNew']
+
+        not_aborted && (new_and_saved || different_and_saved || not_a_mismatch)
+      end
+      logger.info 'match_window done!'
+
+      if result.as_expected?
+        clear_user_inputs
+        self.last_screenshot = result.screenshot
+      else
+        unless match_window_data.ignore_mismatch
+          clear_user_inputs
+          self.last_screenshot = result.screenshot
+        end
+
+        self.should_match_window_run_once_on_timeout = true
+
+        logger.info "Mistmatch! #{tag}"
+
+        if failure_reports == :immediate
+          raise Applitools::TestFailedException.new "Mistmatch found in #{session_start_info.scenario_id_or_name}" \
+              " of #{session_start_info.app_id_or_name}"
+        end
+      end
+
+      logger.info 'Done!'
+      result.original_results
+    end
+
     # Closes eyes
     # @param [Boolean] throw_exception If set to +true+ eyes will trow [Applitools::TestFailedError] exception,
     # otherwise the test will pass. Default is true
@@ -267,7 +332,7 @@ module Applitools
 
       logger.info 'Ending server session...'
 
-      save = is_new_session && save_new_tests || !is_new_session && save_failed_tests
+      save = is_new_session && save_new_tests || !is_new_session && failed && save_failed_tests
 
       logger.info "Automatically save test? #{save}"
 
@@ -305,7 +370,7 @@ module Applitools
     private
 
     attr_accessor :running_session, :last_screenshot, :current_app_name, :test_name, :session_type,
-      :scale_provider, :session_start_info, :should_match_window_run_once_on_timeout, :app_output_provider
+      :scale_provider, :session_start_info, :should_match_window_run_once_on_timeout, :app_output_provider, :failed
 
     attr_reader :user_inputs
 

data/lib/applitools/core/match_single_check_data.rb

@@ -0,0 +1,87 @@
+require_relative 'match_window_data'
+module Applitools
+  class MatchSingleCheckData < MatchWindowData
+    class << self
+      def default_data
+        {
+            'startInfo' => {
+              'agentId' => nil,
+              'appIdOrName' => nil,
+              'verId' => nil,
+              'scenarioIdOrName' => nil,
+              'batchInfo' => {},
+              'envName' => nil,
+              'environment' => {},
+              'defaultMatchSettings' => nil,
+              'branchName' => nil,
+              'parentBranchName' => nil
+            },
+            'IgnoreMismatch' => false,
+            'MismatchWait' => 0,
+            'Options' => {
+                'Name' => nil,
+                'UserInputs' => [],
+                'ImageMatchSettings' => {
+                    'MatchLevel' => 'None',
+                    'SplitTopHeight' => 0,
+                    'SplitBottomHeight' => 0,
+                    'IgnoreCaret' => false,
+                    'Ignore' => [],
+                    'Exact' => {
+                        'MinDiffIntensity' => 0,
+                        'MinDiffWidth' => 0,
+                        'MinDiffHeight' => 0,
+                        'MatchThreshold' => 0
+                    }
+                },
+                'IgnoreExpectedOutputSettings' => false,
+                'ForceMatch' => false,
+                'ForceMismatch' => false,
+                'IgnoreMatch' => false,
+                'IgnoreMismatch' => false,
+                'Trim' => {
+                    'Enabled' => false,
+                    'ForegroundIntensity' => 0,
+                    'MinEdgeLength' => 0
+                }
+            },
+            'Id' => nil,
+            'UserInputs' => [],
+            'AppOutput' => {
+                'Screenshot64' => nil,
+                'ScreenshotUrl' => nil,
+                'Title' => nil,
+                'IsPrimary' => false,
+                'Elapsed' => 0
+            },
+            'Tag' => nil,
+            'updateBaselineIfDifferent' => false,
+            'updateBaselineIfNew' => false
+        }
+      end
+    end
+
+    def start_info=(value)
+      Applitools::ArgumentGuard.is_a? value, 'value', Applitools::SessionStartInfo
+      hash_value = value.to_hash
+      current_data['startInfo']['batchInfo'] = hash_value[:batch_info]
+      current_data['startInfo']['environment'] = hash_value[:environment]
+      current_data['startInfo']['agentId'] = hash_value[:agent_id]
+      current_data['startInfo']['appIdOrName'] = hash_value[:app_id_or_name]
+      current_data['startInfo']['verId'] = hash_value[:ver_id]
+      current_data['startInfo']['scenarioIdOrName'] = hash_value[:scenario_id_or_name]
+      current_data['startInfo']['envName'] = hash_value[:env_name]
+      current_data['startInfo']['defaultMatchSettings'] = hash_value[:default_match_settings]
+      current_data['startInfo']['branchName'] = hash_value[:branch_name]
+      current_data['startInfo']['parentBranchName'] = hash_value[:parent_branch_name]
+    end
+
+    def update_baseline_if_different=(value)
+      current_data['updateBaselineIfDifferent'] = value ? true : false
+    end
+
+    def update_baseline_if_new=(value)
+      current_data['updateBaselineIfNew'] = value ? true : false
+    end
+  end
+end

data/lib/applitools/core/match_single_task.rb

@@ -0,0 +1,16 @@
+require 'base64'
+require_relative 'match_window_task'
+module Applitools
+  class MatchSingleTask < MatchWindowTask
+    def initialize(logger, retry_timeout, app_output_provider)
+      super(logger, 'nil', retry_timeout, app_output_provider)
+    end
+
+    private
+
+    def perform_match(match_window_data)
+      Applitools::ArgumentGuard.is_a? match_window_data, 'match_window_data', Applitools::MatchSingleCheckData
+      Applitools::Connectivity::ServerConnector.match_single_window match_window_data
+    end
+  end
+end

data/lib/applitools/core/match_window_data.rb

@@ -1,34 +1,171 @@
 module Applitools
   class MatchWindowData
+    class << self
+      def convert_coordinates(region, screenshot)
+        screenshot.convert_region_location(
+          Applitools::Region.from_location_size(region.location, region.size),
+          Applitools::EyesScreenshot::COORDINATE_TYPES[:context_relative],
+          Applitools::EyesScreenshot::COORDINATE_TYPES[:screenshot_as_is]
+        ).to_hash
+      end
+
+      def default_data
+        {
+          'IgnoreMismatch' => false,
+          'MismatchWait' => 0,
+          'Options' => {
+            'Name' => nil,
+            'UserInputs' => [],
+            'ImageMatchSettings' => {
+              'MatchLevel' => 'None',
+              'SplitTopHeight' => 0,
+              'SplitBottomHeight' => 0,
+              'IgnoreCaret' => false,
+              'Ignore' => [],
+              'Exact' => {
+                'MinDiffIntensity' => 0,
+                'MinDiffWidth' => 0,
+                'MinDiffHeight' => 0,
+                'MatchThreshold' => 0
+              }
+            },
+            'IgnoreExpectedOutputSettings' => false,
+            'ForceMatch' => false,
+            'ForceMismatch' => false,
+            'IgnoreMatch' => false,
+            'IgnoreMismatch' => false,
+            'Trim' => {
+              'Enabled' => false,
+            }
+          },
+          'Id' => nil,
+          'UserInputs' => [],
+          'AppOutput' => {
+            'Screenshot64' => nil,
+            'ScreenshotUrl' => nil,
+            'Title' => nil,
+            'IsPrimary' => false,
+            'Elapsed' => 0
+          },
+          'Tag' => nil
+        }
+      end
+
+      def valid_region(r)
+        true
+      end
+
+      def valid_input(i)
+        true
+      end
+    end
+
     attr_accessor :app_output, :user_inputs, :tag, :options, :ignore_mismatch
 
-    def initialize(user_inputs, app_output, tag, ignore_mismatch, options = {})
-      self.user_inputs = user_inputs
-      self.app_output = app_output
-      self.tag = tag
-      self.ignore_mismatch = ignore_mismatch
-      self.options = options
+    def initialize
+      @app_output = nil
+      @ignored_regions = []
+      @need_convert_ignored_regions_coordinates = false
     end
 
     def screenshot
       app_output.screenshot.image.to_blob
     end
 
-    alias appOutput app_output
-    alias userInputs user_inputs
-    alias ignoreMismatch ignore_mismatch
+    def ignore_mismatch=(value)
+      current_data['IgnoreMismatch'] = value ? true : false
+      current_data['Options']['IgnoreMismatch'] = current_data['IgnoreMismatch']
+    end
+
+    def tag=(value)
+      current_data['Tag'] = value
+      current_data['Options']['Name'] = value
+    end
+
+    def user_inputs=(value)
+      Applitools::ArgumentGuard.is_a? value, 'value', Array
+      value.each do |i|
+        current_data['UserInputs'] << i if self.class.valid_input(i)
+      end
+      current_data['Options']['UserInputs'] = current_data['UserInputs']
+    end
+
+    def ignored_regions=(value)
+      Applitools::ArgumentGuard.is_a? value, 'value', Array
+      value.each do |r|
+        current_data['Options']['ImageMatchSettings']['Ignore'] << r.to_hash if self.class.valid_region(r)
+      end
+    end
+
+    def app_output=(value)
+      Applitools::ArgumentGuard.is_a? value, 'value', Applitools::AppOutputWithScreenshot
+      @app_output = value
+      hash_value = value.to_hash
+      %w(Screenshot64 ScreenshotUrl Title IsPrimary Elapsed).each do |key|
+        current_data['AppOutput'][key] = hash_value[key] unless hash_value[key].nil?
+      end
+    end
+
+    def match_level=(value)
+      current_data['Options']['ImageMatchSettings']['MatchLevel'] = value
+    end
+
+    def read_target(target, driver)
+      #options
+      %w(trim).each do |field|
+        send("#{field}=", target.options[field.to_sym])
+      end
+      #ignored regions
+      target.ignored_regions.each do |r|
+        case r
+          when Proc
+            region = r.call(driver)
+            @ignored_regions << Applitools::Region.from_location_size(region.location, region.size)
+            @need_convert_ignored_regions_coordinates = true
+          when Applitools::Region
+            @ignored_regions << r
+            @need_convert_ignored_regions_coordinates = true
+        end
+      end
+    end
+
+    def ignore_mismatch
+     current_data['IgnoreMismatch']
+    end
+
+    def tag
+      current_data['Tag']
+    end
+
+    def screenshot
+      app_output.screenshot.image.to_blob
+    end
+
+    def trim=(value)
+      current_data['Options']['Trim']['Enabled'] = value ? true : false
+    end
+
+    def convert_ignored_regions_coordinates
+      return unless @need_convert_ignored_regions_coordinates
+      self.ignored_regions = @ignored_regions.map do |r|
+        self.class.convert_coordinates(r, app_output.screenshot)
+      end
+      @need_convert_ignored_regions_coordinates = false
+    end
 
     def to_hash
-      ary = [:userInputs, :appOutput, :tag, :ignoreMismatch, :options].map do |field|
-        result = send(field)
-        result = result.to_hash if result.respond_to? :to_hash
-        [field, result] if [String, Symbol, Hash, Array, FalseClass, TrueClass].include? result.class
-      end.compact
-      Hash[ary]
+      raise Applitools::EyesError.new 'You should convert coordinates for ignored_regions!' if @need_convert_ignored_regions_coordinates
+      current_data.dup
     end
 
     def to_s
       to_hash
     end
+
+    private
+
+    def current_data
+      @current_data ||= self.class.default_data
+    end
   end
 end

data/lib/applitools/core/match_window_task.rb

@@ -6,18 +6,6 @@ module Applitools
 
     attr_reader :logger, :running_session, :default_retry_timeout, :app_output_provider
 
-    class << self
-      def convert_coordinates(regions, screenshot)
-        regions.map do |r|
-          screenshot.convert_region_location(
-            Applitools::Region.from_location_size(r.location, r.size),
-            Applitools::EyesScreenshot::COORDINATE_TYPES[:context_relative],
-            Applitools::EyesScreenshot::COORDINATE_TYPES[:screenshot_as_is]
-          ).to_hash
-        end
-      end
-    end
-
     def initialize(logger, running_session, retry_timeout, app_output_provider)
       @logger = logger
       @running_session = running_session
@@ -35,18 +23,11 @@ module Applitools
         ' respond to :app_output'
     end
 
-    def match_window(options = {})
-      user_inputs = options[:user_inputs]
+    def match_window(match_window_data, options = {})
       last_screenshot = options[:last_screenshot]
       region_provider = options[:region_provider]
-      tag = options[:tag]
-      should_match_window_run_once_on_timeout = options[:should_match_window_run_once_on_timeout]
-      ignore_mismatch = options[:ignore_mismatch]
       retry_timeout = options[:retry_timeout]
-      ignore = options[:ignore] || []
-      trim = options[:trim] || false
-      match_level = options[:match_level]
-      exact = options[:exact]
+      should_match_window_run_once_on_timeout = options[:should_match_window_run_once_on_timeout]
 
       retry_timeout = default_retry_timeout if retry_timeout < 0
 
@@ -55,60 +36,42 @@ module Applitools
 
       if retry_timeout.zero? || should_match_window_run_once_on_timeout
         sleep retry_timeout if should_match_window_run_once_on_timeout
-        app_output = app_output_provider.app_output region_provider, last_screenshot
-        match_result = perform_match(
-          user_inputs: user_inputs,
-          app_output: app_output,
-          tag: tag,
-          ignore_mismatch: ignore_mismatch,
-          ignore: self.class.convert_coordinates(ignore, app_output.screenshot),
-          trim: trim,
-          match_level: match_level,
-          exact: exact
-        )
+        app_output = app_output_provider.app_output(region_provider, last_screenshot)
+        match_window_data.app_output = app_output
+        match_window_data.convert_ignored_regions_coordinates
+        match_result = perform_match(match_window_data)
       else
-        app_output = app_output_provider.app_output region_provider, last_screenshot
+        passed_ignore_mismatch = match_window_data.ignore_mismatch
+        app_output = app_output_provider.app_output(region_provider, last_screenshot)
+        match_window_data.app_output = app_output
+        match_window_data.convert_ignored_regions_coordinates
+        match_window_data.ignore_mismatch = true
         start = Time.now
-        match_result = perform_match(
-          user_inputs: user_inputs,
-          app_output: app_output,
-          tag: tag,
-          ignore_mismatch: true,
-          ignore: self.class.convert_coordinates(ignore, app_output.screenshot),
-          trim: trim,
-          match_level: match_level,
-          exact: exact
-        )
+        match_result = perform_match(match_window_data)
         retry_time = Time.now - start
 
-        while retry_time < retry_timeout && !match_result.as_expected?
+        if block_given?
+          block_retry = yield(match_result)
+        else
+          block_retry = false
+        end
+
+        while retry_time < retry_timeout && !(block_retry || match_result.as_expected?)
           sleep MATCH_INTERVAL
-          app_output = app_output_provider.app_output region_provider, last_screenshot
-          match_result = perform_match(
-            user_inputs: user_inputs,
-            app_output: app_output,
-            tag: tag,
-            ignore_mismatch: true,
-            ignore: self.class.convert_coordinates(ignore, app_output.screenshot),
-            trim: trim,
-            match_level: match_level,
-            exact: exact
-          )
+          app_output = app_output_provider.app_output(region_provider, last_screenshot)
+          match_window_data.app_output = app_output
+          match_window_data.convert_ignored_regions_coordinates
+          match_window_data.ignore_mismatch = true
+          match_result = perform_match(match_window_data)
           retry_time = Time.now - start
         end
 
-        unless match_result.as_expected?
-          app_output = app_output_provider.app_output region_provider, last_screenshot
-          match_result = perform_match(
-            user_inputs: user_inputs,
-            app_output: app_output,
-            tag: tag,
-            ignore_mismatch: ignore_mismatch,
-            ignore: self.class.convert_coordinates(ignore, app_output.screenshot),
-            trim: trim,
-            match_level: match_level,
-            exact: exact
-          )
+        unless block_retry || match_result.as_expected?
+          app_output = app_output_provider.app_output(region_provider, last_screenshot)
+          match_window_data.app_output = app_output
+          match_window_data.convert_ignored_regions_coordinates
+          match_window_data.ignore_mismatch = passed_ignore_mismatch
+          match_result = perform_match(match_window_data)
         end
       end
 
@@ -120,24 +83,9 @@ module Applitools
 
     private
 
-    def perform_match(options = {})
-      user_inputs = options[:user_inputs]
-      app_output = options[:app_output]
-      tag = options[:tag]
-      ignore_mismatch = options[:ignore_mismatch]
-      data = Applitools::MatchWindowData.new user_inputs, app_output, tag, ignore_mismatch,
-        name: tag, user_inputs: user_inputs.to_hash, ignore_mismatch: ignore_mismatch, ignore_match: false,
-        force_mistmatch: false, force_match: false,
-        image_match_settings: {
-          matchLevel: options[:match_level],
-          ignore: options[:ignore],
-          ignoreCaret: options[:ignore_caret].nil? ? true : options[:ignore_caret],
-          exact: options[:exact]
-        },
-        trim: {
-          enabled: options[:trim]
-        }
-      Applitools::Connectivity::ServerConnector.match_window running_session, data
+    def perform_match(match_window_data)
+      Applitools::ArgumentGuard.is_a? match_window_data, 'match_window_data', Applitools::MatchWindowData
+      Applitools::Connectivity::ServerConnector.match_window running_session, match_window_data
     end
   end
 end

data/lib/applitools/core/test_results.rb

@@ -2,7 +2,7 @@ require 'yaml'
 
 module Applitools
   class TestResults
-    attr_accessor :is_new, :url
+    attr_accessor :is_new, :url, :screenshot
     attr_reader :steps, :matches, :mismatches, :missing, :original_results
 
     def initialize(results = {})
@@ -16,17 +16,15 @@ module Applitools
     end
 
     def passed?
-      return !(mismatches > 0) && !(missing > 0) unless new?
-      false
+      !(original_results['isAborted'] || original_results['isDifferent'] || original_results['isNew'])
     end
 
     def failed?
-      return (mismatches > 0) || (missing > 0) unless new?
-      false
+      original_results['isDifferent'] && !(original_results['isAborted'] || original_results['isNew'])
     end
 
     def new?
-      is_new
+      original_results['isNew']
     end
 
     def ==(other)
@@ -42,6 +40,8 @@ module Applitools
 
     alias is_passed passed?
 
+    alias as_expected? passed?
+
     def to_s(advanced = false)
       is_new_str = ''
       is_new_str = is_new ? 'New test' : 'Existing test' unless is_new.nil?

data/lib/applitools/images/eyes.rb

@@ -62,21 +62,48 @@ module Applitools::Images
       Applitools::ArgumentGuard.not_nil(name, 'name')
       region_provider = get_region_provider(target)
 
+      match_window_data = Applitools::MatchWindowData.new
+      match_window_data.tag = name
+      match_window_data.match_level = default_match_settings[:match_level]
+      match_window_data.read_target(target, nil)
+
       image = target.image
       self.viewport_size = Applitools::RectangleSize.new image.width, image.height if viewport_size.nil?
       self.screenshot = EyesImagesScreenshot.new image
 
       mr = check_window_base(
-        region_provider, name, false,
+        region_provider,
         target.options[:timeout] || Applitools::EyesBase::USE_DEFAULT_TIMEOUT,
-        ignore: target.ignored_regions,
-        trim: target.options[:trim],
-        match_level: default_match_settings[:match_level],
-        exact: default_match_settings[:exact]
+        match_window_data
       )
       mr.as_expected?
     end
 
+    def check_single(name, target, options = {})
+      open_base(options) unless options.empty?
+      Applitools::ArgumentGuard.not_nil(name, 'name')
+      region_provider = get_region_provider(target)
+
+      match_window_data = Applitools::MatchSingleCheckData.new
+      match_window_data.tag = name
+
+      match_window_data.ignore_mismatch = options[:ignore_mismatch] ? true : false
+      match_window_data.match_level = default_match_settings[:match_level]
+
+      match_window_data.read_target(target, nil)
+
+      image = target.image
+      self.viewport_size = Applitools::RectangleSize.new image.width, image.height if viewport_size.nil?
+      self.screenshot = EyesImagesScreenshot.new image
+
+      mr = check_single_base(
+          region_provider,
+          target.options[:timeout] || Applitools::EyesBase::USE_DEFAULT_TIMEOUT,
+          match_window_data
+      )
+      mr
+    end
+
     def get_region_provider(target)
       if (region_to_check = target.region_to_check).nil?
         Object.new.tap do |prov|
@@ -124,6 +151,10 @@ module Applitools::Images
     #   eyes.check_image(image: my_image, tag: 'My Test', ignore_mismatch: true)
     def check_image(options)
       options = { tag: nil, ignore_mismatch: false }.merge options
+      match_data = Applitools::MatchWindowData.new
+      match_data.tag = options[:tag]
+      match_data.ignore_mismatch = options[:ignore_mismatch]
+      match_data.match_level = default_match_settings[:match_level]
 
       if disabled?
         logger.info "check_image(image, #{options[:tag]}, #{options[:ignore_mismatch]}): Ignored"
@@ -148,8 +179,7 @@ module Applitools::Images
           nil
         end
       end
-      mr = check_window_base region_provider, options[:tag], options[:ignore_mismatch],
-        Applitools::EyesBase::USE_DEFAULT_TIMEOUT, options.merge(match_level: default_match_settings[:match_level])
+      mr = check_window_base region_provider, Applitools::EyesBase::USE_DEFAULT_TIMEOUT, match_data
       mr.as_expected?
     end
 
@@ -170,6 +200,10 @@ module Applitools::Images
     #   eyes.check_region(image_bytes: string_represents_image, tag: 'My Test', region: my_region)
     def check_region(options)
       options = { tag: nil, ignore_mismatch: false }.merge options
+      match_data = Applitools::MatchWindowData.new
+      match_data.tag = options[:tag]
+      match_data.ignore_mismatch = options[:ignore_mismatch]
+      match_data.match_level = default_match_settings[:match_level]
 
       if disabled?
         logger.info "check_region(image, #{options[:tag]}, #{options[:ignore_mismatch]}): Ignored"
@@ -196,8 +230,9 @@ module Applitools::Images
           Applitools::EyesScreenshot::COORDINATE_TYPES[:screenshot_as_is]
         end
       end
-      mr = check_window_base region_provider, options[:tag], options[:ignore_mismatch],
-        Applitools::EyesBase::USE_DEFAULT_TIMEOUT, options.merge(match_level: default_match_settings[:match_level])
+      # mr = check_window_base region_provider, options[:tag], options[:ignore_mismatch],
+      #   Applitools::EyesBase::USE_DEFAULT_TIMEOUT, options.merge(match_level: default_match_settings[:match_level])
+      mr = check_window_base region_provider, Applitools::EyesBase::USE_DEFAULT_TIMEOUT, match_data
       mr.as_expected?
     end
 

data/lib/applitools/version.rb

@@ -1,3 +1,3 @@
 module Applitools
-  VERSION = '3.5.4'.freeze
+  VERSION = '3.6.4'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: eyes_core
 version: !ruby/object:Gem::Version
-  version: 3.5.4
+  version: 3.6.4
 platform: ruby
 authors:
 - Applitools Team
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-05-02 00:00:00.000000000 Z
+date: 2017-05-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: oily_png
@@ -222,6 +222,8 @@ files:
 - lib/applitools/core/location.rb
 - lib/applitools/core/match_result.rb
 - lib/applitools/core/match_results.rb
+- lib/applitools/core/match_single_check_data.rb
+- lib/applitools/core/match_single_task.rb
 - lib/applitools/core/match_window_data.rb
 - lib/applitools/core/match_window_task.rb
 - lib/applitools/core/mouse_trigger.rb