def test_wrap_method_with_overriding_retry_and_timeout(unusued_sleep):
method = mock.Mock(spec=['__call__'],
side_effect=[exceptions.NotFound(None), 42])
default_retry = retry.Retry()
default_timeout = timeout.ConstantTimeout(60)
wrapped_method = google.api.core.gapic_v1.method.wrap_method(
method, default_retry, default_timeout)
result = wrapped_method(retry=retry.Retry(
retry.if_exception_type(exceptions.NotFound)),
timeout=timeout.ConstantTimeout(22))
assert result == 42
assert method.call_count == 2
method.assert_called_with(timeout=22, metadata=mock.ANY)
def _retry_from_retry_config(retry_params, retry_codes):
"""Creates a Retry object given a gapic retry configuration.
Args:
retry_params (dict): The retry parameter values, for example::
{
"initial_retry_delay_millis": 1000,
"retry_delay_multiplier": 2.5,
"max_retry_delay_millis": 120000,
"initial_rpc_timeout_millis": 120000,
"rpc_timeout_multiplier": 1.0,
"max_rpc_timeout_millis": 120000,
"total_timeout_millis": 600000
}
retry_codes (sequence[str]): The list of retryable gRPC error code
names.
Returns:
google.api.core.retry.Retry: The default retry object for the method.
"""
exception_classes = [
_exception_class_for_grpc_status_name(code) for code in retry_codes
]
return retry.Retry(
retry.if_exception_type(*exception_classes),
initial=(retry_params['initial_retry_delay_millis'] /
_MILLIS_PER_SECOND),
maximum=(retry_params['max_retry_delay_millis'] / _MILLIS_PER_SECOND),
multiplier=retry_params['retry_delay_multiplier'],
deadline=retry_params['total_timeout_millis'] / _MILLIS_PER_SECOND)
def test_constructor_defaults(self):
retry_ = retry.Retry()
assert retry_._predicate == retry.if_transient_error
assert retry_._initial == 1
assert retry_._maximum == 60
assert retry_._multiplier == 2
assert retry_._deadline == 120
def test_with_delay_noop(self):
retry_ = retry.Retry()
new_retry = retry_.with_delay()
assert retry_ is not new_retry
assert new_retry._initial == retry_._initial
assert new_retry._maximum == retry_._maximum
assert new_retry._multiplier == retry_._multiplier
def test_with_delay(self):
retry_ = retry.Retry()
new_retry = retry_.with_delay(initial=1, maximum=2, multiplier=3)
assert retry_ is not new_retry
assert new_retry._initial == 1
assert new_retry._maximum == 2
assert new_retry._multiplier == 3
def test_wrap_method_with_overriding_timeout_as_a_number():
method = mock.Mock(spec=['__call__'], return_value=42)
default_retry = retry.Retry()
default_timeout = timeout.ConstantTimeout(60)
wrapped_method = google.api.core.gapic_v1.method.wrap_method(
method, default_retry, default_timeout)
result = wrapped_method(timeout=22)
assert result == 42
method.assert_called_once_with(timeout=22, metadata=mock.ANY)
def test_constructor_options(self):
retry_ = retry.Retry(predicate=mock.sentinel.predicate,
initial=1,
maximum=2,
multiplier=3,
deadline=4)
assert retry_._predicate == mock.sentinel.predicate
assert retry_._initial == 1
assert retry_._maximum == 2
assert retry_._multiplier == 3
assert retry_._deadline == 4
def test_wrap_method_with_default_retry_and_timeout(unusued_sleep):
method = mock.Mock(spec=['__call__'],
side_effect=[exceptions.InternalServerError(None), 42])
default_retry = retry.Retry()
default_timeout = timeout.ConstantTimeout(60)
wrapped_method = google.api.core.gapic_v1.method.wrap_method(
method, default_retry, default_timeout)
result = wrapped_method()
assert result == 42
assert method.call_count == 2
method.assert_called_with(timeout=60, metadata=mock.ANY)
def test___call___and_execute_success(self, sleep):
retry_ = retry.Retry()
target = mock.Mock(spec=['__call__'], return_value=42)
# __name__ is needed by functools.partial.
target.__name__ = 'target'
decorated = retry_(target)
target.assert_not_called()
result = decorated('meep')
assert result == 42
target.assert_called_once_with('meep')
sleep.assert_not_called()
def test___call___and_execute_retry(self, sleep, uniform):
retry_ = retry.Retry(predicate=retry.if_exception_type(ValueError))
target = mock.Mock(spec=['__call__'], side_effect=[ValueError(), 42])
# __name__ is needed by functools.partial.
target.__name__ = 'target'
decorated = retry_(target)
target.assert_not_called()
result = decorated('meep')
assert result == 42
assert target.call_count == 2
target.assert_has_calls([mock.call('meep'), mock.call('meep')])
sleep.assert_called_once_with(retry_._initial)
def test_wrap_method_with_overriding_retry_deadline(unusued_sleep):
method = mock.Mock(
spec=['__call__'],
side_effect=([exceptions.InternalServerError(None)] * 3) + [42])
default_retry = retry.Retry()
default_timeout = timeout.ExponentialTimeout(deadline=60)
wrapped_method = google.api.core.gapic_v1.method.wrap_method(
method, default_retry, default_timeout)
# Overriding only the retry's deadline should also override the timeout's
# deadline.
result = wrapped_method(retry=default_retry.with_deadline(30))
assert result == 42
timeout_args = [call[1]['timeout'] for call in method.call_args_list]
assert timeout_args == [5, 10, 20, 29]
def _blocking_poll(self, timeout=None):
"""Poll and wait for the Future to be resolved.
Args:
timeout (int): How long to wait for the operation to complete.
If None, wait indefinitely.
"""
if self._result_set:
return
retry_ = retry.Retry(
predicate=retry.if_exception_type(_OperationNotComplete),
deadline=timeout)
try:
retry_(self._done_or_raise)()
except exceptions.RetryError:
raise concurrent.futures.TimeoutError(
'Operation did not complete within the designated '
'timeout.')
def test___str__(self):
retry_ = retry.Retry()
assert re.match((
r'<Retry predicate=<function.*?if_exception_type.*?>, '
r'initial=1.0, maximum=60.0, multiplier=2.0, deadline=120.0>'),
str(retry_))
def test_with_predicate(self):
retry_ = retry.Retry()
new_retry = retry_.with_predicate(mock.sentinel.predicate)
assert retry_ is not new_retry
assert new_retry._predicate == mock.sentinel.predicate
def test_with_deadline(self):
retry_ = retry.Retry()
new_retry = retry_.with_deadline(42)
assert retry_ is not new_retry
assert new_retry._deadline == 42
