def test_from_tree_string(self):
simple_plan_string = "task0\n\ttask1\ntask2"
print(simple_plan_string)
e = ExecutionPlan().from_tree_string(simple_plan_string)
#print(e.plan_as_dict_array)
print(e.as_tree_string())
self.assertEqual(simple_plan_string,
e.as_tree_string().replace(
" Ready ",
"")[:-1]) # str returns string with trailing \n
def test_as_gantt(self):
e = ExecutionPlan().from_dict_array(self.tasks_dict_array)
def complete_a_task():
t = e.ready_tasks()[0]
e.mark_started(t)
time.sleep(1)
e.mark_completed(t)
for task in e.plan_as_dict_array:
complete_a_task()
print(e)
print(e.as_gantt())
def test_low_granularity_execution(self):
async def print_task(loop, task):
print("Executing task {}".format(task['name']))
await asyncio.sleep(0)
async def delayed_task(loop, task):
print("Executing task {}".format(task['name']))
await asyncio.sleep(0.1)
plan = ExecutionPlan().from_dict_array(self.tasks_dict_array)
print("\nBEFORE EXECUTION\n{}".format(plan))
Executor(plan, 2, 0.01, print_task).trigger_execution()
print("\nAFTER EXECUTION\n{}".format(plan))
self.assertEqual(
plan.is_incomplete(), False,
"Simple plan has been marked complete during low granularity execution"
)
map(
lambda x: self.assertIn(x, plan.completed_tasks(),
"Task {} has been completed".format(x)),
[x for x in range(0, len(plan.plan_as_dict_array))])
plan = ExecutionPlan().from_dict_array(self.tasks_dict_array)
print("\nBEFORE EXECUTION\n{}".format(plan))
Executor(plan, 3, 0.01, delayed_task).trigger_execution()
print("\nAFTER EXECUTION\n{}".format(plan))
self.assertEqual(
plan.is_incomplete(), False,
"Long plan has been marked complete during low granularity execution"
)
map(
lambda x: self.assertIn(x, plan.completed_tasks(),
"Task {} has been completed".format(x)),
[x for x in range(0, len(plan.plan_as_dict_array))])
def test_simple_execution(self):
async def print_task(loop, task):
print("Executing task {}".format(task))
await asyncio.sleep(0.1)
plan = ExecutionPlan().from_dict_array(self.tasks_dict_array)
print("\nBEFORE EXECUTION\n{}".format(plan))
Executor(plan, 2, 0.01, print_task).trigger_execution()
print("\nAFTER EXECUTION\n{}".format(plan.as_gantt()))
self.assertEqual(plan.is_incomplete(), False,
"Plan has been marked complete")
map(
lambda x: self.assertIn(x, plan.completed_tasks(),
"Task {} has been completed".format(x)),
[x for x in range(0, len(plan.plan_as_dict_array))])
def test_multi_random_data_execution(self):
async def delayed_task(loop, task):
duration = random.randint(1, 3)
print("Executing task {0} for {1} deciseconds".format(
task['name'], duration))
await asyncio.sleep(float(duration / 10))
def times_tab(n):
return "".join(["\t" for x in range(0, n)])
for q in range(0, 10):
tree_str = "task1\n"
prev_indent_level = 0
for i in range(1, 7):
if prev_indent_level == 0:
indent_level = prev_indent_level + random.randint(0, 1)
else:
indent_level = prev_indent_level + random.randint(-1, 1)
tree_str += "{0}task{1}".format(times_tab(indent_level),
i + 1) + "\n"
prev_indent_level = indent_level
plan = ExecutionPlan().from_tree_string(tree_str[:-1])
print("PLAN\n{}".format(plan))
max_concurrency = random.randint(1, 5)
granularity = 1 / (10**random.randint(1, 4))
print("\nExecuting with {0} threads, {1} granularity".format(
max_concurrency, granularity))
Executor(plan, max_concurrency, granularity,
delayed_task).trigger_execution()
self.assertEqual(plan.is_incomplete(), False,
"Plan has been marked complete")
for i in range(0, len(plan.plan_as_dict_array)):
self.assertIn(i, plan.completed_list,
"Task {} has been completed".format(i))
for j in plan.get_dependants(i):
self.assertGreaterEqual(
plan.plan_as_dict_array[j]['start_time'],
plan.plan_as_dict_array[i]['end_time'],
"Task {0} started after Task {1} ended".format(j, i))
print(plan.as_gantt())
def test_ready_tasks_till_empty(self):
e = ExecutionPlan().from_dict_array(self.tasks_dict_array)
print("Till empty ready test plan\n" + str(e))
print(e.ready_tasks())
t = e.ready_tasks()[0]
e.mark_started(t)
e.mark_completed(t)
print(e.ready_tasks())
t = e.ready_tasks()[0]
e.mark_started(t)
e.mark_completed(t)
print(e.ready_tasks())
t = e.ready_tasks()[0]
e.mark_started(t)
e.mark_completed(t)
print(e.ready_tasks())
t = e.ready_tasks()[0]
e.mark_started(t)
e.mark_completed(t)
print(e.ready_tasks())
t = e.ready_tasks()[0]
e.mark_started(t)
e.mark_completed(t)
self.assertEqual(len(e.ready_tasks()), 0, "ready tasks till empty")
def test_ready_tasks_two_plans(self):
e1 = ExecutionPlan().from_dict_array(self.tasks_dict_array)
e2 = ExecutionPlan().from_dict_array(self.tasks_dict_array)
print("Twin ready test plan\n" + str(e1) + "\n" + str(e2))
print(e1.ready_tasks())
t = e1.ready_tasks()[0]
e1.mark_started(t)
e1.mark_completed(t)
print(e1.ready_tasks())
t = e1.ready_tasks()[0]
e1.mark_started(t)
e1.mark_completed(t)
self.assertEqual(len(e1.ready_tasks()), 3,
"ready tasks plan 1(modified)")
self.assertEqual(len(e2.ready_tasks()), 2,
"ready tasks plan 2 (unmodified)")
def test_ready_tasks_simple(self):
e = ExecutionPlan().from_dict_array(self.tasks_dict_array)
print("Simple ready test plan \n" + str(e))
print(e.ready_tasks())
t = e.ready_tasks()[0]
e.mark_started(t)
e.mark_completed(t)
print(e.ready_tasks())
t = e.ready_tasks()[0]
e.mark_started(t)
e.mark_completed(t)
self.assertEqual(len(e.ready_tasks()), 3, "ready tasks simple case")
def test___str__(self):
execution_plan = ExecutionPlan().from_dict_array(self.tasks_dict_array)
print("Printing plan...\n" + str(execution_plan))
def test_as_json(self):
e = ExecutionPlan().from_dict_array(self.tasks_dict_array)
t = e.ready_tasks()[0]
e.mark_started(t)
time.sleep(2)
e.mark_completed(t)
t = e.ready_tasks()[0]
e.mark_started(t)
time.sleep(1)
e.mark_completed(t)
print(e)
print(e.as_json())