def test_on_exception_success_random_jitter(monkeypatch):
monkeypatch.setattr('time.sleep', lambda x: None)
log, log_success, log_backoff, log_giveup = _log_hdlrs()
@backoff.on_exception(backoff.expo,
Exception,
on_success=log_success,
on_backoff=log_backoff,
on_giveup=log_giveup,
jitter=backoff.random_jitter,
factor=0.5)
@_save_target
def succeeder(*args, **kwargs):
# succeed after we've backed off twice
if len(log['backoff']) < 2:
raise ValueError("catch me")
succeeder(1, 2, 3, foo=1, bar=2)
# we try 3 times, backing off twice before succeeding
assert len(log['success']) == 1
assert len(log['backoff']) == 2
assert len(log['giveup']) == 0
for i in range(2):
details = log['backoff'][i]
assert details['wait'] >= 0.5 * 2**i
def test_on_predicate_giveup():
log, log_success, log_backoff, log_giveup = _log_hdlrs()
@backoff.on_predicate(backoff.constant,
on_success=log_success,
on_backoff=log_backoff,
on_giveup=log_giveup,
max_tries=3,
jitter=lambda: 0,
interval=0)
@_save_target
def emptiness(*args, **kwargs):
pass
emptiness(1, 2, 3, foo=1, bar=2)
# we try 3 times, backing off twice and giving up once
assert len(log['success']) == 0
assert len(log['backoff']) == 2
assert len(log['giveup']) == 1
details = log['giveup'][0]
assert details == {
'args': (1, 2, 3),
'kwargs': {
'foo': 1,
'bar': 2
},
'target': emptiness._target,
'tries': 3,
'value': None
}
def test_on_predicate_iterable_handlers():
hdlrs = [_log_hdlrs() for _ in range(3)]
@backoff.on_predicate(backoff.constant,
on_success=(h[1] for h in hdlrs),
on_backoff=(h[2] for h in hdlrs),
on_giveup=(h[3] for h in hdlrs),
max_tries=3,
jitter=lambda: 0,
interval=0)
@_save_target
def emptiness(*args, **kwargs):
pass
emptiness(1, 2, 3, foo=1, bar=2)
for i in range(3):
assert len(hdlrs[i][0]['success']) == 0
assert len(hdlrs[i][0]['backoff']) == 2
assert len(hdlrs[i][0]['giveup']) == 1
details = hdlrs[i][0]['giveup'][0]
assert details == {
'args': (1, 2, 3),
'kwargs': {
'foo': 1,
'bar': 2
},
'target': emptiness._target,
'tries': 3,
'value': None
}
async def test_on_predicate_iterable_handlers():
hdlrs = [_log_hdlrs() for _ in range(3)]
@backoff.on_predicate(backoff.constant,
on_success=(h[1] for h in hdlrs),
on_backoff=(h[2] for h in hdlrs),
on_giveup=(h[3] for h in hdlrs),
max_tries=3,
jitter=None,
interval=0)
@_save_target
async def emptiness(*args, **kwargs):
pass
await emptiness(1, 2, 3, foo=1, bar=2)
for i in range(3):
assert len(hdlrs[i][0]['success']) == 0
assert len(hdlrs[i][0]['backoff']) == 2
assert len(hdlrs[i][0]['giveup']) == 1
details = dict(hdlrs[i][0]['giveup'][0])
elapsed = details.pop('elapsed')
assert isinstance(elapsed, float)
assert details == {'args': (1, 2, 3),
'kwargs': {'foo': 1, 'bar': 2},
'target': emptiness._target,
'tries': 3,
'value': None}
def test_on_exception_giveup():
log, log_success, log_backoff, log_giveup = _log_hdlrs()
@backoff.on_exception(backoff.constant,
ValueError,
on_success=log_success,
on_backoff=log_backoff,
on_giveup=log_giveup,
max_tries=3,
jitter=lambda: 0,
interval=0)
@_save_target
def exceptor(*args, **kwargs):
raise ValueError("catch me")
with pytest.raises(ValueError):
exceptor(1, 2, 3, foo=1, bar=2)
# we try 3 times, backing off twice and giving up once
assert len(log['success']) == 0
assert len(log['backoff']) == 2
assert len(log['giveup']) == 1
details = log['giveup'][0]
assert details == {
'args': (1, 2, 3),
'kwargs': {
'foo': 1,
'bar': 2
},
'target': exceptor._target,
'tries': 3
}
async def test_on_predicate_giveup():
log, log_success, log_backoff, log_giveup = _log_hdlrs()
@backoff.on_predicate(backoff.constant,
on_success=log_success,
on_backoff=log_backoff,
on_giveup=log_giveup,
max_tries=3,
jitter=None,
interval=0)
@_save_target
async def emptiness(*args, **kwargs):
pass
await emptiness(1, 2, 3, foo=1, bar=2)
# we try 3 times, backing off twice and giving up once
assert len(log['success']) == 0
assert len(log['backoff']) == 2
assert len(log['giveup']) == 1
details = log['giveup'][0]
elapsed = details.pop('elapsed')
assert isinstance(elapsed, float)
assert details == {'args': (1, 2, 3),
'kwargs': {'foo': 1, 'bar': 2},
'target': emptiness._target,
'tries': 3,
'value': None}
async def test_on_exception_giveup():
log, log_success, log_backoff, log_giveup = _log_hdlrs()
@backoff.on_exception(backoff.constant,
ValueError,
on_success=log_success,
on_backoff=log_backoff,
on_giveup=log_giveup,
max_tries=3,
jitter=None,
interval=0)
@_save_target
async def exceptor(*args, **kwargs):
raise ValueError("catch me")
with pytest.raises(ValueError):
await exceptor(1, 2, 3, foo=1, bar=2)
# we try 3 times, backing off twice and giving up once
assert len(log['success']) == 0
assert len(log['backoff']) == 2
assert len(log['giveup']) == 1
details = log['giveup'][0]
elapsed = details.pop('elapsed')
assert isinstance(elapsed, float)
assert details == {'args': (1, 2, 3),
'kwargs': {'foo': 1, 'bar': 2},
'target': exceptor._target,
'tries': 3}
async def test_on_exception_success_full_jitter(monkeypatch):
monkeypatch.setattr('asyncio.sleep', asyncio.coroutine(lambda x: None))
log, log_success, log_backoff, log_giveup = _log_hdlrs()
@backoff.on_exception(backoff.expo,
Exception,
on_success=log_success,
on_backoff=log_backoff,
on_giveup=log_giveup,
jitter=backoff.full_jitter,
factor=0.5)
@_save_target
async def succeeder(*args, **kwargs):
# succeed after we've backed off twice
if len(log['backoff']) < 2:
raise ValueError("catch me")
await succeeder(1, 2, 3, foo=1, bar=2)
# we try 3 times, backing off twice before succeeding
assert len(log['success']) == 1
assert len(log['backoff']) == 2
assert len(log['giveup']) == 0
for i in range(2):
details = log['backoff'][i]
assert details['wait'] <= 0.5 * 2 ** i
def test_on_predicate_success_0_arg_jitter(monkeypatch):
monkeypatch.setattr('asyncio.sleep', asyncio.coroutine(lambda x: None))
monkeypatch.setattr('random.random', lambda: 0)
log, log_success, log_backoff, log_giveup = _log_hdlrs()
@backoff.on_predicate(backoff.constant,
on_success=log_success,
on_backoff=log_backoff,
on_giveup=log_giveup,
jitter=random.random,
interval=0)
@_save_target
@asyncio.coroutine
def success(*args, **kwargs):
# succeed after we've backed off twice
return len(log['backoff']) == 2
yield from success(1, 2, 3, foo=1, bar=2)
# we try 3 times, backing off twice before succeeding
assert len(log['success']) == 1
assert len(log['backoff']) == 2
assert len(log['giveup']) == 0
for i in range(2):
details = log['backoff'][i]
elapsed = details.pop('elapsed')
assert isinstance(elapsed, float)
assert details == {
'args': (1, 2, 3),
'kwargs': {
'foo': 1,
'bar': 2
},
'target': success._target,
'tries': i + 1,
'value': False,
'wait': 0
}
details = log['success'][0]
elapsed = details.pop('elapsed')
assert isinstance(elapsed, float)
assert details == {
'args': (1, 2, 3),
'kwargs': {
'foo': 1,
'bar': 2
},
'target': success._target,
'tries': 3,
'value': True
}
async def test_on_exception_success_0_arg_jitter(monkeypatch):
monkeypatch.setattr('asyncio.sleep', asyncio.coroutine(lambda x: None))
monkeypatch.setattr('random.random', lambda: 0)
log, log_success, log_backoff, log_giveup = _log_hdlrs()
@backoff.on_exception(backoff.constant,
Exception,
on_success=log_success,
on_backoff=log_backoff,
on_giveup=log_giveup,
jitter=random.random,
interval=0)
@_save_target
async def succeeder(*args, **kwargs):
# succeed after we've backed off twice
if len(log['backoff']) < 2:
raise ValueError("catch me")
with pytest.deprecated_call():
await succeeder(1, 2, 3, foo=1, bar=2)
# we try 3 times, backing off twice before succeeding
assert len(log['success']) == 1
assert len(log['backoff']) == 2
assert len(log['giveup']) == 0
for i in range(2):
details = log['backoff'][i]
elapsed = details.pop('elapsed')
assert isinstance(elapsed, float)
assert details == {
'args': (1, 2, 3),
'kwargs': {
'foo': 1,
'bar': 2
},
'target': succeeder._target,
'tries': i + 1,
'wait': 0
}
details = log['success'][0]
elapsed = details.pop('elapsed')
assert isinstance(elapsed, float)
assert details == {
'args': (1, 2, 3),
'kwargs': {
'foo': 1,
'bar': 2
},
'target': succeeder._target,
'tries': 3
}
def test_on_exception_success():
log, log_success, log_backoff, log_giveup = _log_hdlrs()
@backoff.on_exception(backoff.constant,
Exception,
on_success=log_success,
on_backoff=log_backoff,
on_giveup=log_giveup,
jitter=lambda: 0,
interval=0)
@_save_target
@asyncio.coroutine
def succeeder(*args, **kwargs):
# succeed after we've backed off twice
if len(log['backoff']) < 2:
raise ValueError("catch me")
yield from succeeder(1, 2, 3, foo=1, bar=2)
# we try 3 times, backing off twice before succeeding
assert len(log['success']) == 1
assert len(log['backoff']) == 2
assert len(log['giveup']) == 0
for i in range(2):
details = log['backoff'][i]
elapsed = details.pop('elapsed')
assert isinstance(elapsed, float)
assert details == {
'args': (1, 2, 3),
'kwargs': {
'foo': 1,
'bar': 2
},
'target': succeeder._target,
'tries': i + 1,
'wait': 0
}
details = log['success'][0]
elapsed = details.pop('elapsed')
assert isinstance(elapsed, float)
assert details == {
'args': (1, 2, 3),
'kwargs': {
'foo': 1,
'bar': 2
},
'target': succeeder._target,
'tries': 3
}
async def test_on_predicate_success():
log, log_success, log_backoff, log_giveup = _log_hdlrs()
@backoff.on_predicate(backoff.constant,
on_success=log_success,
on_backoff=log_backoff,
on_giveup=log_giveup,
jitter=None,
interval=0)
@_save_target
async def success(*args, **kwargs):
# succeed after we've backed off twice
return len(log['backoff']) == 2
await success(1, 2, 3, foo=1, bar=2)
# we try 3 times, backing off twice before succeeding
assert len(log['success']) == 1
assert len(log['backoff']) == 2
assert len(log['giveup']) == 0
for i in range(2):
details = log['backoff'][i]
elapsed = details.pop('elapsed')
assert isinstance(elapsed, float)
assert details == {
'args': (1, 2, 3),
'kwargs': {
'foo': 1,
'bar': 2
},
'target': success._target,
'tries': i + 1,
'value': False,
'wait': 0
}
details = log['success'][0]
elapsed = details.pop('elapsed')
assert isinstance(elapsed, float)
assert details == {
'args': (1, 2, 3),
'kwargs': {
'foo': 1,
'bar': 2
},
'target': success._target,
'tries': 3,
'value': True
}
def test_on_predicate_success():
log, log_success, log_backoff, log_giveup = _log_hdlrs()
@backoff.on_predicate(backoff.constant,
on_success=log_success,
on_backoff=log_backoff,
on_giveup=log_giveup,
jitter=lambda: 0,
interval=0)
@_save_target
@asyncio.coroutine
def success(*args, **kwargs):
# succeed after we've backed off twice
return len(log['backoff']) == 2
yield from success(1, 2, 3, foo=1, bar=2)
# we try 3 times, backing off twice before succeeding
assert len(log['success']) == 1
assert len(log['backoff']) == 2
assert len(log['giveup']) == 0
for i in range(2):
details = log['backoff'][i]
assert details == {
'args': (1, 2, 3),
'kwargs': {
'foo': 1,
'bar': 2
},
'target': success._target,
'tries': i + 1,
'value': False,
'wait': 0
}
details = log['success'][0]
assert details == {
'args': (1, 2, 3),
'kwargs': {
'foo': 1,
'bar': 2
},
'target': success._target,
'tries': 3,
'value': True
}
async def test_on_predicate_success_0_arg_jitter(monkeypatch):
monkeypatch.setattr('asyncio.sleep', asyncio.coroutine(lambda x: None))
monkeypatch.setattr('random.random', lambda: 0)
log, log_success, log_backoff, log_giveup = _log_hdlrs()
@backoff.on_predicate(backoff.constant,
on_success=log_success,
on_backoff=log_backoff,
on_giveup=log_giveup,
jitter=random.random,
interval=0)
@_save_target
async def success(*args, **kwargs):
# succeed after we've backed off twice
return len(log['backoff']) == 2
with pytest.deprecated_call():
await success(1, 2, 3, foo=1, bar=2)
# we try 3 times, backing off twice before succeeding
assert len(log['success']) == 1
assert len(log['backoff']) == 2
assert len(log['giveup']) == 0
for i in range(2):
details = log['backoff'][i]
elapsed = details.pop('elapsed')
assert isinstance(elapsed, float)
assert details == {'args': (1, 2, 3),
'kwargs': {'foo': 1, 'bar': 2},
'target': success._target,
'tries': i + 1,
'value': False,
'wait': 0}
details = log['success'][0]
elapsed = details.pop('elapsed')
assert isinstance(elapsed, float)
assert details == {'args': (1, 2, 3),
'kwargs': {'foo': 1, 'bar': 2},
'target': success._target,
'tries': 3,
'value': True}
async def test_on_predicate_success():
log, log_success, log_backoff, log_giveup = _log_hdlrs()
@backoff.on_predicate(backoff.constant,
on_success=log_success,
on_backoff=log_backoff,
on_giveup=log_giveup,
jitter=None,
interval=0)
@_save_target
async def success(*args, **kwargs):
# succeed after we've backed off twice
return len(log['backoff']) == 2
await success(1, 2, 3, foo=1, bar=2)
# we try 3 times, backing off twice before succeeding
assert len(log['success']) == 1
assert len(log['backoff']) == 2
assert len(log['giveup']) == 0
for i in range(2):
details = log['backoff'][i]
elapsed = details.pop('elapsed')
assert isinstance(elapsed, float)
assert details == {'args': (1, 2, 3),
'kwargs': {'foo': 1, 'bar': 2},
'target': success._target,
'tries': i + 1,
'value': False,
'wait': 0}
details = log['success'][0]
elapsed = details.pop('elapsed')
assert isinstance(elapsed, float)
assert details == {'args': (1, 2, 3),
'kwargs': {'foo': 1, 'bar': 2},
'target': success._target,
'tries': 3,
'value': True}
async def test_on_exception_success():
log, log_success, log_backoff, log_giveup = _log_hdlrs()
@backoff.on_exception(backoff.constant,
Exception,
on_success=log_success,
on_backoff=log_backoff,
on_giveup=log_giveup,
jitter=None,
interval=0)
@_save_target
async def succeeder(*args, **kwargs):
# succeed after we've backed off twice
if len(log['backoff']) < 2:
raise ValueError("catch me")
await succeeder(1, 2, 3, foo=1, bar=2)
# we try 3 times, backing off twice before succeeding
assert len(log['success']) == 1
assert len(log['backoff']) == 2
assert len(log['giveup']) == 0
for i in range(2):
details = log['backoff'][i]
elapsed = details.pop('elapsed')
assert isinstance(elapsed, float)
assert details == {'args': (1, 2, 3),
'kwargs': {'foo': 1, 'bar': 2},
'target': succeeder._target,
'tries': i + 1,
'wait': 0}
details = log['success'][0]
elapsed = details.pop('elapsed')
assert isinstance(elapsed, float)
assert details == {'args': (1, 2, 3),
'kwargs': {'foo': 1, 'bar': 2},
'target': succeeder._target,
'tries': 3}
