def test_fire_timers_raises(self):
eback = Mock()
eback.side_effect = KeyError('foo')
self.hub.timer = Mock()
self.hub.scheduler = iter([(0, eback)])
with pytest.raises(KeyError):
self.hub.fire_timers(propagate=(KeyError,))
eback.side_effect = ValueError('foo')
self.hub.scheduler = iter([(0, eback)])
with patch('kombu.asynchronous.hub.logger') as logger:
with pytest.raises(StopIteration):
self.hub.fire_timers()
logger.error.assert_called()
eback.side_effect = MemoryError('foo')
self.hub.scheduler = iter([(0, eback)])
with pytest.raises(MemoryError):
self.hub.fire_timers()
eback.side_effect = OSError()
eback.side_effect.errno = errno.ENOMEM
self.hub.scheduler = iter([(0, eback)])
with pytest.raises(OSError):
self.hub.fire_timers()
eback.side_effect = OSError()
eback.side_effect.errno = errno.ENOENT
self.hub.scheduler = iter([(0, eback)])
with patch('kombu.asynchronous.hub.logger') as logger:
with pytest.raises(StopIteration):
self.hub.fire_timers()
logger.error.assert_called()
def test_apply_timeout(self):
self.patching.modules(*gevent_modules)
class Timeout(Exception):
value = None
def __init__(self, value):
self.__class__.value = value
def __enter__(self):
return self
def __exit__(self, *exc_info):
pass
timeout_callback = Mock(name='timeout_callback')
apply_target = Mock(name='apply_target')
apply_timeout(
Mock(), timeout=10, callback=Mock(name='callback'),
timeout_callback=timeout_callback,
apply_target=apply_target, Timeout=Timeout,
)
assert Timeout.value == 10
apply_target.assert_called()
apply_target.side_effect = Timeout(10)
apply_timeout(
Mock(), timeout=10, callback=Mock(),
timeout_callback=timeout_callback,
apply_target=apply_target, Timeout=Timeout,
)
timeout_callback.assert_called_with(False, 10)
def passthrough(*args, **kwargs):
m = Mock(*args, **kwargs)
def side_effect(ret):
return ret
m.side_effect = side_effect
return m
def test_apply_target__raises_BaseException_raises_else(self, reraise):
target = Mock(name='target')
callback = Mock(name='callback')
reraise.side_effect = KeyError()
target.side_effect = BaseException()
with pytest.raises(KeyError):
apply_target(target, callback=callback)
callback.assert_not_called()
def closer(self, mock=None, mod=0):
mock = Mock() if mock is None else mock
def closing(*args, **kwargs):
if not mod or mock.call_count >= mod:
self.close()
mock.side_effect = closing
return mock
def test_apply_entry_error_handled(self, logger):
t = Timer()
t.schedule.on_error = None
fun = Mock()
fun.side_effect = ValueError()
t.schedule.apply_entry(fun)
logger.error.assert_called()
def close_then_error(self, mock=None, mod=0, exc=None):
mock = Mock() if mock is None else mock
def first(*args, **kwargs):
if not mod or mock.call_count > mod:
self.close()
raise (socket.error() if exc is None else exc)
mock.side_effect = first
return mock
def test_apply_entry_error_not_handled(self, stdouts):
t = Timer()
t.schedule.on_error = Mock()
fun = Mock()
fun.side_effect = ValueError()
t.schedule.apply_entry(fun)
fun.assert_called_with()
assert not stdouts.stderr.getvalue()
def test_poll_readable_raises_Empty(self):
x = X(self.app)
reader = Mock(name='reader')
x.hub.add_reader(6, reader, 6)
x.hub.on_tick.add(x.close_then_error(Mock(name='tick'), 2))
poller = x.hub.poller
poller.poll.return_value = [(6, READ)]
reader.side_effect = Empty()
with pytest.raises(socket.error):
asynloop(*x.args)
reader.assert_called_with(6)
poller.poll.assert_called()
def test_outside_body_error(self, report_internal_error, build_tracer):
tracer = Mock()
tracer.side_effect = KeyError('foo')
build_tracer.return_value = tracer
@self.app.task(shared=False)
def xtask():
pass
trace_task(xtask, 'uuid', (), {})
assert report_internal_error.call_count
assert xtask.__trace__ is tracer
def test_find_module():
def imp_side_effect(module):
if module == 'foo':
return None
else:
raise ImportError(module)
assert find_module('celery')
imp = Mock()
imp.side_effect = imp_side_effect
with pytest.raises(NotAPackage) as exc_info:
find_module('foo.bar.baz', imp=imp)
assert exc_info.value.args[0] == 'foo'
assert find_module('celery.worker.request')
def test_sync_clock_and_purge(self, p):
passthrough = Mock()
passthrough.side_effect = lambda x: x
with patch('celery.worker.state.revoked') as revoked:
d = {str('clock'): 0}
p.clock = Mock()
p.clock.forward.return_value = 627
p._dumps = passthrough
p.compress = passthrough
p._sync_with(d)
revoked.purge.assert_called_with()
assert d[str('clock')] == 627
assert str('revoked') not in d
assert d[str('zrevoked')] is revoked
def test_autoretry(self):
myfun = Mock()
self.conn.transport.connection_errors = (KeyError,)
def on_call(*args, **kwargs):
myfun.side_effect = None
raise KeyError('foo')
myfun.side_effect = on_call
insured = self.conn.autoretry(myfun)
insured()
myfun.assert_called()
def test_chained(self):
def add(x, y):
return x + y
def pow2(x):
return x ** 2
adder = Mock(name='adder')
adder.side_effect = add
power = Mock(name='multiplier')
power.side_effect = pow2
final = Mock(name='final')
p = promise()
p.then(adder).then(power).then(final)
p(42, 42)
assert p.value == ((42, 42), {})
adder.assert_called_with(42, 42)
power.assert_called_with(84)
final.assert_called_with(7056)
def test_apply_target__raises_WorkerTerminate(self):
target = Mock(name='target')
target.side_effect = WorkerTerminate()
with pytest.raises(WorkerTerminate):
apply_target(target)
def test_apply_target__propagate(self):
target = Mock(name='target')
target.side_effect = KeyError()
with pytest.raises(KeyError):
apply_target(target, propagate=(KeyError,))
def test_apply_target__raises_WorkerShutdown(self):
target = Mock(name='target')
target.side_effect = WorkerShutdown()
with pytest.raises(WorkerShutdown):
apply_target(target)
def test_apply_target__raises(self):
target = Mock(name='target')
target.side_effect = KeyError()
with pytest.raises(KeyError):
apply_target(target)
def test_loads_DecodeError(self):
_loads = Mock(name='_loads')
_loads.side_effect = _DecodeError(
MagicMock(), MagicMock(), MagicMock())
assert loads(dumps({'x': 'z'}), _loads=_loads) == {'x': 'z'}
def test_apply_target__raises_BaseException(self):
target = Mock(name='target')
callback = Mock(name='callback')
target.side_effect = BaseException()
apply_target(target, callback=callback)
callback.assert_called()
def test_imp_reraises_ValueError(self):
imp = Mock()
imp.side_effect = ValueError()
with pytest.raises(ValueError):
symbol_by_name('kombu.Connection', imp=imp)
