def test_max_time_reached(self): # Python built-in types are immutable so we can't use @mock.patch curr_time = datetime.datetime.utcnow() class NewDateTime(datetime.datetime): """ Class to mock datetime. """ @classmethod def utcnow(cls): """ Method to always return specific UTC datetime. """ return curr_time built_in_datetime = retry.datetime # The instance of datetime becomes local to the module it's import in to. We must patch datetime using the # module instance that is imported in to the ec2 module. retry.datetime = NewDateTime manager = retry.LifecycleManager(1, 1, 300) self.assertEqual(manager._max_datetime, curr_time + datetime.timedelta(0, 300)) # pylint: disable=protected-access self.assertFalse(manager.max_time_reached()) # set the expiration in the past and ensure that max_time_reached returns True manager = retry.LifecycleManager(1, 1, -1) self.assertEqual(manager._max_datetime, curr_time + datetime.timedelta(0, -1)) # pylint: disable=protected-access self.assertTrue(manager.max_time_reached()) # restore the default functionality of retry.datetime retry.datetime = built_in_datetime
def test_execute_failure(self): manager = retry.LifecycleManager(1, 1, None) mock_func = mock.MagicMock() mock_func.side_effect = UniqueTestException mock_func.__name__ = 'TheMockTestFunction' with mock.patch(retry.__name__ + '.LifecycleManager.get_delay_time', lambda x: 0): self.assertRaises(UniqueTestException, manager.execute, mock_func, 'arg1', 'arg2')
def test_done(self, max_time_ret_val, max_attempts_ret_val, expected_return_value): manager = retry.LifecycleManager(1, 1, 1) with mock.patch( 'tubular.utils.retry.LifecycleManager.max_attempts_reached', lambda x: max_attempts_ret_val): with mock.patch( 'tubular.utils.retry.LifecycleManager.max_time_reached', lambda x: max_time_ret_val): self.assertEqual(manager.done(), expected_return_value)
def test_max_attempts_reached(self): manager = retry.LifecycleManager(1, 1, 1) # first call current_attempt_number should be 0 and max_attempts_reached should return False self.assertFalse(manager.max_attempts_reached()) manager._current_attempt_number += 1 self.assertFalse(manager.max_attempts_reached()) # incrementing again should put us past the max attempts threshold manager._current_attempt_number += 1 self.assertTrue(manager.max_attempts_reached())
def test_execute_subsequent_attempts_succeed(self): """ Test that the first call to execute fails, the second calls succeeds """ mock_func = mock.MagicMock() mock_func.side_effect = [UniqueTestException, "success"] mock_func.__name__ = 'TheMockTestFunction' with mock.patch(retry.__name__ + '.LifecycleManager.get_delay_time', lambda x: 0): manager = retry.LifecycleManager(2, 1, 500) self.assertEqual("success", manager.execute(mock_func, 'arg1', 'arg2'))
def test_execute_max_attempts_exceeded(self): mock_func = mock.MagicMock() mock_func.side_effect = UniqueTestException mock_func.__name__ = 'TheMockTestFunction' # patch out the sleep time and ensure that max_time_reached always returns False # this ensures we are only testing that the maximum number attempts have bee exceeded with mock.patch(retry.__name__ + '.LifecycleManager.get_delay_time', lambda x: 0): with mock.patch( retry.__name__ + '.LifecycleManager.max_time_reached', lambda x: False): manager = retry.LifecycleManager(2, 1, 500) self.assertRaises(UniqueTestException, manager.execute, mock_func, 'arg1', 'arg2')
def test_execute_time_limit_exceeded(self): mock_func = mock.MagicMock() mock_func.side_effect = UniqueTestException mock_func.__name__ = 'TheMockTestFunction' # patch out the sleep time and ensure that max_attempts_reached always returns False # this ensures we are only testing that the end time has been reached for the exit condition with mock.patch(retry.__name__ + '.LifecycleManager.get_delay_time', lambda x: 0): with mock.patch( retry.__name__ + '.LifecycleManager.max_attempts_reached', lambda x: False): manager = retry.LifecycleManager(10000, 1, 1) self.assertRaises(UniqueTestException, manager.execute, mock_func, 'arg1', 'arg2')
def test_execute_success(self): string1 = 'argument 1' string2 = 'argument 2' def success_fn(arg1, arg2): """ Function to mock success. """ self.assertEqual(string1, arg1) self.assertEqual(string2, arg2) manager = retry.LifecycleManager(1, 1, None) with mock.patch(retry.__name__ + '.LifecycleManager.get_delay_time', lambda x: 0): manager.execute(success_fn, string1, string2)
def test_max_time_reached_none(self): """ When no max time is set, max_time_reached should always return False """ manager = retry.LifecycleManager(1, 1, None) self.assertFalse(manager.max_time_reached())
def test_get_delay_time(self): manager = retry.LifecycleManager(1, 1, 1) self.assertEqual(manager.get_delay_time(), 1)