def test_instantiate_fail(base_task_class, _failed):
mocked_task = mock.MagicMock()
exc = Exception('test')
mocked_task.side_effect = exc
ptask = mod.PackagedTask(mocked_task)
assert ptask.instantiate() is None
_failed.assert_called_once_with(None, exc)
def test_run_failed_execution(base_task_class, instantiate, _failed):
mocked_task = mock.MagicMock()
task_instance = instantiate.return_value
exc = Exception("test")
task_instance.side_effect = exc
ptask = mod.PackagedTask(mocked_task)
assert ptask.run() is _failed.return_value
_failed.assert_called_once_with(task_instance, exc)
def test__retry_success(base_task_class):
ptask = mod.PackagedTask(mock.Mock())
task_instance = mock.Mock()
retry_delay = task_instance.get_retry_delay.return_value
assert ptask._retry(task_instance) == dict(delay=retry_delay)
task_instance.get_retry_delay.assert_called_once_with(None, 0)
assert ptask._previous_retry_delay == retry_delay
assert ptask._retry_count == 1
assert ptask._status == mod.PackagedTask.RETRY
def test__reschedule_success(base_task_class):
ptask = mod.PackagedTask(mock.Mock())
ptask._retry_count = 3
task_instance = mock.Mock()
delay = task_instance.get_delay.return_value
assert ptask._reschedule(task_instance) == dict(delay=delay)
task_instance.get_delay.assert_called_once_with(None)
assert ptask._previous_delay == delay
assert ptask._status == mod.PackagedTask.SCHEDULED
assert ptask._retry_count == 0
def test_run_finished(base_task_class, instantiate, _finished):
args = (1, 2)
kwargs = dict(a=3, b=4)
mocked_task = mock.MagicMock()
task_instance = instantiate.return_value
ptask = mod.PackagedTask(mocked_task, args, kwargs)
assert ptask.run() is _finished.return_value
task_instance.assert_called_once_with(*args, **kwargs)
_finished.assert_called_once_with(task_instance,
task_instance.return_value)
def test__failed_instantiation(future_class, base_task_class, _retry):
result = future_class.return_value
mocked_task = mock.Mock()
errback = mock.Mock()
mocked_exc = mock.Mock()
ptask = mod.PackagedTask(mocked_task, errback=errback)
assert ptask._failed(None, mocked_exc) == {}
result.set_exception.assert_called_once_with(mocked_exc)
errback.assert_called_once_with(mocked_exc)
assert ptask.status == mod.PackagedTask.FAILED
assert not _retry.called
def test__failed_execution(future_class, base_task_class, _retry):
result = future_class.return_value
mocked_task = mock.Mock()
task_instance = mocked_task.return_value
errback = mock.Mock()
mocked_exc = mock.Mock()
ptask = mod.PackagedTask(mocked_task, errback=errback)
assert ptask._failed(task_instance, mocked_exc) == _retry.return_value
result.set_exception.assert_called_once_with(mocked_exc)
errback.assert_called_once_with(mocked_exc)
assert ptask.status == mod.PackagedTask.FAILED
_retry.assert_called_once_with(task_instance)
def test__finished(future_class, base_task_class, _reschedule):
result = future_class.return_value
mocked_task = mock.Mock()
task_instance = mocked_task.return_value
callback = mock.Mock()
ret_val = mock.Mock()
ptask = mod.PackagedTask(mocked_task, callback=callback)
ptask._finished(task_instance, ret_val)
result.set.assert_called_once_with(ret_val)
callback.assert_called_once_with(ret_val)
assert ptask.status == mod.PackagedTask.FINISHED
_reschedule.assert_called_once_with(task_instance)
def test_init_with_non_base_task_subclass(is_descendant, from_callable):
task = mock.Mock()
is_descendant.return_value = False
mod.PackagedTask(task,
delay=10,
periodic=True,
retry_delay=5,
max_retries=3)
from_callable.assert_called_once_with(task,
delay=10,
periodic=True,
retry_delay=5,
max_retries=3)
def test__retry_exceeded(base_task_class, _reschedule):
ptask = mod.PackagedTask(mock.Mock())
ptask._previous_retry_delay = 10
ptask._retry_count = 2
ptask._status = mod.PackagedTask.FAILED
task_instance = mock.Mock()
task_instance.get_retry_delay.return_value = None
assert ptask._retry(task_instance) is _reschedule.return_value
task_instance.get_retry_delay.assert_called_once_with(10, 2)
_reschedule.assert_called_once_with(task_instance)
assert ptask._previous_retry_delay is None
# make sure state is not changed
assert ptask._retry_count == 2
assert ptask._status == mod.PackagedTask.FAILED
def test_init_with_base_task_subclass(is_descendant, from_callable):
task = mock.Mock()
is_descendant.return_value = True
mod.PackagedTask(task)
assert not from_callable.called
def test___str__(base_task_class, _generate_task_id):
mocked_task = mock.Mock()
mocked_task.get_name.return_value = 'AwesomeTask'
_generate_task_id.return_value = 123
ptask = mod.PackagedTask(mocked_task)
assert unicode(ptask) == '<PackagedTask: 123 - AwesomeTask>'
def test___eq__(base_task_class):
ptask1 = mod.PackagedTask(mock.Mock())
ptask2 = mod.PackagedTask(mock.Mock())
assert ptask1 == ptask1
assert ptask2 == ptask2
assert ptask1 != ptask2
def test___hash__(base_task_class, _generate_task_id):
_generate_task_id.return_value = 123456789
ptask = mod.PackagedTask(mock.Mock())
assert hash(ptask) == 123456789
def test_packaged_task_status(base_task_class):
ptask = mod.PackagedTask(mock.Mock())
assert ptask.status == mod.PackagedTask.SCHEDULED
def test_run_failed_instantiation(base_task_class, instantiate):
mocked_task = mock.MagicMock()
instantiate.return_value = None
ptask = mod.PackagedTask(mocked_task)
assert ptask.run() == {}
def test_instantiate_success(base_task_class):
mocked_task = mock.MagicMock()
ptask = mod.PackagedTask(mocked_task)
assert ptask.instantiate() == mocked_task.return_value
def test__reschedule_fail(base_task_class):
ptask = mod.PackagedTask(mock.Mock())
task_instance = mock.Mock()
task_instance.get_delay.side_effect = Exception('test')
assert ptask._reschedule(task_instance) == dict(delay=None)
task_instance.get_delay.assert_called_once_with(None)
def test_packaged_task_name(base_task_class):
mocked_task = mock.MagicMock()
ptask = mod.PackagedTask(mocked_task)
assert ptask.name == mocked_task.get_name.return_value
def test__reschedule_not_needed(base_task_class):
ptask = mod.PackagedTask(mock.Mock())
task_instance = mock.Mock()
task_instance.periodic = False
assert ptask._reschedule(task_instance) == dict(delay=None)
assert not task_instance.get_delay.called
