[#17] Allow to define minimum time for busy waiting (#62)

* Introduce at_least functionality 
* DISCLAMER: Timeout message for min time isn't supported yet
---------

Co-authored-by: Amazia Gur <[email protected]>
Co-authored-by: Eli Segal <[email protected]>

Author: 3 people

Diff for: busypie/awaiter.py

@@ -1,8 +1,9 @@
 import asyncio
-
-import busypie
 import time
+from functools import partial
+from typing import Callable
 
+import busypie
 from busypie.condition import Condition
 from busypie.func import describe
 from busypie.types import Checker, ConditionEvaluator
@@ -16,36 +17,48 @@ def __init__(self, condition: 'Condition', evaluator_checker: Checker):
         self._last_error = None
 
     def _validate_condition(self):
-        if self._condition.poll_delay > self._condition.wait_time_in_secs:
+        if self._condition.poll_delay > self._condition.max_wait_time:
             raise ValueError('Poll delay should be shorter than maximum wait constraint')
+        if self._condition.min_wait_time >= self._condition.max_wait_time:
+            raise ValueError('at least should be shorter than maximum wait constraint')
 
     async def wait_for(self, evaluator: ConditionEvaluator) -> any:
         start_time = time.time()
+        time_bounds_checker = partial(self._validate_wait_bounds, evaluator, start_time)
         await asyncio.sleep(self._condition.poll_delay)
         while True:
             try:
                 result = await self._evaluator_check(evaluator)
                 if result:
+                    time_bounds_checker(self.is_under_min_wait_time)
                     return result
             except Exception as e:
                 self._raise_exception_if_not_ignored(e)
                 self._last_error = e
-            self._validate_wait_constraint(evaluator, start_time)
+            time_bounds_checker(self.is_max_wait_time_passed)
             await asyncio.sleep(self._condition.poll_interval)
 
+    def _validate_wait_bounds(self, condition_evaluator: ConditionEvaluator, start_time: float,
+                              constraint: Callable[[float], bool]):
+        execution_time = time.time() - start_time
+        if constraint(execution_time):
+            raise busypie.ConditionTimeoutError(
+                self._describe(condition_evaluator), self._condition.max_wait_time) from self._last_error
+
+    def _describe(self, condition_evaluator: ConditionEvaluator) -> str:
+        return self._condition.description or describe(condition_evaluator)
+
+    def is_under_min_wait_time(self, execute_time: float):
+        return execute_time <= self._condition.min_wait_time
+
     def _raise_exception_if_not_ignored(self, e: Exception):
         ignored_exceptions = self._condition.ignored_exceptions
         if ignored_exceptions is None or \
                 (ignored_exceptions and e.__class__ not in ignored_exceptions):
             raise e
 
-    def _validate_wait_constraint(self, condition_evaluator: ConditionEvaluator, start_time: float):
-        if (time.time() - start_time) > self._condition.wait_time_in_secs:
-            raise busypie.ConditionTimeoutError(
-                self._describe(condition_evaluator), self._condition.wait_time_in_secs) from self._last_error
-
-    def _describe(self, condition_evaluator: ConditionEvaluator) -> str:
-        return self._condition.description or describe(condition_evaluator)
+    def is_max_wait_time_passed(self, execute_time: float):
+        return execute_time > self._condition.max_wait_time
 
 
 class ReturnOnTimeoutAwaiter:
@@ -64,7 +77,7 @@ async def wait_for(self, evaluator: ConditionEvaluator) -> any:
 
 
 class ConditionTimeoutError(Exception):
-    def __init__(self, description: str, wait_time_in_secs: float):
+    def __init__(self, description: str, max_wait_time: float):
         super(ConditionTimeoutError, self).__init__("Failed to meet condition of [{}] within {} seconds"
-                                                    .format(description, wait_time_in_secs))
+                                                    .format(description, max_wait_time))
         self.description = description

Diff for: busypie/condition.py

@@ -21,10 +21,11 @@ def __init__(self, condition: 'Condition' = None):
         self._create_time_based_evaluatortions()
 
     def _create_time_based_evaluatortions(self):
-        self.at_most = self._time_property_evaluator_for('wait_time_in_secs')
+        self.at_most = self._time_property_evaluator_for('max_wait_time')
         self.wait_at_most = self.at_most
         self.poll_delay = self._time_property_evaluator_for('poll_delay')
         self.poll_interval = self._time_property_evaluator_for('poll_interval')
+        self.at_least = self._time_property_evaluator_for('min_wait_time')
 
     def _time_property_evaluator_for(self, name: str):
         return partial(time_value_operator, visitor=partial(self._time_property, name=name))
@@ -85,12 +86,13 @@ def return_on_timeout(self) -> 'ConditionBuilder':
 
 
 class Condition:
-    wait_time_in_secs = DEFAULT_MAX_WAIT_TIME
+    max_wait_time = DEFAULT_MAX_WAIT_TIME
     ignored_exceptions = None
     poll_interval = DEFAULT_POLL_INTERVAL
     poll_delay = DEFAULT_POLL_DELAY
     description = None
     return_on_timeout = False
+    min_wait_time = 0
 
     def append_exception(self, exception: Type[Exception]):
         if self.ignored_exceptions is None:
@@ -100,17 +102,18 @@ def append_exception(self, exception: Type[Exception]):
     def __eq__(self, other):
         if not isinstance(other, Condition):
             return False
+
         return \
-            self.wait_time_in_secs == other.wait_time_in_secs and \
+            self.max_wait_time == other.max_wait_time and \
             self.ignored_exceptions == other.ignored_exceptions and \
             self.poll_interval == other.poll_interval and \
             self.poll_delay == other.poll_delay
 
 
 set_default_timeout = partial(
     time_value_operator,
-    visitor=partial(setattr, Condition, 'wait_time_in_secs'))
+    visitor=partial(setattr, Condition, 'max_wait_time'))
 
 
 def reset_defaults() -> None:
-    Condition.wait_time_in_secs = DEFAULT_MAX_WAIT_TIME
+    Condition.max_wait_time = DEFAULT_MAX_WAIT_TIME

Diff for: tests/test_wait.py

@@ -45,3 +45,9 @@ def condition():
 
 def test_return_on_timeout():
     assert wait().at_most(100 * MILLISECOND).return_on_timeout().until(lambda: 2 == 3) is False
+
+
+def test_raise_given_condition_invoked_before_at_least():
+    with pytest.raises(ConditionTimeoutError):
+        with assert_done_after(0.4) as c:
+            wait().at_least(0.6).until(lambda: c.done)