Fix repeated steps (#13)

* Run match_window only once

* Remove option to set retry_timeout
* Set retry_timeout to 0

* Fix ignore_mismatch param

Author: eirenik0

eyes_core/applitools/core/match_window_task.py

@@ -1,6 +1,5 @@
 from __future__ import absolute_import
 
-import functools
 import time
 import typing as tp
 from struct import pack
@@ -56,7 +55,7 @@ def __init__(self, eyes, server_connector, running_session, default_retry_timeou
         self._default_retry_timeout = (
             default_retry_timeout / 1000.0
         )  # type: Num # since we want the time in seconds.
-        self._screenshot = None  # type: tp.Optional[EyesScreenshot]
+        self._last_screenshot = None  # type: tp.Optional[EyesScreenshot]
 
     @staticmethod
     def _create_match_data_bytes(
@@ -143,14 +142,16 @@ def _prepare_match_data_for_window(
         # TODO: Refactor this
         if hasattr(self._eyes, "_hide_scrollbars_if_needed"):
             with self._eyes._hide_scrollbars_if_needed():  # type: ignore
-                self._screenshot = self._eyes.get_screenshot(
+                self._last_screenshot = self._eyes.get_screenshot(
                     hide_scrollbars_called=True
                 )
         else:
-            self._screenshot = self._eyes.get_screenshot()
+            self._last_screenshot = self._eyes.get_screenshot()
 
-        dynamic_regions = MatchWindowTask._get_dynamic_regions(target, self._screenshot)
-        app_output = {"_title": title, "screenshot64": None}  # type: AppOutput
+        dynamic_regions = MatchWindowTask._get_dynamic_regions(
+            target, self._last_screenshot
+        )
+        app_output = {"title": title, "screenshot64": None}  # type: AppOutput
 
         if self._eyes.send_dom:
             dom_json = self._eyes._try_capture_dom()
@@ -167,50 +168,86 @@ def _prepare_match_data_for_window(
             user_inputs,
             tag,
             ignore_mismatch,
-            self._screenshot,
+            self._last_screenshot,
             default_match_settings,
             target,
             dynamic_regions["ignore"],
             dynamic_regions["floating"],
         )
 
-    def _run_with_intervals(self, prepare_action, retry_timeout):
-        # type: (tp.Callable, Num) -> MatchResult
+    def _run_with_intervals(self, prepare_match_data_options, retry_timeout):
+        # type: (tp.Dict, Num) -> MatchResult
         """
         Includes retries in case the screenshot does not match.
         """
         logger.debug("Matching with intervals...")
         # We intentionally take the first screenshot before starting the timer,
         # to allow the page just a tad more time to stabilize.
-        data = prepare_action()
+        prepare_match_data_options = prepare_match_data_options.copy()
+        prepare_match_data_options["ignore_mismatch"] = True
+        data = self._prepare_match_data_for_window(**prepare_match_data_options)
+
         # Start the timer.
         start = time.time()
         logger.debug("First match attempt...")
         as_expected = self._server_connector.match_window(self._running_session, data)
         if as_expected:
-            return {"as_expected": True, "screenshot": self._screenshot}
+            return {"as_expected": True, "screenshot": self._last_screenshot}
         retry = time.time() - start
         logger.debug("Failed. Elapsed time: {0:.1f} seconds".format(retry))
 
         while retry < retry_timeout:
             logger.debug("Matching...")
             time.sleep(self.MATCH_INTERVAL)
-            data = prepare_action(ignore_mismatch=True)
+
+            data = self._prepare_match_data_for_window(**prepare_match_data_options)
             as_expected = self._server_connector.match_window(
                 self._running_session, data
             )
             if as_expected:
-                return {"as_expected": True, "screenshot": self._screenshot}
+                return {"as_expected": True, "screenshot": self._last_screenshot}
             retry = time.time() - start
             logger.debug("Elapsed time: {0:.1f} seconds".format(retry))
+
         # One last try
         logger.debug("One last matching attempt...")
-        data = prepare_action()
+        prepare_match_data_options["ignore_mismatch"] = False
+        data = self._prepare_match_data_for_window(**prepare_match_data_options)
         as_expected = self._server_connector.match_window(self._running_session, data)
-        return {"as_expected": as_expected, "screenshot": self._screenshot}
+        return {"as_expected": as_expected, "screenshot": self._last_screenshot}
+
+    def match_window(
+        self,
+        retry_timeout,  # type: Num
+        tag,  # type: str
+        user_inputs,  # UserInputs
+        default_match_settings,  # type: ImageMatchSettings
+        target,
+        ignore_mismatch,
+        run_once_after_wait=False,
+    ):
+        # type: (...) -> MatchResult
+        """
+        Performs a match for the window.
+
+        :param retry_timeout: Amount of time until it retries.
+        :param tag: The name of the tag (optional).
+        :param user_inputs: The user input.
+        :param default_match_settings: The default match settings for the session.
+        :param target: The target of the check_window call.
+        :param ignore_mismatch: True if the server should ignore a negative result
+                                for the visual validation.
+        :param run_once_after_wait: Whether or not to run again after waiting.
+        :return: The result of the run.
+        """
+        prepare_match_data_options = dict(
+            tag=tag,
+            user_inputs=user_inputs,
+            default_match_settings=default_match_settings,
+            target=target,
+            ignore_mismatch=ignore_mismatch,
+        )
 
-    def _run(self, prepare_action, run_once_after_wait=False, retry_timeout=-1):
-        # type: (tp.Callable, bool, Num) -> MatchResult
         if 0 < retry_timeout < MatchWindowTask.MINIMUM_MATCH_TIMEOUT:
             raise ValueError(
                 "Match timeout must be at least 60ms, got {} instead.".format(
@@ -221,57 +258,25 @@ def _run(self, prepare_action, run_once_after_wait=False, retry_timeout=-1):
             retry_timeout = self._default_retry_timeout
         else:
             retry_timeout /= 1000.0
+
         logger.debug("Match timeout set to: {0} seconds".format(retry_timeout))
         start = time.time()
         if run_once_after_wait or retry_timeout == 0:
             logger.debug("Matching once...")
             # If the load time is 0, the sleep would immediately return anyway.
             time.sleep(retry_timeout)
-            data = prepare_action()
+            data = self._prepare_match_data_for_window(**prepare_match_data_options)
             as_expected = self._server_connector.match_window(
                 self._running_session, data
             )
             result = {
                 "as_expected": as_expected,
-                "screenshot": self._screenshot,
+                "screenshot": self._last_screenshot,
             }  # type: MatchResult
         else:
-            result = self._run_with_intervals(prepare_action, retry_timeout)
+            result = self._run_with_intervals(prepare_match_data_options, retry_timeout)
+
         logger.debug("Match result: {0}".format(result["as_expected"]))
         elapsed_time = time.time() - start
         logger.debug("_run(): Completed in {0:.1f} seconds".format(elapsed_time))
         return result
-
-    def match_window(
-        self,
-        retry_timeout,  # type: Num
-        tag,  # type: str
-        user_inputs,  # UserInputs
-        default_match_settings,  # type: ImageMatchSettings
-        target,
-        ignore_mismatch,
-        run_once_after_wait=False,
-    ):
-        # type: (...) -> MatchResult
-        """
-        Performs a match for the window.
-
-        :param retry_timeout: Amount of time until it retries.
-        :param tag: The name of the tag (optional).
-        :param user_inputs: The user input.
-        :param default_match_settings: The default match settings for the session.
-        :param target: The target of the check_window call.
-        :param ignore_mismatch: True if the server should ignore a negative result
-                                for the visual validation.
-        :param run_once_after_wait: Whether or not to run again after waiting.
-        :return: The result of the run.
-        """
-        prepare_action = functools.partial(
-            self._prepare_match_data_for_window,
-            tag,
-            user_inputs,
-            default_match_settings,
-            target,
-            ignore_mismatch,
-        )
-        return self._run(prepare_action, run_once_after_wait, retry_timeout)

eyes_core/applitools/core/server_connector.py

@@ -214,7 +214,7 @@ def stop_session(self, running_session, is_aborted, save):
         )
 
     def match_window(self, running_session, data):
-        # type: (RunningSession, tp.Text) -> bool
+        # type: (RunningSession, bytes) -> bool
         """
         Matches the current window to the immediate expected window in the Eyes server.
         Notice that a window might be matched later at the end of the test, even if it

eyes_images/applitools/images/eyes.py

@@ -72,34 +72,27 @@ def check(self, name, target):
             return False
         return self._check_image(name, False, target)
 
-    def check_image(self, image, tag=None, ignore_mismatch=False, retry_timeout=-1):
-        # type: (Union[Image.Image, Text], Optional[Text], bool, int) -> Optional[bool]
+    def check_image(self, image, tag=None, ignore_mismatch=False):
+        # type: (Union[Image.Image, Text], Optional[Text], bool) -> Optional[bool]
         if self.is_disabled:
             return None
         logger.info(
-            "check_image(Image {}, tag {}, ignore_mismatch {}, retry_timeout {}".format(
-                image, tag, ignore_mismatch, retry_timeout
+            "check_image(Image {}, tag {}, ignore_mismatch {}".format(
+                image, tag, ignore_mismatch
             )
         )
-        return self._check_image(
-            tag, ignore_mismatch, Target().image(image).timeout(retry_timeout)
-        )
+        return self._check_image(tag, ignore_mismatch, Target().image(image))
 
-    def check_region(
-        self, image, region, tag=None, ignore_mismatch=False, retry_timeout=-1
-    ):
-        # type: (Image.Image, Region, Optional[Text], bool, int) -> Optional[bool]
+    def check_region(self, image, region, tag=None, ignore_mismatch=False):
+        # type: (Image.Image, Region, Optional[Text], bool) -> Optional[bool]
         if self.is_disabled:
             return None
         logger.info(
-            "check_region(Image {}, region {}, tag {}, "
-            "ignore_mismatch {}, retry_timeout {}".format(
-                image, region, tag, ignore_mismatch, retry_timeout
+            "check_region(Image {}, region {}, tag {}, ignore_mismatch {}".format(
+                image, region, tag, ignore_mismatch
             )
         )
-        return self._check_image(
-            tag, ignore_mismatch, Target().region(image, region).timeout(retry_timeout)
-        )
+        return self._check_image(tag, ignore_mismatch, Target().region(image, region))
 
     def _check_image(self, name, ignore_mismatch, target):
         # type: (Text, bool, Target) -> bool
@@ -110,12 +103,13 @@ def _check_image(self, name, ignore_mismatch, target):
             self.abort_if_not_closed()
             raise EyesError("you must call open() before checking")
 
-        image = target._image  # type: Image.Image
+        image = target.values.image  # type: Image.Image
+        timeout = 0  # run match_window once
         self._screenshot = EyesImagesScreenshot(image)
         if not self._viewport_size:
             self.set_viewport_size(dict(width=image.width, height=image.height))
 
-        match_result = self._check_window_base(name, -1, target, ignore_mismatch)
+        match_result = self._check_window_base(name, timeout, target, ignore_mismatch)
         self._screenshot = None
         self._raw_title = None
         return match_result["as_expected"]

eyes_images/applitools/images/target.py

@@ -2,12 +2,11 @@
 
 import typing as tp
 
-from PIL import Image
-
 from applitools.core import RegionProvider
-from applitools.core.utils import image_utils
 from applitools.core.errors import EyesError
 from applitools.core.geometry import Region
+from applitools.core.utils import image_utils
+from PIL import Image
 
 if tp.TYPE_CHECKING:
     from applitools.images.capture import EyesImagesScreenshot
@@ -88,6 +87,10 @@ def ignore_regions(self):
     def floating_regions(self):
         return self.check_settings._floating_regions
 
+    @property
+    def image(self):
+        return self.check_settings._image
+
 
 # Main class for the module
 class Target(object):
@@ -99,7 +102,6 @@ class Target(object):
     __floating_regions = None  # type: tp.Optional[tp.List]
     _image = None  # type: tp.Optional[EyesImagesScreenshot]
     _target_region = None  # type: tp.Optional[Region]
-    _timeout = -1
 
     _ignore_caret = None