def test_if_activation_activate(self):
flow_task_mock = mock.Mock(spec=flow.If(lambda act: True))
flow_task_mock._outgoing = mock.Mock(return_value=[])
prev_activation_mock = mock.Mock(spec=activation.StartActivation())
act = gates.IfActivation.activate(flow_task_mock, prev_activation_mock,
Token('start'))
act.task.save.assert_has_calls(())
def test_view_activation_activate(self):
flow_task_mock = mock.Mock(
spec=flow.View(lambda *args, **kwargs: None))
flow_task_mock._outgoing = mock.Mock(return_value=[])
prev_activation_mock = mock.Mock(spec=activation.StartActivation())
act = activation.TaskActivation.activate(flow_task_mock,
prev_activation_mock,
Token('start'))
act.task.save.assert_has_calls(())
def test_switch_activation_activate(self):
flow_task_mock = mock.Mock(spec=flow.Split())
flow_task_mock._outgoing = mock.Mock(return_value=[])
type(flow_task_mock).branches = mock.PropertyMock(
return_value=[(mock.Mock(), lambda p: True)])
prev_activation_mock = mock.Mock(spec=activation.StartActivation())
act = gates.SplitActivation.activate(flow_task_mock,
prev_activation_mock,
Token('start'))
act.task.save.assert_has_calls(())
def test_job_activation_activate(self):
flow_task_mock = mock.Mock(
spec=celery.Job(lambda *args, **kwargs: None))
flow_task_mock._outgoing = mock.Mock(return_value=[])
prev_activation_mock = mock.Mock(spec=activation.StartActivation())
with mock.patch('viewflow.contrib.celery.get_task_ref'):
act = celery.JobActivation.activate(flow_task_mock,
prev_activation_mock,
Token('start'))
act.task.save.assert_has_calls(())
self.assertEqual(1, flow_task_mock.job.apply_async.call_count)
def test_start_activation_lifecycle(self):
flow_task_mock = mock.Mock(spec=flow.Start())
flow_task_mock._outgoing = mock.Mock(return_value=[])
act = activation.StartActivation()
act.initialize(flow_task_mock)
act.prepare()
act.done()
act.task.prepare.assert_called_once_with()
act.task.done.assert_called_once_with()
act.process.start.assert_called_once_with()
flow_task_mock._outgoing.assert_any_call()
def test_job_activation_lifecycle(self):
flow_task_mock = mock.Mock(
spec=celery.Job(lambda *args, **kwargs: None))
flow_task_mock._outgoing = mock.Mock(return_value=[])
task_mock = mock.Mock(spec=Task())
act = celery.JobActivation()
act.initialize(flow_task_mock, task_mock)
act.prepare()
act.start()
act.done(result=None)
act.task.done.assert_called_once_with()
flow_task_mock._outgoing.assert_any_call()
def test_view_activation_lifecycle(self):
flow_task_mock = mock.Mock(
spec=flow.View(lambda *args, **kwargs: None))
flow_task_mock._outgoing = mock.Mock(return_value=[])
task_mock = mock.Mock(spec=Task())
act = activation.TaskActivation()
act.initialize(flow_task_mock, task_mock)
act.prepare()
act.done()
act.task.prepare.assert_called_once_with()
act.task.done.assert_called_once_with()
flow_task_mock._outgoing.assert_any_call()
class ProcessStub(object):
_default_manager = mock.Mock()
def __init__(self, *args, **kwargs):
pass
def save(self):
pass
def test_failed_activate_next(self):
job_task_mock = mock.Mock(spec=Task())
gate_task_mock = mock.Mock(spec=Task())
next_flow_task_mock = mock.Mock()
next_flow_task_mock.flow_cls.task_cls = mock.Mock(
return_value=gate_task_mock)
next_flow_task_mock.dst.activate = \
lambda prev_activation, token: activation.GateActivation().activate(next_flow_task_mock, prev_activation, token) # NOQA
flow_task_mock = mock.MagicMock(spec=celery.Job(lambda p: None))
flow_task_mock.flow_cls.task_cls.objects.get = mock.Mock(
return_value=job_task_mock)
flow_task_mock.activation_cls = mock.Mock(
return_value=celery.JobActivation())
flow_task_mock._outgoing = mock.Mock(
return_value=[next_flow_task_mock])
with mock.patch('viewflow.flow.job.import_task_by_ref',
return_value=flow_task_mock):
successful_job(flow_task_strref='unit/TestFlow.job',
process_pk=-1,
task_pk=-1)
job_task_mock.prepare.assert_called_once_with()
job_task_mock.start.assert_called_once_with()
job_task_mock.done.assert_called_once_with()
self.assertFalse(job_task_mock.error.called)
gate_task_mock.prepare.assert_called_once_with()
gate_task_mock.error.assert_called_once_with()
self.assertFalse(gate_task_mock.done.called)
def test_failed_job(self):
task_mock = mock.Mock(spec=Task())
flow_task_mock = mock.MagicMock(spec=celery.Job(lambda p: None))
flow_task_mock.flow_cls.task_cls.objects.get = mock.Mock(
return_value=task_mock)
flow_task_mock.activation_cls = mock.Mock(
return_value=celery.JobActivation())
with mock.patch('viewflow.flow.job.import_task_by_ref',
return_value=flow_task_mock):
with self.assertRaises(NotImplementedError):
failure_job(flow_task_strref='unit/TestFlow.job',
process_pk=-1,
task_pk=-1)
task_mock.prepare.assert_called_once_with()
task_mock.start.assert_called_once_with()
task_mock.error.assert_called_once_with()
self.assertFalse(task_mock.done.called)
class ProcessStub(object):
_default_manager = mock.Mock()
def __init__(self, flow_cls=None):
self.flow_cls = flow_cls
def active_tasks(self):
return []
def save(self):
return
class TaskStub(object):
_default_manager = mock.Mock()
def __init__(self, flow_task=None):
self.flow_task = flow_task
self.process_id = 1
self.pk = 1
self.status = STATUS.NEW
@property
def leading(self):
from viewflow.models import Task
return Task.objects.none()
def save(self):
return
def test_join_activation_activate(self):
prev_task_mock = mock.Mock(spec=Task())
prev_task_mock.token = Token('start/1_2')
task_mock = mock.Mock(spec=Task())
task_mock.previous.all = mock.Mock(return_value=[prev_task_mock])
flow_task_mock = mock.Mock(spec=flow.Join())
flow_task_mock._outgoing = mock.Mock(return_value=[])
flow_task_mock.flow_cls.task_cls = mock.Mock(return_value=task_mock)
flow_task_mock.flow_cls.task_cls._default_manager.filter = mock.Mock(
return_value=Task.objects.none())
prev_activation_mock = mock.Mock(spec=activation.StartActivation())
act = gates.JoinActivation.activate(flow_task_mock,
prev_activation_mock,
Token('start'))
act.task.save.assert_has_calls(())
flow_task_mock._outgoing.assert_any_call()
def test_end_activation_activate(self):
active_task_mock = mock.Mock()
process_mock = mock.Mock(spec=Process())
process_mock.active_tasks = mock.Mock(return_value=[active_task_mock])
flow_task_mock = mock.Mock(spec=flow.End())
flow_task_mock._outgoing = mock.Mock(return_value=[])
flow_task_mock.flow_cls.process_cls._default_manager.get = mock.Mock(
return_value=process_mock)
prev_activation_mock = mock.Mock(spec=activation.StartActivation())
act = activation.EndActivation.activate(flow_task_mock,
prev_activation_mock,
Token('start'))
act.task.save.assert_has_calls(())
act.process.finish.assert_has_calls(())
active_task_mock.flow_task.deactivate.assert_called_once_with(mock.ANY)
