class ParallelMultipleSplitsTest(BpmnWorkflowTestCase):
def setUp(self):
self.spec = self.load_spec()
def load_spec(self):
return self.load_workflow_spec('Test-Workflows/Parallel-Multiple-Splits.bpmn20.xml', 'Parallel Multiple Splits')
def testRunThroughAlternating(self):
self.workflow = BpmnWorkflow(self.spec)
self.workflow.do_engine_steps()
self.assertEquals(2, len(self.workflow.get_tasks(Task.READY)))
self.do_next_named_step('Do First')
self.workflow.do_engine_steps()
self.do_next_named_step('SP 1 - Choose', choice='Yes')
self.workflow.do_engine_steps()
self.do_next_named_step('SP 2 - Choose', choice='Yes')
self.workflow.do_engine_steps()
self.do_next_named_step('SP 3 - Choose', choice='Yes')
self.workflow.do_engine_steps()
self.do_next_named_step('SP 1 - Yes Task')
self.workflow.do_engine_steps()
self.do_next_named_step('SP 2 - Yes Task')
self.workflow.do_engine_steps()
self.do_next_named_step('SP 3 - Yes Task')
self.workflow.do_engine_steps()
self.do_next_named_step('Done')
self.workflow.do_engine_steps()
self.assertEquals(0, len(self.workflow.get_tasks(Task.READY | Task.WAITING)))
class ParallelMultipleSplitsTest(BpmnWorkflowTestCase):
def setUp(self):
self.spec = self.load_spec()
def load_spec(self):
return self.load_workflow_spec("Test-Workflows/Parallel-Multiple-Splits.bpmn20.xml", "Parallel Multiple Splits")
def testRunThroughAlternating(self):
self.workflow = BpmnWorkflow(self.spec)
self.workflow.do_engine_steps()
self.assertEquals(2, len(self.workflow.get_tasks(Task.READY)))
self.do_next_named_step("Do First")
self.workflow.do_engine_steps()
self.do_next_named_step("SP 1 - Choose", choice="Yes")
self.workflow.do_engine_steps()
self.do_next_named_step("SP 2 - Choose", choice="Yes")
self.workflow.do_engine_steps()
self.do_next_named_step("SP 3 - Choose", choice="Yes")
self.workflow.do_engine_steps()
self.do_next_named_step("SP 1 - Yes Task")
self.workflow.do_engine_steps()
self.do_next_named_step("SP 2 - Yes Task")
self.workflow.do_engine_steps()
self.do_next_named_step("SP 3 - Yes Task")
self.workflow.do_engine_steps()
self.do_next_named_step("Done")
self.workflow.do_engine_steps()
self.assertEquals(0, len(self.workflow.get_tasks(Task.READY | Task.WAITING)))
class ParallelJoinLongTest(BpmnWorkflowTestCase):
def setUp(self):
self.spec = self.load_spec()
def load_spec(self):
return self.load_workflow_spec("Test-Workflows/Parallel-Join-Long.bpmn20.xml", "Parallel Join Long")
def testRunThroughAlternating(self):
self.workflow = BpmnWorkflow(self.spec)
self.workflow.do_engine_steps()
self.assertEquals(2, len(self.workflow.get_tasks(Task.READY)))
self.do_next_named_step("Thread 1 - Choose", choice="Yes", with_save_load=True)
self.workflow.do_engine_steps()
self.do_next_named_step("Thread 2 - Choose", choice="Yes", with_save_load=True)
self.workflow.do_engine_steps()
for i in range(1, 13):
self.do_next_named_step("Thread 1 - Task %d" % i, with_save_load=True)
self.workflow.do_engine_steps()
self.do_next_named_step("Thread 2 - Task %d" % i, with_save_load=True)
self.workflow.do_engine_steps()
self.do_next_named_step("Done", with_save_load=True)
self.workflow.do_engine_steps()
self.assertEquals(0, len(self.workflow.get_tasks(Task.READY | Task.WAITING)))
def testRunThroughThread1First(self):
self.workflow = BpmnWorkflow(self.spec)
self.workflow.do_engine_steps()
self.assertEquals(2, len(self.workflow.get_tasks(Task.READY)))
self.do_next_named_step("Thread 1 - Choose", choice="Yes", with_save_load=True)
self.workflow.do_engine_steps()
for i in range(1, 13):
self.do_next_named_step("Thread 1 - Task %d" % i)
self.workflow.do_engine_steps()
self.assertRaises(AssertionError, self.do_next_named_step, "Done")
self.assertEquals(1, len(self.workflow.get_tasks(Task.WAITING)))
self.do_next_named_step("Thread 2 - Choose", choice="Yes", with_save_load=True)
self.workflow.do_engine_steps()
for i in range(1, 13):
self.do_next_named_step("Thread 2 - Task %d" % i, with_save_load=True)
self.workflow.do_engine_steps()
self.do_next_named_step("Done", with_save_load=True)
self.workflow.do_engine_steps()
self.assertEquals(0, len(self.workflow.get_tasks(Task.READY | Task.WAITING)))
class ParallelJoinLongTest(BpmnWorkflowTestCase):
def setUp(self):
self.spec = self.load_spec()
def load_spec(self):
return self.load_workflow_spec('Test-Workflows/Parallel-Join-Long.bpmn20.xml', 'Parallel Join Long')
def testRunThroughAlternating(self):
self.workflow = BpmnWorkflow(self.spec)
self.workflow.do_engine_steps()
self.assertEquals(2, len(self.workflow.get_tasks(Task.READY)))
self.do_next_named_step('Thread 1 - Choose', choice='Yes', with_save_load=True)
self.workflow.do_engine_steps()
self.do_next_named_step('Thread 2 - Choose', choice='Yes', with_save_load=True)
self.workflow.do_engine_steps()
for i in range(1,13):
self.do_next_named_step('Thread 1 - Task %d' % i, with_save_load=True)
self.workflow.do_engine_steps()
self.do_next_named_step('Thread 2 - Task %d' % i, with_save_load=True)
self.workflow.do_engine_steps()
self.do_next_named_step('Done', with_save_load=True)
self.workflow.do_engine_steps()
self.assertEquals(0, len(self.workflow.get_tasks(Task.READY | Task.WAITING)))
def testRunThroughThread1First(self):
self.workflow = BpmnWorkflow(self.spec)
self.workflow.do_engine_steps()
self.assertEquals(2, len(self.workflow.get_tasks(Task.READY)))
self.do_next_named_step('Thread 1 - Choose', choice='Yes', with_save_load=True)
self.workflow.do_engine_steps()
for i in range(1,13):
self.do_next_named_step('Thread 1 - Task %d' % i)
self.workflow.do_engine_steps()
self.assertRaises(AssertionError, self.do_next_named_step, 'Done')
self.assertEquals(1, len(self.workflow.get_tasks(Task.WAITING)))
self.do_next_named_step('Thread 2 - Choose', choice='Yes', with_save_load=True)
self.workflow.do_engine_steps()
for i in range(1,13):
self.do_next_named_step('Thread 2 - Task %d' % i, with_save_load=True)
self.workflow.do_engine_steps()
self.do_next_named_step('Done', with_save_load=True)
self.workflow.do_engine_steps()
self.assertEquals(0, len(self.workflow.get_tasks(Task.READY | Task.WAITING)))
class ParallelJoinLongInclusiveTest(ParallelJoinLongTest):
def load_spec(self):
return self.load_workflow_spec('Test-Workflows/Parallel-Join-Long-Inclusive.bpmn20.xml', 'Parallel Join Long Inclusive')
def testRunThroughThread1FirstThenNo(self):
self.workflow = BpmnWorkflow(self.spec)
self.workflow.do_engine_steps()
self.assertEquals(2, len(self.workflow.get_tasks(Task.READY)))
self.do_next_named_step('Thread 1 - Choose', choice='Yes', with_save_load=True)
self.workflow.do_engine_steps()
for i in range(1,13):
self.do_next_named_step('Thread 1 - Task %d' % i)
self.workflow.do_engine_steps()
self.assertRaises(AssertionError, self.do_next_named_step, 'Done')
self.assertEquals(1, len(self.workflow.get_tasks(Task.WAITING)))
self.do_next_named_step('Thread 2 - Choose', choice='No', with_save_load=True)
self.workflow.do_engine_steps()
self.do_next_named_step('Done', with_save_load=True)
self.workflow.do_engine_steps()
self.do_next_named_step('Thread 2 - No Task', with_save_load=True)
self.workflow.do_engine_steps()
self.assertEquals(0, len(self.workflow.get_tasks(Task.READY | Task.WAITING)))
def testNoFirstThenThread1(self):
self.workflow = BpmnWorkflow(self.spec)
self.workflow.do_engine_steps()
self.assertEquals(2, len(self.workflow.get_tasks(Task.READY)))
self.do_next_named_step('Thread 2 - Choose', choice='No', with_save_load=True)
self.workflow.do_engine_steps()
self.do_next_named_step('Thread 1 - Choose', choice='Yes', with_save_load=True)
self.workflow.do_engine_steps()
for i in range(1,13):
self.do_next_named_step('Thread 1 - Task %d' % i)
self.workflow.do_engine_steps()
self.do_next_named_step('Done', with_save_load=True)
self.workflow.do_engine_steps()
self.do_next_named_step('Thread 2 - No Task', with_save_load=True)
self.workflow.do_engine_steps()
self.assertEquals(0, len(self.workflow.get_tasks(Task.READY | Task.WAITING)))
class ParallelJoinLongInclusiveTest(ParallelJoinLongTest):
def load_spec(self):
return self.load_workflow_spec('Test-Workflows/Parallel-Join-Long-Inclusive.bpmn20.xml', 'Parallel Join Long Inclusive')
def testRunThroughThread1FirstThenNo(self):
self.workflow = BpmnWorkflow(self.spec)
self.workflow.do_engine_steps()
self.assertEquals(2, len(self.workflow.get_tasks(Task.READY)))
self.do_next_named_step('Thread 1 - Choose', choice='Yes', with_save_load=True)
self.workflow.do_engine_steps()
for i in range(1,13):
self.do_next_named_step('Thread 1 - Task %d' % i)
self.workflow.do_engine_steps()
self.assertRaises(AssertionError, self.do_next_named_step, 'Done')
self.assertEquals(1, len(self.workflow.get_tasks(Task.WAITING)))
self.do_next_named_step('Thread 2 - Choose', choice='No', with_save_load=True)
self.workflow.do_engine_steps()
self.do_next_named_step('Done', with_save_load=True)
self.workflow.do_engine_steps()
self.do_next_named_step('Thread 2 - No Task', with_save_load=True)
self.workflow.do_engine_steps()
self.assertEquals(0, len(self.workflow.get_tasks(Task.READY | Task.WAITING)))
def testNoFirstThenThread1(self):
self.workflow = BpmnWorkflow(self.spec)
self.workflow.do_engine_steps()
self.assertEquals(2, len(self.workflow.get_tasks(Task.READY)))
self.do_next_named_step('Thread 2 - Choose', choice='No', with_save_load=True)
self.workflow.do_engine_steps()
self.do_next_named_step('Thread 1 - Choose', choice='Yes', with_save_load=True)
self.workflow.do_engine_steps()
for i in range(1,13):
self.do_next_named_step('Thread 1 - Task %d' % i)
self.workflow.do_engine_steps()
self.do_next_named_step('Done', with_save_load=True)
self.workflow.do_engine_steps()
self.do_next_named_step('Thread 2 - No Task', with_save_load=True)
self.workflow.do_engine_steps()
self.assertEquals(0, len(self.workflow.get_tasks(Task.READY | Task.WAITING)))
class TimerIntermediateTest(BpmnWorkflowTestCase):
def setUp(self):
self.spec = self.load_spec()
def load_spec(self):
return self.load_workflow_spec('Test-Workflows/*.bpmn20.xml',
'Timer Intermediate')
def testRunThroughHappy(self):
self.workflow = BpmnWorkflow(self.spec)
due_time = datetime.datetime.now() + datetime.timedelta(seconds=0.5)
self.assertEquals(1, len(self.workflow.get_tasks(Task.READY)))
self.workflow.get_tasks(Task.READY)[0].set_data(due_time=due_time)
self.workflow.do_engine_steps()
self.assertEquals(1, len(self.workflow.get_tasks(Task.WAITING)))
time.sleep(0.6)
self.assertEquals(1, len(self.workflow.get_tasks(Task.WAITING)))
self.workflow.refresh_waiting_tasks()
self.assertEquals(0, len(self.workflow.get_tasks(Task.WAITING)))
self.assertEquals(1, len(self.workflow.get_tasks(Task.READY)))
self.workflow.do_engine_steps()
self.assertEquals(
0, len(self.workflow.get_tasks(Task.READY | Task.WAITING)))
class TimerIntermediateTest(BpmnWorkflowTestCase):
def setUp(self):
self.spec = self.load_spec()
def load_spec(self):
return self.load_workflow_spec('Test-Workflows/*.bpmn20.xml', 'Timer Intermediate')
def testRunThroughHappy(self):
self.workflow = BpmnWorkflow(self.spec)
due_time = datetime.datetime.now() + datetime.timedelta(seconds=0.5)
self.assertEquals(1, len(self.workflow.get_tasks(Task.READY)))
self.workflow.get_tasks(Task.READY)[0].set_data(due_time=due_time)
self.workflow.do_engine_steps()
self.assertEquals(1, len(self.workflow.get_tasks(Task.WAITING)))
time.sleep(0.6)
self.assertEquals(1, len(self.workflow.get_tasks(Task.WAITING)))
self.workflow.refresh_waiting_tasks()
self.assertEquals(0, len(self.workflow.get_tasks(Task.WAITING)))
self.assertEquals(1, len(self.workflow.get_tasks(Task.READY)))
self.workflow.do_engine_steps()
self.assertEquals(0, len(self.workflow.get_tasks(Task.READY | Task.WAITING)))
class AbstractParallelTest(BpmnWorkflowTestCase):
def _do_test(self, order, only_one_instance=True, save_restore=False):
self.workflow = BpmnWorkflow(self.spec)
self.workflow.do_engine_steps()
for s in order:
choice = None
if isinstance(s, tuple):
s, choice = s
if s.startswith('!'):
logging.info("Checking that we cannot do '%s'", s[1:])
self.assertRaises(AssertionError,
self.do_next_named_step,
s[1:],
choice=choice)
else:
if choice is not None:
logging.info("Doing step '%s' (with choice='%s')", s,
choice)
else:
logging.info("Doing step '%s'", s)
#logging.debug(self.workflow.get_dump())
self.do_next_named_step(s,
choice=choice,
only_one_instance=only_one_instance)
self.workflow.do_engine_steps()
if save_restore:
#logging.debug("Before SaveRestore: \n%s" % self.workflow.get_dump())
self.save_restore()
self.workflow.do_engine_steps()
unfinished = self.workflow.get_tasks(Task.READY | Task.WAITING)
if unfinished:
logging.debug("Unfinished tasks: %s", unfinished)
logging.debug(self.workflow.get_dump())
self.assertEquals(0, len(unfinished))
class AbstractParallelTest(BpmnWorkflowTestCase):
def _do_test(self, order, only_one_instance=True, save_restore=False):
self.workflow = BpmnWorkflow(self.spec)
self.workflow.do_engine_steps()
for s in order:
choice = None
if isinstance(s, tuple):
s, choice = s
if s.startswith("!"):
logging.info("Checking that we cannot do '%s'", s[1:])
self.assertRaises(AssertionError, self.do_next_named_step, s[1:], choice=choice)
else:
if choice is not None:
logging.info("Doing step '%s' (with choice='%s')", s, choice)
else:
logging.info("Doing step '%s'", s)
# logging.debug(self.workflow.get_dump())
self.do_next_named_step(s, choice=choice, only_one_instance=only_one_instance)
self.workflow.do_engine_steps()
if save_restore:
# logging.debug("Before SaveRestore: \n%s" % self.workflow.get_dump())
self.save_restore()
self.workflow.do_engine_steps()
unfinished = self.workflow.get_tasks(Task.READY | Task.WAITING)
if unfinished:
logging.debug("Unfinished tasks: %s", unfinished)
logging.debug(self.workflow.get_dump())
self.assertEquals(0, len(unfinished))
class MessagesTest(BpmnWorkflowTestCase):
def setUp(self):
self.spec = self.load_spec()
def load_spec(self):
return self.load_workflow_spec('Test-Workflows/*.bpmn20.xml',
'Test Workflows')
def testRunThroughHappy(self):
self.workflow = BpmnWorkflow(self.spec)
self.do_next_exclusive_step('Select Test', choice='Messages')
self.workflow.do_engine_steps()
self.assertEquals([], self.workflow.get_tasks(Task.READY))
self.assertEquals(1, len(self.workflow.get_tasks(Task.WAITING)))
self.workflow.accept_message('Wrong Message')
self.assertEquals([], self.workflow.get_tasks(Task.READY))
self.workflow.accept_message('Test Message')
self.assertEquals(1, len(self.workflow.get_tasks(Task.READY)))
self.assertEquals(
'Test Message',
self.workflow.get_tasks(Task.READY)[0].task_spec.description)
self.workflow.do_engine_steps()
self.assertEquals(
0, len(self.workflow.get_tasks(Task.READY | Task.WAITING)))
def testRunThroughSaveAndRestore(self):
self.workflow = BpmnWorkflow(self.spec)
self.do_next_exclusive_step('Select Test', choice='Messages')
self.workflow.do_engine_steps()
self.save_restore()
self.assertEquals([], self.workflow.get_tasks(Task.READY))
self.assertEquals(1, len(self.workflow.get_tasks(Task.WAITING)))
self.workflow.accept_message('Wrong Message')
self.assertEquals([], self.workflow.get_tasks(Task.READY))
self.workflow.accept_message('Test Message')
self.save_restore()
self.workflow.do_engine_steps()
self.assertEquals(
0, len(self.workflow.get_tasks(Task.READY | Task.WAITING)))
class MessagesTest(BpmnWorkflowTestCase):
def setUp(self):
self.spec = self.load_spec()
def load_spec(self):
return self.load_workflow_spec('Test-Workflows/*.bpmn20.xml', 'Test Workflows')
def testRunThroughHappy(self):
self.workflow = BpmnWorkflow(self.spec)
self.do_next_exclusive_step('Select Test', choice='Messages')
self.workflow.do_engine_steps()
self.assertEquals([], self.workflow.get_tasks(Task.READY))
self.assertEquals(1, len(self.workflow.get_tasks(Task.WAITING)))
self.workflow.accept_message('Wrong Message')
self.assertEquals([], self.workflow.get_tasks(Task.READY))
self.workflow.accept_message('Test Message')
self.assertEquals(1, len(self.workflow.get_tasks(Task.READY)))
self.assertEquals('Test Message', self.workflow.get_tasks(Task.READY)[0].task_spec.description)
self.workflow.do_engine_steps()
self.assertEquals(0, len(self.workflow.get_tasks(Task.READY | Task.WAITING)))
def testRunThroughSaveAndRestore(self):
self.workflow = BpmnWorkflow(self.spec)
self.do_next_exclusive_step('Select Test', choice='Messages')
self.workflow.do_engine_steps()
self.save_restore()
self.assertEquals([], self.workflow.get_tasks(Task.READY))
self.assertEquals(1, len(self.workflow.get_tasks(Task.WAITING)))
self.workflow.accept_message('Wrong Message')
self.assertEquals([], self.workflow.get_tasks(Task.READY))
self.workflow.accept_message('Test Message')
self.save_restore()
self.workflow.do_engine_steps()
self.assertEquals(0, len(self.workflow.get_tasks(Task.READY | Task.WAITING)))
class NestedProcessesTest(BpmnWorkflowTestCase):
def setUp(self):
self.spec = self.load_spec()
def load_spec(self):
return self.load_workflow_spec('Test-Workflows/*.bpmn20.xml', 'Nested Subprocesses')
def testRunThroughHappy(self):
self.workflow = BpmnWorkflow(self.spec)
self.do_next_named_step('Action1')
self.workflow.do_engine_steps()
self.save_restore()
self.assertEquals(1, len(self.workflow.get_tasks(Task.READY)))
self.do_next_named_step('Action2')
self.workflow.do_engine_steps()
self.save_restore()
self.assertEquals(1, len(self.workflow.get_tasks(Task.READY)))
self.do_next_named_step('Action3')
self.workflow.do_engine_steps()
self.save_restore()
self.assertEquals(0, len(self.workflow.get_tasks(Task.READY | Task.WAITING)))
class MessageInterruptsSpTest(BpmnWorkflowTestCase):
def setUp(self):
self.spec = self.load_spec()
def load_spec(self):
return self.load_workflow_spec('Test-Workflows/*.bpmn20.xml',
'Message Interrupts SP')
def testRunThroughHappySaveAndRestore(self):
self.workflow = BpmnWorkflow(self.spec)
self.save_restore()
self.workflow.do_engine_steps()
self.save_restore()
self.assertEquals(1, len(self.workflow.get_tasks(Task.READY)))
self.assertEquals(1, len(self.workflow.get_tasks(Task.WAITING)))
self.do_next_exclusive_step('Do Something In a Subprocess')
self.workflow.do_engine_steps()
self.save_restore()
self.do_next_exclusive_step('Ack Subprocess Done')
self.workflow.do_engine_steps()
self.save_restore()
self.workflow.do_engine_steps()
self.assertEquals(
0, len(self.workflow.get_tasks(Task.READY | Task.WAITING)))
def testRunThroughInterruptSaveAndRestore(self):
self.workflow = BpmnWorkflow(self.spec)
self.save_restore()
self.workflow.do_engine_steps()
self.save_restore()
self.assertEquals(1, len(self.workflow.get_tasks(Task.READY)))
self.assertEquals(1, len(self.workflow.get_tasks(Task.WAITING)))
self.workflow.accept_message('Test Message')
self.workflow.do_engine_steps()
self.save_restore()
self.do_next_exclusive_step('Acknowledge SP Interrupt Message')
self.workflow.do_engine_steps()
self.save_restore()
self.workflow.do_engine_steps()
self.assertEquals(
0, len(self.workflow.get_tasks(Task.READY | Task.WAITING)))
class MessageInterruptsSpTest(BpmnWorkflowTestCase):
def setUp(self):
self.spec = self.load_spec()
def load_spec(self):
return self.load_workflow_spec('Test-Workflows/*.bpmn20.xml', 'Message Interrupts SP')
def testRunThroughHappySaveAndRestore(self):
self.workflow = BpmnWorkflow(self.spec)
self.save_restore()
self.workflow.do_engine_steps()
self.save_restore()
self.assertEquals(1, len(self.workflow.get_tasks(Task.READY)))
self.assertEquals(1, len(self.workflow.get_tasks(Task.WAITING)))
self.do_next_exclusive_step('Do Something In a Subprocess')
self.workflow.do_engine_steps()
self.save_restore()
self.do_next_exclusive_step('Ack Subprocess Done')
self.workflow.do_engine_steps()
self.save_restore()
self.workflow.do_engine_steps()
self.assertEquals(0, len(self.workflow.get_tasks(Task.READY | Task.WAITING)))
def testRunThroughInterruptSaveAndRestore(self):
self.workflow = BpmnWorkflow(self.spec)
self.save_restore()
self.workflow.do_engine_steps()
self.save_restore()
self.assertEquals(1, len(self.workflow.get_tasks(Task.READY)))
self.assertEquals(1, len(self.workflow.get_tasks(Task.WAITING)))
self.workflow.accept_message('Test Message')
self.workflow.do_engine_steps()
self.save_restore()
self.do_next_exclusive_step('Acknowledge SP Interrupt Message')
self.workflow.do_engine_steps()
self.save_restore()
self.workflow.do_engine_steps()
self.assertEquals(0, len(self.workflow.get_tasks(Task.READY | Task.WAITING)))
class ZEngine(object):
"""
takes wf
"""
def __init__(self, **kwargs):
self.conf = DotDict(kwargs)
self.current = DotDict()
self.modules = {}
self.workflow = BpmnWorkflow
self.workflow_spec = WorkflowSpec
self.load_or_create_workflow()
# self.run()
def load_or_create_workflow(self):
"""
tries to load the workflow from session
creates a new one if it can't find
:return:
"""
try:
workflow_path = self.get_worfklow_path()
serialized_wf = self.request.session.workflows[workflow_path]
self.workflow = BpmnWorkflow.deserialize(DictionarySerializer(), serialized_wf)
except Exception as e:
print e
wf_pkg_file = open(self.workflow_name)
self.workflow_spec = BpmnSerializer().deserialize_workflow_spec(wf_pkg_file)
self.workflow = BpmnWorkflow(self.workflow_spec)
def get_worfklow_path(self):
return "%s/workflows/%s.zip" % (os.path.dirname(os.path.realpath(__file__)), self.workflow_name)
def save_workflow(self):
if 'workflows' in self.request.session:
serialized_wf = self.workflow.serialize(serializer=DictionarySerializer())
self.request.session['workflows'][self.workflow_name] = serialized_wf
self.request.session.save() # TODO: check if this is realy neccessary
def set_current(self, **kwargs):
self.current.update(kwargs)
if 'task' in self.current:
# TODO: look for a better way for getting the task type
self.current.type = str(self.current.task).split('(')[1].split(')')[0]
self.current.spec = self.current.task.task_spec
self.current.name = self.current.task.get_name()
def complete_current_task(self):
self.workflow.complete_task_from_id(self.current.task.id)
def run(self):
ready_tasks = self.workflow.get_tasks(state=Task.READY)
if ready_tasks:
for task in ready_tasks:
self.set_current(task=task)
print("TASK >> %s" % self.current.name, self.current.task.data)
self.process_callbacks()
self.complete_current_task()
self.save_workflow()
def run_module_method(self, module_method):
mod_parts = module_method.split('.')
module = "zaerp.lib.zaerp.service_modules.%s" % mod_parts[:-1]
method = mod_parts[-1]
if module not in self.modules:
self.modules[module] = import_module(module)
getattr(self.modules[module], method)(self.current)
def process_callbacks(self):
if 'callbacks' in self.current.spec.data:
for cb in self.current.spec.data.callbacks:
self.run_module_method(cb)
class ParallelOnePathEndsTest(BpmnWorkflowTestCase):
def setUp(self):
self.spec = self.load_spec()
def load_spec(self):
return self.load_workflow_spec(
'Test-Workflows/Parallel-One-Path-Ends.bpmn20.xml',
'Parallel One Path Ends')
def testRunThroughParallelTaskFirst(self):
self.workflow = BpmnWorkflow(self.spec)
self.workflow.do_engine_steps()
self.assertEquals(2, len(self.workflow.get_tasks(Task.READY)))
self.do_next_named_step('Parallel Task')
self.workflow.do_engine_steps()
self.assertRaises(AssertionError, self.do_next_named_step, 'Done')
self.do_next_named_step('Choice 1', choice='No')
self.workflow.do_engine_steps()
self.do_next_named_step('Done')
self.workflow.do_engine_steps()
self.assertEquals(
0, len(self.workflow.get_tasks(Task.READY | Task.WAITING)))
def testRunThroughChoiceFirst(self):
self.workflow = BpmnWorkflow(self.spec)
self.workflow.do_engine_steps()
self.assertEquals(2, len(self.workflow.get_tasks(Task.READY)))
self.do_next_named_step('Choice 1', choice='No')
self.workflow.do_engine_steps()
self.assertRaises(AssertionError, self.do_next_named_step, 'Done')
self.do_next_named_step('Parallel Task')
self.workflow.do_engine_steps()
self.do_next_named_step('Done')
self.workflow.do_engine_steps()
self.assertEquals(
0, len(self.workflow.get_tasks(Task.READY | Task.WAITING)))
def testRunThroughParallelTaskFirstYes(self):
self.workflow = BpmnWorkflow(self.spec)
self.workflow.do_engine_steps()
self.assertEquals(2, len(self.workflow.get_tasks(Task.READY)))
self.do_next_named_step('Parallel Task')
self.workflow.do_engine_steps()
self.assertRaises(AssertionError, self.do_next_named_step, 'Done')
self.do_next_named_step('Choice 1', choice='Yes')
self.workflow.do_engine_steps()
self.assertRaises(AssertionError, self.do_next_named_step, 'Done')
self.do_next_named_step('Yes Task')
self.workflow.do_engine_steps()
self.do_next_named_step('Done')
self.workflow.do_engine_steps()
self.assertEquals(
0, len(self.workflow.get_tasks(Task.READY | Task.WAITING)))
class ParallelThroughSameTaskTest(BpmnWorkflowTestCase):
def setUp(self):
self.spec = self.load_spec()
def load_spec(self):
return self.load_workflow_spec(
'Test-Workflows/Parallel-Through-Same-Task.bpmn20.xml',
'Parallel Through Same Task')
def testRunThroughFirstRepeatTaskFirst(self):
self.workflow = BpmnWorkflow(self.spec)
self.workflow.do_engine_steps()
self.assertEquals(2, len(self.workflow.get_tasks(Task.READY)))
self.do_next_named_step('Repeated Task')
self.workflow.do_engine_steps()
#The inclusive gateway allows this to pass through (since there is a route to it on the same sequence flow)
self.do_next_named_step('Done')
self.workflow.do_engine_steps()
self.do_next_named_step('Choice 1', choice='Yes')
self.workflow.do_engine_steps()
self.do_next_named_step('Yes Task')
self.workflow.do_engine_steps()
self.assertRaises(AssertionError, self.do_next_named_step, 'Done')
self.do_next_named_step('Repeated Task')
self.workflow.do_engine_steps()
self.do_next_named_step('Done')
self.workflow.do_engine_steps()
self.assertEquals(
0, len(self.workflow.get_tasks(Task.READY | Task.WAITING)))
def testRepeatTasksReadyTogether(self):
self.workflow = BpmnWorkflow(self.spec)
self.workflow.do_engine_steps()
self.assertEquals(2, len(self.workflow.get_tasks(Task.READY)))
self.do_next_named_step('Choice 1', choice='Yes')
self.workflow.do_engine_steps()
self.do_next_named_step('Yes Task')
self.workflow.do_engine_steps()
self.assertRaises(AssertionError, self.do_next_named_step, 'Done')
ready_tasks = self.workflow.get_tasks(Task.READY)
self.assertEquals(2, len(ready_tasks))
self.assertEquals('Repeated Task',
ready_tasks[0].task_spec.description)
ready_tasks[0].complete()
self.workflow.do_engine_steps()
#The inclusive gateway allows us through here, because there is no route for the other thread
#that doesn't use the same sequence flow
self.do_next_named_step('Done')
self.workflow.do_engine_steps()
self.do_next_named_step('Repeated Task')
self.workflow.do_engine_steps()
self.do_next_named_step('Done')
self.workflow.do_engine_steps()
self.assertEquals(
0, len(self.workflow.get_tasks(Task.READY | Task.WAITING)))
def testRepeatTasksReadyTogetherSaveRestore(self):
self.workflow = BpmnWorkflow(self.spec)
self.workflow.do_engine_steps()
self.save_restore()
self.assertEquals(2, len(self.workflow.get_tasks(Task.READY)))
self.do_next_named_step('Choice 1', choice='Yes')
self.workflow.do_engine_steps()
self.save_restore()
self.do_next_named_step('Yes Task')
self.workflow.do_engine_steps()
self.save_restore()
self.assertRaises(AssertionError, self.do_next_named_step, 'Done')
ready_tasks = self.workflow.get_tasks(Task.READY)
self.assertEquals(2, len(ready_tasks))
self.assertEquals('Repeated Task',
ready_tasks[0].task_spec.description)
ready_tasks[0].complete()
self.workflow.do_engine_steps()
self.save_restore()
#The inclusive gateway allows us through here, because there is no route for the other thread
#that doesn't use the same sequence flow
self.do_next_named_step('Done')
self.workflow.do_engine_steps()
self.save_restore()
self.do_next_named_step('Repeated Task')
self.workflow.do_engine_steps()
self.save_restore()
self.do_next_named_step('Done')
self.workflow.do_engine_steps()
self.save_restore()
self.assertEquals(
0, len(self.workflow.get_tasks(Task.READY | Task.WAITING)))
def testNoRouteRepeatTaskFirst(self):
self.workflow = BpmnWorkflow(self.spec)
self.workflow.do_engine_steps()
self.save_restore()
self.assertEquals(2, len(self.workflow.get_tasks(Task.READY)))
self.do_next_named_step('Repeated Task')
self.workflow.do_engine_steps()
self.save_restore()
#The inclusive gateway allows this to pass through (since there is a route to it on the same sequence flow)
self.do_next_named_step('Done')
self.workflow.do_engine_steps()
self.save_restore()
self.do_next_named_step('Choice 1', choice='No')
self.workflow.do_engine_steps()
self.save_restore()
self.do_next_named_step('No Task')
self.workflow.do_engine_steps()
self.save_restore()
self.do_next_named_step('Done')
self.workflow.do_engine_steps()
self.save_restore()
self.assertEquals(
0, len(self.workflow.get_tasks(Task.READY | Task.WAITING)))
def testNoRouteNoTaskFirst(self):
self.workflow = BpmnWorkflow(self.spec)
self.workflow.do_engine_steps()
self.save_restore()
self.assertEquals(2, len(self.workflow.get_tasks(Task.READY)))
self.do_next_named_step('Choice 1', choice='No')
self.workflow.do_engine_steps()
self.save_restore()
self.do_next_named_step('No Task')
self.workflow.do_engine_steps()
self.save_restore()
self.assertRaises(AssertionError, self.do_next_named_step, 'Done')
self.do_next_named_step('Repeated Task')
self.workflow.do_engine_steps()
self.save_restore()
self.do_next_named_step('Done')
self.workflow.do_engine_steps()
self.save_restore()
self.assertEquals(
0, len(self.workflow.get_tasks(Task.READY | Task.WAITING)))
def testNoRouteNoFirstThenRepeating(self):
self.workflow = BpmnWorkflow(self.spec)
self.workflow.do_engine_steps()
self.save_restore()
self.assertEquals(2, len(self.workflow.get_tasks(Task.READY)))
self.do_next_named_step('Choice 1', choice='No')
self.workflow.do_engine_steps()
self.save_restore()
self.assertRaises(AssertionError, self.do_next_named_step, 'Done')
self.do_next_named_step('Repeated Task')
self.workflow.do_engine_steps()
self.save_restore()
self.assertRaises(AssertionError, self.do_next_named_step, 'Done')
self.do_next_named_step('No Task')
self.workflow.do_engine_steps()
self.save_restore()
self.do_next_named_step('Done')
self.workflow.do_engine_steps()
self.save_restore()
self.assertEquals(
0, len(self.workflow.get_tasks(Task.READY | Task.WAITING)))
class ParallelOnePathEndsTest(BpmnWorkflowTestCase):
def setUp(self):
self.spec = self.load_spec()
def load_spec(self):
return self.load_workflow_spec("Test-Workflows/Parallel-One-Path-Ends.bpmn20.xml", "Parallel One Path Ends")
def testRunThroughParallelTaskFirst(self):
self.workflow = BpmnWorkflow(self.spec)
self.workflow.do_engine_steps()
self.assertEquals(2, len(self.workflow.get_tasks(Task.READY)))
self.do_next_named_step("Parallel Task")
self.workflow.do_engine_steps()
self.assertRaises(AssertionError, self.do_next_named_step, "Done")
self.do_next_named_step("Choice 1", choice="No")
self.workflow.do_engine_steps()
self.do_next_named_step("Done")
self.workflow.do_engine_steps()
self.assertEquals(0, len(self.workflow.get_tasks(Task.READY | Task.WAITING)))
def testRunThroughChoiceFirst(self):
self.workflow = BpmnWorkflow(self.spec)
self.workflow.do_engine_steps()
self.assertEquals(2, len(self.workflow.get_tasks(Task.READY)))
self.do_next_named_step("Choice 1", choice="No")
self.workflow.do_engine_steps()
self.assertRaises(AssertionError, self.do_next_named_step, "Done")
self.do_next_named_step("Parallel Task")
self.workflow.do_engine_steps()
self.do_next_named_step("Done")
self.workflow.do_engine_steps()
self.assertEquals(0, len(self.workflow.get_tasks(Task.READY | Task.WAITING)))
def testRunThroughParallelTaskFirstYes(self):
self.workflow = BpmnWorkflow(self.spec)
self.workflow.do_engine_steps()
self.assertEquals(2, len(self.workflow.get_tasks(Task.READY)))
self.do_next_named_step("Parallel Task")
self.workflow.do_engine_steps()
self.assertRaises(AssertionError, self.do_next_named_step, "Done")
self.do_next_named_step("Choice 1", choice="Yes")
self.workflow.do_engine_steps()
self.assertRaises(AssertionError, self.do_next_named_step, "Done")
self.do_next_named_step("Yes Task")
self.workflow.do_engine_steps()
self.do_next_named_step("Done")
self.workflow.do_engine_steps()
self.assertEquals(0, len(self.workflow.get_tasks(Task.READY | Task.WAITING)))
class ParallelThroughSameTaskTest(BpmnWorkflowTestCase):
def setUp(self):
self.spec = self.load_spec()
def load_spec(self):
return self.load_workflow_spec(
"Test-Workflows/Parallel-Through-Same-Task.bpmn20.xml", "Parallel Through Same Task"
)
def testRunThroughFirstRepeatTaskFirst(self):
self.workflow = BpmnWorkflow(self.spec)
self.workflow.do_engine_steps()
self.assertEquals(2, len(self.workflow.get_tasks(Task.READY)))
self.do_next_named_step("Repeated Task")
self.workflow.do_engine_steps()
# The inclusive gateway allows this to pass through (since there is a route to it on the same sequence flow)
self.do_next_named_step("Done")
self.workflow.do_engine_steps()
self.do_next_named_step("Choice 1", choice="Yes")
self.workflow.do_engine_steps()
self.do_next_named_step("Yes Task")
self.workflow.do_engine_steps()
self.assertRaises(AssertionError, self.do_next_named_step, "Done")
self.do_next_named_step("Repeated Task")
self.workflow.do_engine_steps()
self.do_next_named_step("Done")
self.workflow.do_engine_steps()
self.assertEquals(0, len(self.workflow.get_tasks(Task.READY | Task.WAITING)))
def testRepeatTasksReadyTogether(self):
self.workflow = BpmnWorkflow(self.spec)
self.workflow.do_engine_steps()
self.assertEquals(2, len(self.workflow.get_tasks(Task.READY)))
self.do_next_named_step("Choice 1", choice="Yes")
self.workflow.do_engine_steps()
self.do_next_named_step("Yes Task")
self.workflow.do_engine_steps()
self.assertRaises(AssertionError, self.do_next_named_step, "Done")
ready_tasks = self.workflow.get_tasks(Task.READY)
self.assertEquals(2, len(ready_tasks))
self.assertEquals("Repeated Task", ready_tasks[0].task_spec.description)
ready_tasks[0].complete()
self.workflow.do_engine_steps()
# The inclusive gateway allows us through here, because there is no route for the other thread
# that doesn't use the same sequence flow
self.do_next_named_step("Done")
self.workflow.do_engine_steps()
self.do_next_named_step("Repeated Task")
self.workflow.do_engine_steps()
self.do_next_named_step("Done")
self.workflow.do_engine_steps()
self.assertEquals(0, len(self.workflow.get_tasks(Task.READY | Task.WAITING)))
def testRepeatTasksReadyTogetherSaveRestore(self):
self.workflow = BpmnWorkflow(self.spec)
self.workflow.do_engine_steps()
self.save_restore()
self.assertEquals(2, len(self.workflow.get_tasks(Task.READY)))
self.do_next_named_step("Choice 1", choice="Yes")
self.workflow.do_engine_steps()
self.save_restore()
self.do_next_named_step("Yes Task")
self.workflow.do_engine_steps()
self.save_restore()
self.assertRaises(AssertionError, self.do_next_named_step, "Done")
ready_tasks = self.workflow.get_tasks(Task.READY)
self.assertEquals(2, len(ready_tasks))
self.assertEquals("Repeated Task", ready_tasks[0].task_spec.description)
ready_tasks[0].complete()
self.workflow.do_engine_steps()
self.save_restore()
# The inclusive gateway allows us through here, because there is no route for the other thread
# that doesn't use the same sequence flow
self.do_next_named_step("Done")
self.workflow.do_engine_steps()
self.save_restore()
self.do_next_named_step("Repeated Task")
self.workflow.do_engine_steps()
self.save_restore()
self.do_next_named_step("Done")
self.workflow.do_engine_steps()
self.save_restore()
self.assertEquals(0, len(self.workflow.get_tasks(Task.READY | Task.WAITING)))
def testNoRouteRepeatTaskFirst(self):
self.workflow = BpmnWorkflow(self.spec)
self.workflow.do_engine_steps()
self.save_restore()
self.assertEquals(2, len(self.workflow.get_tasks(Task.READY)))
self.do_next_named_step("Repeated Task")
self.workflow.do_engine_steps()
self.save_restore()
# The inclusive gateway allows this to pass through (since there is a route to it on the same sequence flow)
self.do_next_named_step("Done")
self.workflow.do_engine_steps()
self.save_restore()
self.do_next_named_step("Choice 1", choice="No")
self.workflow.do_engine_steps()
self.save_restore()
self.do_next_named_step("No Task")
self.workflow.do_engine_steps()
self.save_restore()
self.do_next_named_step("Done")
self.workflow.do_engine_steps()
self.save_restore()
self.assertEquals(0, len(self.workflow.get_tasks(Task.READY | Task.WAITING)))
def testNoRouteNoTaskFirst(self):
self.workflow = BpmnWorkflow(self.spec)
self.workflow.do_engine_steps()
self.save_restore()
self.assertEquals(2, len(self.workflow.get_tasks(Task.READY)))
self.do_next_named_step("Choice 1", choice="No")
self.workflow.do_engine_steps()
self.save_restore()
self.do_next_named_step("No Task")
self.workflow.do_engine_steps()
self.save_restore()
self.assertRaises(AssertionError, self.do_next_named_step, "Done")
self.do_next_named_step("Repeated Task")
self.workflow.do_engine_steps()
self.save_restore()
self.do_next_named_step("Done")
self.workflow.do_engine_steps()
self.save_restore()
self.assertEquals(0, len(self.workflow.get_tasks(Task.READY | Task.WAITING)))
def testNoRouteNoFirstThenRepeating(self):
self.workflow = BpmnWorkflow(self.spec)
self.workflow.do_engine_steps()
self.save_restore()
self.assertEquals(2, len(self.workflow.get_tasks(Task.READY)))
self.do_next_named_step("Choice 1", choice="No")
self.workflow.do_engine_steps()
self.save_restore()
self.assertRaises(AssertionError, self.do_next_named_step, "Done")
self.do_next_named_step("Repeated Task")
self.workflow.do_engine_steps()
self.save_restore()
self.assertRaises(AssertionError, self.do_next_named_step, "Done")
self.do_next_named_step("No Task")
self.workflow.do_engine_steps()
self.save_restore()
self.do_next_named_step("Done")
self.workflow.do_engine_steps()
self.save_restore()
self.assertEquals(0, len(self.workflow.get_tasks(Task.READY | Task.WAITING)))
class ActionManagementTest(BpmnWorkflowTestCase):
def setUp(self):
self.spec = self.load_spec()
self.workflow = BpmnWorkflow(self.spec)
start_time = datetime.datetime.now() + datetime.timedelta(seconds=0.5)
finish_time = datetime.datetime.now() + datetime.timedelta(seconds=1.5)
self.assertEquals(1, len(self.workflow.get_tasks(Task.READY)))
self.workflow.get_tasks(Task.READY)[0].set_attribute(
start_time=start_time, finish_time=finish_time)
def load_spec(self):
return self.load_workflow_spec('Test-Workflows/*.bpmn20.xml',
'Action Management')
def testRunThroughHappy(self):
self.do_next_exclusive_step("Review Action", choice='Approve')
self.workflow.do_engine_steps()
self.assertEquals(1, len(self.workflow.get_tasks(Task.WAITING)))
self.assertEquals(1, len(self.workflow.get_tasks(Task.READY)))
self.assertEquals(
'NEW ACTION',
self.workflow.get_tasks(
Task.READY)[0].get_attribute('script_output'))
self.assertEquals(
'Cancel Action (if necessary)',
self.workflow.get_tasks(Task.READY)[0].task_spec.description)
time.sleep(0.6)
self.workflow.refresh_waiting_tasks()
self.workflow.do_engine_steps()
self.assertEquals(1, len(self.workflow.get_tasks(Task.WAITING)))
self.assertEquals(2, len(self.workflow.get_tasks(Task.READY)))
self.do_next_named_step("Start Work")
self.workflow.do_engine_steps()
self.do_next_named_step("Complete Work", choice="Done")
self.workflow.do_engine_steps()
self.assertTrue(self.workflow.is_completed())
def testRunThroughOverdue(self):
self.do_next_exclusive_step("Review Action", choice='Approve')
self.workflow.do_engine_steps()
self.assertEquals(1, len(self.workflow.get_tasks(Task.WAITING)))
self.assertEquals(1, len(self.workflow.get_tasks(Task.READY)))
self.assertEquals(
'Cancel Action (if necessary)',
self.workflow.get_tasks(Task.READY)[0].task_spec.description)
time.sleep(0.6)
self.workflow.refresh_waiting_tasks()
self.workflow.do_engine_steps()
self.assertEquals(1, len(self.workflow.get_tasks(Task.WAITING)))
self.assertEquals(2, len(self.workflow.get_tasks(Task.READY)))
self.do_next_named_step("Start Work")
self.workflow.do_engine_steps()
self.assertEquals(1, len(self.workflow.get_tasks(Task.WAITING)))
self.assertEquals(
'Finish Time',
self.workflow.get_tasks(Task.WAITING)[0].task_spec.description)
time.sleep(1.1)
self.workflow.refresh_waiting_tasks()
self.workflow.do_engine_steps()
self.assertEquals(1, len(self.workflow.get_tasks(Task.WAITING)))
self.assertNotEquals(
'Finish Time',
self.workflow.get_tasks(Task.WAITING)[0].task_spec.description)
overdue_escalation_task = filter(
lambda t: t.task_spec.description == 'Overdue Escalation',
self.workflow.get_tasks())
self.assertEquals(1, len(overdue_escalation_task))
overdue_escalation_task = overdue_escalation_task[0]
self.assertEquals(Task.COMPLETED, overdue_escalation_task.state)
self.assertEquals(
'ACTION OVERDUE',
overdue_escalation_task.get_attribute('script_output'))
self.do_next_named_step("Complete Work", choice="Done")
self.workflow.do_engine_steps()
self.assertTrue(self.workflow.is_completed())
def testRunThroughCancel(self):
self.do_next_exclusive_step("Review Action", choice='Cancel')
self.workflow.do_engine_steps()
self.assertTrue(self.workflow.is_completed())
def testRunThroughCancelAfterApproved(self):
self.do_next_exclusive_step("Review Action", choice='Approve')
self.workflow.do_engine_steps()
self.do_next_named_step("Cancel Action (if necessary)")
self.workflow.do_engine_steps()
self.assertTrue(self.workflow.is_completed())
self.assertEquals('ACTION CANCELLED',
self.workflow.get_attribute('script_output'))
def testRunThroughCancelAfterWorkStarted(self):
self.do_next_exclusive_step("Review Action", choice='Approve')
self.workflow.do_engine_steps()
self.assertEquals(1, len(self.workflow.get_tasks(Task.WAITING)))
self.assertEquals(1, len(self.workflow.get_tasks(Task.READY)))
time.sleep(0.6)
self.workflow.refresh_waiting_tasks()
self.workflow.do_engine_steps()
self.assertEquals(1, len(self.workflow.get_tasks(Task.WAITING)))
self.assertEquals(2, len(self.workflow.get_tasks(Task.READY)))
self.do_next_named_step("Start Work")
self.workflow.do_engine_steps()
self.do_next_named_step("Cancel Action (if necessary)")
self.workflow.do_engine_steps()
self.assertTrue(self.workflow.is_completed())
self.assertEquals('ACTION CANCELLED',
self.workflow.get_attribute('script_output'))
class MessageNonInterruptTest(BpmnWorkflowTestCase):
def setUp(self):
self.spec = self.load_spec()
#self.spec.dump()
def load_spec(self):
return self.load_workflow_spec('Test-Workflows/*.bpmn20.xml', 'Test Workflows')
def testRunThroughHappySaveAndRestore(self):
self.workflow = BpmnWorkflow(self.spec)
self.save_restore()
self.do_next_exclusive_step('Select Test', choice='Message Non Interrupt')
self.workflow.do_engine_steps()
self.save_restore()
self.assertEquals(1, len(self.workflow.get_tasks(Task.READY)))
self.assertEquals(1, len(self.workflow.get_tasks(Task.WAITING)))
self.do_next_exclusive_step('Do Something That Takes A Long Time')
self.save_restore()
self.workflow.do_engine_steps()
self.assertEquals(0, len(self.workflow.get_tasks(Task.WAITING)))
self.save_restore()
self.workflow.do_engine_steps()
self.assertEquals(0, len(self.workflow.get_tasks(Task.READY | Task.WAITING)))
def testRunThroughMessageInterruptSaveAndRestore(self):
self.workflow = BpmnWorkflow(self.spec)
self.save_restore()
self.do_next_exclusive_step('Select Test', choice='Message Non Interrupt')
self.workflow.do_engine_steps()
self.save_restore()
self.assertEquals(1, len(self.workflow.get_tasks(Task.READY)))
self.assertEquals(1, len(self.workflow.get_tasks(Task.WAITING)))
self.workflow.accept_message('Test Message')
self.save_restore()
self.workflow.do_engine_steps()
self.assertEquals(0, len(self.workflow.get_tasks(Task.WAITING)))
self.assertEquals(2, len(self.workflow.get_tasks(Task.READY)))
self.do_next_named_step('Acknowledge Non-Interrupt Message')
self.workflow.do_engine_steps()
self.save_restore()
self.workflow.do_engine_steps()
self.assertEquals(1, len(self.workflow.get_tasks(Task.READY)))
self.assertEquals(1, len(self.workflow.get_tasks(Task.READY)))
self.do_next_named_step('Do Something That Takes A Long Time')
self.workflow.do_engine_steps()
self.save_restore()
self.workflow.do_engine_steps()
self.assertEquals(0, len(self.workflow.get_tasks(Task.READY | Task.WAITING)))
def testRunThroughHappy(self):
self.workflow = BpmnWorkflow(self.spec)
self.do_next_exclusive_step('Select Test', choice='Message Non Interrupt')
self.workflow.do_engine_steps()
self.assertEquals(1, len(self.workflow.get_tasks(Task.READY)))
self.assertEquals(1, len(self.workflow.get_tasks(Task.WAITING)))
self.do_next_exclusive_step('Do Something That Takes A Long Time')
self.workflow.do_engine_steps()
self.assertEquals(0, len(self.workflow.get_tasks(Task.WAITING)))
self.workflow.do_engine_steps()
self.assertEquals(0, len(self.workflow.get_tasks(Task.READY | Task.WAITING)))
def testRunThroughMessageInterrupt(self):
self.workflow = BpmnWorkflow(self.spec)
self.do_next_exclusive_step('Select Test', choice='Message Non Interrupt')
self.workflow.do_engine_steps()
self.assertEquals(1, len(self.workflow.get_tasks(Task.READY)))
self.assertEquals(1, len(self.workflow.get_tasks(Task.WAITING)))
self.workflow.accept_message('Test Message')
self.workflow.do_engine_steps()
self.assertEquals(0, len(self.workflow.get_tasks(Task.WAITING)))
self.assertEquals(2, len(self.workflow.get_tasks(Task.READY)))
self.do_next_named_step('Acknowledge Non-Interrupt Message')
self.workflow.do_engine_steps()
self.assertEquals(1, len(self.workflow.get_tasks(Task.READY)))
self.assertEquals(1, len(self.workflow.get_tasks(Task.WAITING)))
self.do_next_named_step('Do Something That Takes A Long Time')
self.workflow.do_engine_steps()
self.assertEquals(0, len(self.workflow.get_tasks(Task.READY | Task.WAITING)))
def testRunThroughMessageInterruptOtherOrder(self):
self.workflow = BpmnWorkflow(self.spec)
self.do_next_exclusive_step('Select Test', choice='Message Non Interrupt')
self.workflow.do_engine_steps()
self.assertEquals(1, len(self.workflow.get_tasks(Task.READY)))
self.assertEquals(1, len(self.workflow.get_tasks(Task.WAITING)))
self.workflow.accept_message('Test Message')
self.workflow.do_engine_steps()
self.assertEquals(0, len(self.workflow.get_tasks(Task.WAITING)))
self.assertEquals(2, len(self.workflow.get_tasks(Task.READY)))
self.do_next_named_step('Do Something That Takes A Long Time')
self.workflow.do_engine_steps()
self.assertEquals(1, len(self.workflow.get_tasks(Task.READY)))
self.do_next_named_step('Acknowledge Non-Interrupt Message')
self.workflow.do_engine_steps()
self.assertEquals(0, len(self.workflow.get_tasks(Task.READY | Task.WAITING)))
def testRunThroughMessageInterruptOtherOrderSaveAndRestore(self):
self.workflow = BpmnWorkflow(self.spec)
self.save_restore()
self.do_next_exclusive_step('Select Test', choice='Message Non Interrupt')
self.workflow.do_engine_steps()
self.save_restore()
self.assertEquals(1, len(self.workflow.get_tasks(Task.READY)))
self.assertEquals(1, len(self.workflow.get_tasks(Task.WAITING)))
self.workflow.accept_message('Test Message')
self.save_restore()
self.workflow.do_engine_steps()
self.assertEquals(0, len(self.workflow.get_tasks(Task.WAITING)))
self.assertEquals(2, len(self.workflow.get_tasks(Task.READY)))
self.do_next_named_step('Do Something That Takes A Long Time')
self.save_restore()
self.workflow.do_engine_steps()
self.assertEquals(1, len(self.workflow.get_tasks(Task.READY)))
self.assertEquals(1, len(self.workflow.get_tasks(Task.READY)))
self.do_next_named_step('Acknowledge Non-Interrupt Message')
self.save_restore()
self.workflow.do_engine_steps()
self.assertEquals(0, len(self.workflow.get_tasks(Task.READY | Task.WAITING)))
class ActionManagementTest(BpmnWorkflowTestCase):
def setUp(self):
self.spec = self.load_spec()
self.workflow = BpmnWorkflow(self.spec)
start_time = datetime.datetime.now() + datetime.timedelta(seconds=0.5)
finish_time = datetime.datetime.now() + datetime.timedelta(seconds=1.5)
self.assertEquals(1, len(self.workflow.get_tasks(Task.READY)))
self.workflow.get_tasks(Task.READY)[0].set_data(start_time=start_time, finish_time=finish_time)
def load_spec(self):
return self.load_workflow_spec('Test-Workflows/*.bpmn20.xml', 'Action Management')
def testRunThroughHappy(self):
self.do_next_exclusive_step("Review Action", choice='Approve')
self.workflow.do_engine_steps()
self.assertEquals(1, len(self.workflow.get_tasks(Task.WAITING)))
self.assertEquals(1, len(self.workflow.get_tasks(Task.READY)))
self.assertEquals('NEW ACTION', self.workflow.get_tasks(Task.READY)[0].get_data('script_output'))
self.assertEquals('Cancel Action (if necessary)', self.workflow.get_tasks(Task.READY)[0].task_spec.description)
time.sleep(0.6)
self.workflow.refresh_waiting_tasks()
self.workflow.do_engine_steps()
self.assertEquals(1, len(self.workflow.get_tasks(Task.WAITING)))
self.assertEquals(2, len(self.workflow.get_tasks(Task.READY)))
self.do_next_named_step("Start Work")
self.workflow.do_engine_steps()
self.do_next_named_step("Complete Work", choice="Done")
self.workflow.do_engine_steps()
self.assertTrue(self.workflow.is_completed())
def testRunThroughOverdue(self):
self.do_next_exclusive_step("Review Action", choice='Approve')
self.workflow.do_engine_steps()
self.assertEquals(1, len(self.workflow.get_tasks(Task.WAITING)))
self.assertEquals(1, len(self.workflow.get_tasks(Task.READY)))
self.assertEquals('Cancel Action (if necessary)', self.workflow.get_tasks(Task.READY)[0].task_spec.description)
time.sleep(0.6)
self.workflow.refresh_waiting_tasks()
self.workflow.do_engine_steps()
self.assertEquals(1, len(self.workflow.get_tasks(Task.WAITING)))
self.assertEquals(2, len(self.workflow.get_tasks(Task.READY)))
self.do_next_named_step("Start Work")
self.workflow.do_engine_steps()
self.assertEquals(1, len(self.workflow.get_tasks(Task.WAITING)))
self.assertEquals('Finish Time', self.workflow.get_tasks(Task.WAITING)[0].task_spec.description)
time.sleep(1.1)
self.workflow.refresh_waiting_tasks()
self.workflow.do_engine_steps()
self.assertEquals(1, len(self.workflow.get_tasks(Task.WAITING)))
self.assertNotEquals('Finish Time', self.workflow.get_tasks(Task.WAITING)[0].task_spec.description)
overdue_escalation_task = [t for t in self.workflow.get_tasks() if t.task_spec.description=='Overdue Escalation']
self.assertEquals(1, len(overdue_escalation_task))
overdue_escalation_task = overdue_escalation_task[0]
self.assertEquals(Task.COMPLETED, overdue_escalation_task.state)
self.assertEquals('ACTION OVERDUE', overdue_escalation_task.get_data('script_output'))
self.do_next_named_step("Complete Work", choice="Done")
self.workflow.do_engine_steps()
self.assertTrue(self.workflow.is_completed())
def testRunThroughCancel(self):
self.do_next_exclusive_step("Review Action", choice='Cancel')
self.workflow.do_engine_steps()
self.assertTrue(self.workflow.is_completed())
def testRunThroughCancelAfterApproved(self):
self.do_next_exclusive_step("Review Action", choice='Approve')
self.workflow.do_engine_steps()
self.do_next_named_step("Cancel Action (if necessary)")
self.workflow.do_engine_steps()
self.assertTrue(self.workflow.is_completed())
self.assertEquals('ACTION CANCELLED', self.workflow.get_data('script_output'))
def testRunThroughCancelAfterWorkStarted(self):
self.do_next_exclusive_step("Review Action", choice='Approve')
self.workflow.do_engine_steps()
self.assertEquals(1, len(self.workflow.get_tasks(Task.WAITING)))
self.assertEquals(1, len(self.workflow.get_tasks(Task.READY)))
time.sleep(0.6)
self.workflow.refresh_waiting_tasks()
self.workflow.do_engine_steps()
self.assertEquals(1, len(self.workflow.get_tasks(Task.WAITING)))
self.assertEquals(2, len(self.workflow.get_tasks(Task.READY)))
self.do_next_named_step("Start Work")
self.workflow.do_engine_steps()
self.do_next_named_step("Cancel Action (if necessary)")
self.workflow.do_engine_steps()
self.assertTrue(self.workflow.is_completed())
self.assertEquals('ACTION CANCELLED', self.workflow.get_data('script_output'))
class MessageInterruptsTest(BpmnWorkflowTestCase):
def setUp(self):
self.spec = self.load_spec()
#self.spec.dump()
def load_spec(self):
return self.load_workflow_spec('Test-Workflows/*.bpmn20.xml',
'Test Workflows')
def testRunThroughHappySaveAndRestore(self):
self.workflow = BpmnWorkflow(self.spec)
self.save_restore()
self.do_next_exclusive_step('Select Test', choice='Message Interrupts')
self.workflow.do_engine_steps()
self.save_restore()
self.assertEquals(1, len(self.workflow.get_tasks(Task.READY)))
self.assertEquals(1, len(self.workflow.get_tasks(Task.WAITING)))
self.do_next_exclusive_step('Do Something That Takes A Long Time')
self.save_restore()
self.workflow.do_engine_steps()
self.assertEquals(0, len(self.workflow.get_tasks(Task.WAITING)))
self.save_restore()
self.workflow.do_engine_steps()
self.assertEquals(
0, len(self.workflow.get_tasks(Task.READY | Task.WAITING)))
def testRunThroughMessageInterruptSaveAndRestore(self):
self.workflow = BpmnWorkflow(self.spec)
self.save_restore()
self.do_next_exclusive_step('Select Test', choice='Message Interrupts')
self.workflow.do_engine_steps()
self.save_restore()
self.assertEquals(1, len(self.workflow.get_tasks(Task.READY)))
self.assertEquals(1, len(self.workflow.get_tasks(Task.WAITING)))
self.workflow.accept_message('Test Message')
self.save_restore()
self.workflow.do_engine_steps()
self.save_restore()
self.assertEquals(0, len(self.workflow.get_tasks(Task.WAITING)))
self.assertEquals(1, len(self.workflow.get_tasks(Task.READY)))
self.do_next_exclusive_step('Acknowledge Interrupt Message')
self.save_restore()
self.workflow.do_engine_steps()
self.save_restore()
self.assertEquals(
0, len(self.workflow.get_tasks(Task.READY | Task.WAITING)))
def testRunThroughHappy(self):
self.workflow = BpmnWorkflow(self.spec)
self.do_next_exclusive_step('Select Test', choice='Message Interrupts')
self.workflow.do_engine_steps()
self.assertEquals(1, len(self.workflow.get_tasks(Task.READY)))
self.assertEquals(1, len(self.workflow.get_tasks(Task.WAITING)))
self.do_next_exclusive_step('Do Something That Takes A Long Time')
self.workflow.do_engine_steps()
self.assertEquals(0, len(self.workflow.get_tasks(Task.WAITING)))
self.workflow.do_engine_steps()
self.assertEquals(
0, len(self.workflow.get_tasks(Task.READY | Task.WAITING)))
def testRunThroughMessageInterrupt(self):
self.workflow = BpmnWorkflow(self.spec)
self.do_next_exclusive_step('Select Test', choice='Message Interrupts')
self.workflow.do_engine_steps()
self.assertEquals(1, len(self.workflow.get_tasks(Task.READY)))
self.assertEquals(1, len(self.workflow.get_tasks(Task.WAITING)))
self.workflow.accept_message('Test Message')
self.workflow.do_engine_steps()
self.assertEquals(0, len(self.workflow.get_tasks(Task.WAITING)))
self.assertEquals(1, len(self.workflow.get_tasks(Task.READY)))
self.do_next_exclusive_step('Acknowledge Interrupt Message')
self.workflow.do_engine_steps()
self.assertEquals(
0, len(self.workflow.get_tasks(Task.READY | Task.WAITING)))
class ParallelThenExlusiveTest(BpmnWorkflowTestCase):
def setUp(self):
self.spec = self.load_spec()
def load_spec(self):
return self.load_workflow_spec('Test-Workflows/Parallel-Then-Exclusive.bpmn20.xml', 'Parallel Then Exclusive')
def testRunThroughParallelTaskFirst(self):
self.workflow = BpmnWorkflow(self.spec)
self.workflow.do_engine_steps()
self.assertEquals(2, len(self.workflow.get_tasks(Task.READY)))
self.do_next_named_step('Parallel Task')
self.workflow.do_engine_steps()
self.assertRaises(AssertionError, self.do_next_named_step, 'Done')
self.do_next_named_step('Choice 1', choice='Yes')
self.workflow.do_engine_steps()
self.do_next_named_step('Yes Task')
self.workflow.do_engine_steps()
self.do_next_named_step('Done')
self.workflow.do_engine_steps()
self.assertEquals(0, len(self.workflow.get_tasks(Task.READY | Task.WAITING)))
def testRunThroughChoiceFirst(self):
self.workflow = BpmnWorkflow(self.spec)
self.workflow.do_engine_steps()
self.assertEquals(2, len(self.workflow.get_tasks(Task.READY)))
self.do_next_named_step('Choice 1', choice='Yes')
self.workflow.do_engine_steps()
self.do_next_named_step('Parallel Task')
self.workflow.do_engine_steps()
self.assertRaises(AssertionError, self.do_next_named_step, 'Done')
self.do_next_named_step('Yes Task')
self.workflow.do_engine_steps()
self.do_next_named_step('Done')
self.workflow.do_engine_steps()
self.assertEquals(0, len(self.workflow.get_tasks(Task.READY | Task.WAITING)))
def testRunThroughChoiceThreadCompleteFirst(self):
self.workflow = BpmnWorkflow(self.spec)
self.workflow.do_engine_steps()
self.assertEquals(2, len(self.workflow.get_tasks(Task.READY)))
self.do_next_named_step('Choice 1', choice='Yes')
self.workflow.do_engine_steps()
self.do_next_named_step('Yes Task')
self.workflow.do_engine_steps()
self.assertRaises(AssertionError, self.do_next_named_step, 'Done')
self.do_next_named_step('Parallel Task')
self.workflow.do_engine_steps()
self.do_next_named_step('Done')
self.workflow.do_engine_steps()
self.assertEquals(0, len(self.workflow.get_tasks(Task.READY | Task.WAITING)))
