def test_parse_xml_content(self):
"""Test WebDAVResponse._parse_xml_content."""
response = Mock.Response()
response.content = MULTISTATUS
response.status = 207
with replaced(WebDAVResponse, _parse_xml_content=Mock.omnivore_func()):
davresponse = WebDAVResponse(response)
davresponse._parse_xml_content()
href = davresponse._etree.findtext("/{DAV:}response/{DAV:}href")
self.assertEquals(href, "/3/38/38f/38fa476aa97a4b2baeb41a481fdca00b")
def test_parse_xml_content_broken(self):
"""Test WebDAVResponse._parse_xml_content with broken XML."""
response = Mock.Response()
response.content = MULTISTATUS_BROKEN
response.status = 207
with replaced(WebDAVResponse, _parse_xml_content=Mock.omnivore_func()):
davresponse = WebDAVResponse(response)
davresponse._parse_xml_content()
empty = davresponse._etree.getroot().getchildren()[0]
self.assertEquals(empty.tag, "empty")
def test_receive_message_eta(self):
if os.environ.get('C_DEBUG_TEST'):
pp = partial(print, file=sys.__stderr__)
else:
def pp(*args, **kwargs):
pass
pp('TEST RECEIVE MESSAGE ETA')
pp('+CREATE MYKOMBUCONSUMER')
c = self.LoopConsumer()
pp('-CREATE MYKOMBUCONSUMER')
c.steps.pop()
channel = Mock(name='channel')
pp('+ CREATE MESSAGE')
m = self.create_task_message(
channel,
self.foo_task.name,
args=[2, 4, 8],
kwargs={},
eta=(datetime.now() + timedelta(days=1)).isoformat(),
)
pp('- CREATE MESSAGE')
try:
pp('+ BLUEPRINT START 1')
c.blueprint.start(c)
pp('- BLUEPRINT START 1')
p = c.app.conf.broker_connection_retry
c.app.conf.broker_connection_retry = False
pp('+ BLUEPRINT START 2')
c.blueprint.start(c)
pp('- BLUEPRINT START 2')
c.app.conf.broker_connection_retry = p
pp('+ BLUEPRINT RESTART')
c.blueprint.restart(c)
pp('- BLUEPRINT RESTART')
pp('+ GET ON MESSAGE')
callback = self._get_on_message(c)
pp('- GET ON MESSAGE')
pp('+ CALLBACK')
callback(m)
pp('- CALLBACK')
finally:
pp('+ STOP TIMER')
c.timer.stop()
pp('- STOP TIMER')
try:
pp('+ JOIN TIMER')
c.timer.join()
pp('- JOIN TIMER')
except RuntimeError:
pass
in_hold = c.timer.queue[0]
assert len(in_hold) == 3
eta, priority, entry = in_hold
task = entry.args[0]
assert isinstance(task, Request)
assert task.name == self.foo_task.name
assert task.execute() == 2 * 4 * 8
with pytest.raises(Empty):
self.buffer.get_nowait()
def NoopConsumer(self, *args, **kwargs):
c = self.LoopConsumer(*args, **kwargs)
c.loop = Mock(name='.loop')
return c
def test_Pool_pool_no_sem(self):
w = Mock()
w.pool_cls.uses_semaphore = False
components.Pool(w).create(w)
assert w.process_task is w._process_task
def test_release_no__debug(self):
P = self.create_resource(10)
R = Mock()
R._debug.side_effect = AttributeError()
P.release_resource(R)
def test_heartbeat_check(self):
c = Connection(transport=Transport)
c.transport.heartbeat_check = Mock()
c.heartbeat_check(3)
c.transport.heartbeat_check.assert_called_with(c.connection, rate=3)
def test_set_immutable(self):
x = chord([Mock(name='t1'), Mock(name='t2')], app=self.app)
x.set_immutable(True)
def test_on_success__no_events(self):
self.eventer = None
job = self.zRequest(id=uuid())
job.send_event = Mock(name='send_event')
job.on_success((False, 'foo', 1.0))
job.send_event.assert_not_called()
def test_on_success__acks_late_disabled(self):
self.task.acks_late = False
job = self.zRequest(id=uuid())
job.acknowledge = Mock(name='ack')
job.on_success((False, 'foo', 1.0))
job.acknowledge.assert_not_called()
def test_on_success__calls_failure(self):
job = self.zRequest(id=uuid())
einfo = Mock(name='einfo')
job.on_failure = Mock(name='on_failure')
job.on_success((True, einfo, 1.0))
job.on_failure.assert_called_with(einfo, return_ok=True)
def setup(self):
self.task = Mock(name='task')
self.pool = Mock(name='pool')
self.eventer = Mock(name='eventer')
RequestCase.setup(self)
class test_create_request_class(RequestCase):
def setup(self):
self.task = Mock(name='task')
self.pool = Mock(name='pool')
self.eventer = Mock(name='eventer')
RequestCase.setup(self)
def create_request_cls(self, **kwargs):
return create_request_cls(
Request, self.task, self.pool, 'foo', self.eventer, **kwargs
)
def zRequest(self, Request=None, revoked_tasks=None, ref=None, **kwargs):
return self.xRequest(
Request=Request or self.create_request_cls(
ref=ref,
revoked_tasks=revoked_tasks,
),
**kwargs)
def test_on_success(self):
self.zRequest(id=uuid()).on_success((False, 'hey', 3.1222))
def test_on_success__SystemExit(self,
errors=(SystemExit, KeyboardInterrupt)):
for exc in errors:
einfo = None
try:
raise exc()
except exc:
einfo = ExceptionInfo()
with pytest.raises(exc):
self.zRequest(id=uuid()).on_success((True, einfo, 1.0))
def test_on_success__calls_failure(self):
job = self.zRequest(id=uuid())
einfo = Mock(name='einfo')
job.on_failure = Mock(name='on_failure')
job.on_success((True, einfo, 1.0))
job.on_failure.assert_called_with(einfo, return_ok=True)
def test_on_success__acks_late_enabled(self):
self.task.acks_late = True
job = self.zRequest(id=uuid())
job.acknowledge = Mock(name='ack')
job.on_success((False, 'foo', 1.0))
job.acknowledge.assert_called_with()
def test_on_success__acks_late_disabled(self):
self.task.acks_late = False
job = self.zRequest(id=uuid())
job.acknowledge = Mock(name='ack')
job.on_success((False, 'foo', 1.0))
job.acknowledge.assert_not_called()
def test_on_success__no_events(self):
self.eventer = None
job = self.zRequest(id=uuid())
job.send_event = Mock(name='send_event')
job.on_success((False, 'foo', 1.0))
job.send_event.assert_not_called()
def test_on_success__with_events(self):
job = self.zRequest(id=uuid())
job.send_event = Mock(name='send_event')
job.on_success((False, 'foo', 1.0))
job.send_event.assert_called_with(
'task-succeeded', result='foo', runtime=1.0,
)
def test_execute_using_pool__revoked(self):
tid = uuid()
job = self.zRequest(id=tid, revoked_tasks={tid})
job.revoked = Mock()
job.revoked.return_value = True
with pytest.raises(TaskRevokedError):
job.execute_using_pool(self.pool)
def test_execute_using_pool__expired(self):
tid = uuid()
job = self.zRequest(id=tid, revoked_tasks=set())
job.expires = 1232133
job.revoked = Mock()
job.revoked.return_value = True
with pytest.raises(TaskRevokedError):
job.execute_using_pool(self.pool)
def test_execute_using_pool(self):
from celery.app.trace import trace_task_ret as trace
weakref_ref = Mock(name='weakref.ref')
job = self.zRequest(id=uuid(), revoked_tasks=set(), ref=weakref_ref)
job.execute_using_pool(self.pool)
self.pool.apply_async.assert_called_with(
trace,
args=(job.type, job.id, job.request_dict, job.body,
job.content_type, job.content_encoding),
accept_callback=job.on_accepted,
timeout_callback=job.on_timeout,
callback=job.on_success,
error_callback=job.on_failure,
soft_timeout=self.task.soft_time_limit,
timeout=self.task.time_limit,
correlation_id=job.id,
)
assert job._apply_result
weakref_ref.assert_called_with(self.pool.apply_async())
assert job._apply_result is weakref_ref()
def test_execute_using_pool_with_none_timelimit_header(self):
from celery.app.trace import trace_task_ret as trace
weakref_ref = Mock(name='weakref.ref')
job = self.zRequest(id=uuid(),
revoked_tasks=set(),
ref=weakref_ref,
headers={'timelimit': None})
job.execute_using_pool(self.pool)
self.pool.apply_async.assert_called_with(
trace,
args=(job.type, job.id, job.request_dict, job.body,
job.content_type, job.content_encoding),
accept_callback=job.on_accepted,
timeout_callback=job.on_timeout,
callback=job.on_success,
error_callback=job.on_failure,
soft_timeout=self.task.soft_time_limit,
timeout=self.task.time_limit,
correlation_id=job.id,
)
assert job._apply_result
weakref_ref.assert_called_with(self.pool.apply_async())
assert job._apply_result is weakref_ref()
def test_execute_using_pool__defaults_of_hybrid_to_proto2(self):
weakref_ref = Mock(name='weakref.ref')
headers = strategy.hybrid_to_proto2('', {'id': uuid(),
'task': self.mytask.name})[1]
job = self.zRequest(revoked_tasks=set(), ref=weakref_ref, **headers)
job.execute_using_pool(self.pool)
assert job._apply_result
weakref_ref.assert_called_with(self.pool.apply_async())
assert job._apply_result is weakref_ref()
def test_delete(self):
self.app.conf.arangodb_backend_settings = {}
x = ArangoDbBackend(app=self.app)
x.delete = Mock()
x.delete.return_value = None
assert x.delete('1f3fab') is None
def test_get(self):
index = 100
data = {'Key': 'test-consul-1', 'Value': 'mypayload'}
self.backend.client = Mock(name='c.client')
self.backend.client.kv.get.return_value = (index, data)
assert self.backend.get(data['Key']) == 'mypayload'
def setup(self):
self.connection = Mock(name='connection')
def test_app_fallback_to_current(self):
from celery._state import current_app
t1 = Mock(name='t1')
t1.app = t1._app = None
x = chord([t1], body=t1)
assert x.app is current_app
def test_process_cleanup_BaseException(self):
self.mytask.backend = Mock()
self.mytask.backend.process_cleanup = Mock(side_effect=SystemExit())
with pytest.raises(SystemExit):
jail(self.app, uuid(), self.mytask.name, [2], {})
def test_call(self):
x = Signature('foo', (1, 2), {'arg1': 33}, app=self.app)
x.type = Mock(name='type')
x(3, 4, arg2=66)
x.type.assert_called_with(3, 4, 1, 2, arg1=33, arg2=66)
def test_on_retry_acks_if_late(self):
self.add.acks_late = True
req = self.get_request(self.add.s(2, 2))
req.on_retry(Mock())
req.on_ack.assert_called_with(req_logger, req.connection_errors)
def test_close_when_default_channel(self):
conn = self.conn
conn._default_channel = Mock()
conn._close()
conn._default_channel.close.assert_called_with()
def test_send_event(self):
job = self.xRequest()
job.eventer = Mock(name='.eventer')
job.send_event('task-frobulated')
job.eventer.send.assert_called_with('task-frobulated', uuid=job.id)
def test_Hub_create(self):
w = Mock()
x = components.Hub(w)
x.create(w)
assert w.timer.max_interval
def test_send_events__disabled_at_task_level(self):
job = self.xRequest()
job.task.send_events = False
job.eventer = Mock(name='.eventer')
job.send_event('task-frobulated')
job.eventer.send.assert_not_called()
def timers(self):
return {Mock(): 30}
def test_call_with_tasks(self):
x = self.add.s(2, 2) | self.add.s(4)
x.apply_async = Mock()
x(2, 2, foo=1)
x.apply_async.assert_called_with((2, 2), {'foo': 1})
def mock_event_dispatcher():
evd = Mock(name='event_dispatcher')
evd.groups = ['worker']
evd._outbound_buffer = deque()
return evd
def test_set_immutable(self):
g1 = group(Mock(name='t1'), Mock(name='t2'), app=self.app)
g1.set_immutable(True)
for task in g1.tasks:
task.set_immutable.assert_called_with(True)
def test_reset_pidbox_node_green(self):
c = self.NoopConsumer(pool=Mock(is_green=True))
con = find_step(c, consumer.Control)
assert isinstance(con.box, gPidbox)
con.start(c)
c.pool.spawn_n.assert_called_with(con.box.loop, c)
def test_link_error(self):
g1 = group(Mock(name='t1'), Mock(name='t2'), app=self.app)
sig = Mock(name='sig')
g1.link_error(sig)
g1.tasks[0].link_error.assert_called_with(
sig.clone().set(immutable=True), )
def test_app_when_app(self):
app = Mock(name='app')
x = chord([self.add.s(4, 4)], app=app)
assert x.app is app
def __init__(self,
app,
heartbeat=None,
on_task_message=None,
transport_driver_type=None):
hub = Hub()
(
self.obj,
self.connection,
self.consumer,
self.blueprint,
self.hub,
self.qos,
self.heartbeat,
self.clock,
) = self.args = [
Mock(name='obj'),
Mock(name='connection'),
Mock(name='consumer'),
Mock(name='blueprint'), hub,
Mock(name='qos'), heartbeat,
Mock(name='clock')
]
self.connection.supports_heartbeats = True
self.connection.get_heartbeat_interval.side_effect = (
lambda: self.heartbeat)
self.consumer.callbacks = []
self.obj.strategies = {}
self.connection.connection_errors = (socket.error, )
if transport_driver_type:
self.connection.transport.driver_type = transport_driver_type
self.hub.readers = {}
self.hub.timer = Mock(name='hub.timer')
self.hub.timer._queue = [Mock()]
self.hub.fire_timers = Mock(name='hub.fire_timers')
self.hub.fire_timers.return_value = 1.7
self.hub.poller = Mock(name='hub.poller')
self.hub.close = Mock(name='hub.close()') # asynloop calls hub.close
self.Hub = self.hub
self.blueprint.state = RUN
# need this for create_task_handler
self._consumer = _consumer = Consumer(Mock(),
timer=Mock(),
controller=Mock(),
app=app)
_consumer.on_task_message = on_task_message or []
self.obj.create_task_handler = _consumer.create_task_handler
self.on_unknown_message = self.obj.on_unknown_message = Mock(
name='on_unknown_message', )
_consumer.on_unknown_message = self.on_unknown_message
self.on_unknown_task = self.obj.on_unknown_task = Mock(
name='on_unknown_task', )
_consumer.on_unknown_task = self.on_unknown_task
self.on_invalid_task = self.obj.on_invalid_task = Mock(
name='on_invalid_task', )
_consumer.on_invalid_task = self.on_invalid_task
_consumer.strategies = self.obj.strategies
