def testCollisionError(self):
builder_a = task_manager.Builder(self.output_directory, None)
builder_b = task_manager.Builder(self.output_directory, None)
@builder_a.RegisterTask('a')
def TaskA():
pass
@builder_b.RegisterTask('a')
def TaskB():
pass
with self.assertRaises(task_manager.TaskError):
task_manager.GenerateScenario([TaskA, TaskB], set())
def testGraphVizOutput(self):
builder = task_manager.Builder(self.output_directory, None)
@builder.RegisterTask('a')
def TaskA():
pass
@builder.RegisterTask('b')
def TaskB():
pass
@builder.RegisterTask('c', dependencies=[TaskB, TaskA])
def TaskC():
pass
@builder.RegisterTask('d', dependencies=[TaskC])
def TaskD():
pass
@builder.RegisterTask('e')
def TaskE():
pass
@builder.RegisterTask('f', dependencies=[TaskD, TaskE])
def TaskF():
pass
self.TouchOutputFile('e')
scenario = task_manager.GenerateScenario([TaskF], set([TaskE]))
output = StringIO.StringIO()
task_manager.OutputGraphViz(scenario, [TaskF], output)
self.assertEqual(_GOLDEN_GRAPHVIZ, output.getvalue())
def testGenerateDependentSetPerTask(self):
builder = task_manager.Builder(self.output_directory, None)
@builder.RegisterTask('a')
def TaskA():
pass
@builder.RegisterTask('b')
def TaskB():
pass
@builder.RegisterTask('c', dependencies=[TaskA, TaskB])
def TaskC():
pass
@builder.RegisterTask('d', dependencies=[TaskA])
def TaskD():
pass
def RunSubTest(expected, scenario, task):
self.assertEqual(
expected,
task_manager.GenerateDependentSetPerTask(scenario)[task])
RunSubTest(set([]), [TaskA], TaskA)
RunSubTest(set([]), [TaskA, TaskB], TaskA)
RunSubTest(set([TaskC]), [TaskA, TaskB, TaskC], TaskA)
RunSubTest(set([TaskC, TaskD]), [TaskA, TaskB, TaskC, TaskD], TaskA)
RunSubTest(set([]), [TaskA, TaskD], TaskD)
def testFreezing(self):
builder = task_manager.Builder(self.output_directory, None)
@builder.RegisterTask('a')
def TaskA():
pass
@builder.RegisterTask('b', dependencies=[TaskA])
def TaskB():
pass
@builder.RegisterTask('c')
def TaskC():
pass
@builder.RegisterTask('d', dependencies=[TaskB, TaskC])
def TaskD():
pass
# assert no exception raised.
task_manager.GenerateScenario([TaskB], set([TaskC]))
with self.assertRaises(task_manager.TaskError):
task_manager.GenerateScenario([TaskD], set([TaskA]))
self.TouchOutputFile('a')
scenario = task_manager.GenerateScenario([TaskD], set([TaskA]))
self.assertListEqual([TaskB, TaskC, TaskD], scenario)
self.TouchOutputFile('b')
scenario = task_manager.GenerateScenario([TaskD], set([TaskB]))
self.assertListEqual([TaskC, TaskD], scenario)
def testParents(self):
builder = task_manager.Builder(self.output_directory, None)
@builder.RegisterTask('a')
def TaskA():
pass
@builder.RegisterTask('b', dependencies=[TaskA])
def TaskB():
pass
@builder.RegisterTask('c', dependencies=[TaskB])
def TaskC():
pass
scenario = task_manager.GenerateScenario([TaskA, TaskB, TaskC], set())
self.assertListEqual([TaskA, TaskB, TaskC], scenario)
scenario = task_manager.GenerateScenario([TaskB], set())
self.assertListEqual([TaskA, TaskB], scenario)
scenario = task_manager.GenerateScenario([TaskC], set())
self.assertListEqual([TaskA, TaskB, TaskC], scenario)
scenario = task_manager.GenerateScenario([TaskC, TaskB], set())
self.assertListEqual([TaskA, TaskB, TaskC], scenario)
def testStaticTaskMergingError(self):
builder = task_manager.Builder(self.output_directory)
builder.CreateStaticTask('hello.py', __file__)
with self.assertRaises(task_manager.TaskError):
@builder.RegisterTask('hello.py', merge=True)
def TaskA():
pass
del TaskA # unused
def testListResumingTasksToFreeze(self):
TaskManagerTestCase.setUp(self)
builder = task_manager.Builder(self.output_directory, None)
@builder.RegisterTask('a')
def TaskA():
pass
@builder.RegisterTask('b')
def TaskB():
pass
@builder.RegisterTask('c', dependencies=[TaskA, TaskB])
def TaskC():
pass
@builder.RegisterTask('d', dependencies=[TaskA])
def TaskD():
pass
@builder.RegisterTask('e', dependencies=[TaskC])
def TaskE():
pass
@builder.RegisterTask('f', dependencies=[TaskC])
def TaskF():
pass
for k in 'abcdef':
self.TouchOutputFile(k)
def RunSubTest(final_tasks, initial_frozen_tasks, skipped_tasks,
reference):
scenario = task_manager.GenerateScenario(final_tasks,
initial_frozen_tasks)
resume_frozen_tasks = task_manager.ListResumingTasksToFreeze(
scenario, final_tasks, skipped_tasks)
self.assertEqual(reference, resume_frozen_tasks)
new_scenario = \
task_manager.GenerateScenario(final_tasks, resume_frozen_tasks)
self.assertEqual(skipped_tasks, set(new_scenario))
RunSubTest([TaskA], set([]), set([TaskA]), [])
RunSubTest([TaskD], set([]), set([TaskA, TaskD]), [])
RunSubTest([TaskD], set([]), set([TaskD]), [TaskA])
RunSubTest([TaskE, TaskF], set([TaskA]),
set([TaskB, TaskC, TaskE, TaskF]), [TaskA])
RunSubTest([TaskE, TaskF], set([TaskA]), set([TaskC, TaskE, TaskF]),
[TaskA, TaskB])
RunSubTest([TaskE, TaskF], set([TaskA]), set([TaskE, TaskF]), [TaskC])
RunSubTest([TaskE, TaskF], set([TaskA]), set([TaskF]), [TaskE, TaskC])
RunSubTest([TaskD, TaskE, TaskF], set([]), set([TaskD, TaskF]),
[TaskA, TaskE, TaskC])
def testTaskMerging(self):
builder = task_manager.Builder(self.output_directory, None)
@builder.RegisterTask('hello.txt')
def TaskA():
pass
@builder.RegisterTask('hello.txt', merge=True)
def TaskB():
pass
self.assertEqual(TaskA, TaskB)
def testListResumingTasksToFreeze(self):
TaskManagerTestCase.setUp(self)
builder = task_manager.Builder(self.output_directory)
static_task = builder.CreateStaticTask('static', __file__)
@builder.RegisterTask('a')
def TaskA():
pass
@builder.RegisterTask('b', dependencies=[static_task])
def TaskB():
pass
@builder.RegisterTask('c', dependencies=[TaskA, TaskB])
def TaskC():
pass
@builder.RegisterTask('d', dependencies=[TaskA])
def TaskD():
pass
@builder.RegisterTask('e', dependencies=[TaskC])
def TaskE():
pass
@builder.RegisterTask('f', dependencies=[TaskC])
def TaskF():
pass
for k in 'abcdef':
self.TouchOutputFile(k)
def RunSubTest(final_tasks, initial_frozen_tasks, failed_task,
reference):
scenario = \
task_manager.GenerateScenario(final_tasks, initial_frozen_tasks)
resume_frozen_tasks = task_manager.ListResumingTasksToFreeze(
scenario, final_tasks, failed_task)
self.assertEqual(reference, resume_frozen_tasks)
failed_pos = scenario.index(failed_task)
new_scenario = \
task_manager.GenerateScenario(final_tasks, resume_frozen_tasks)
self.assertEqual(scenario[failed_pos:], new_scenario)
RunSubTest([TaskA], set([]), TaskA, set([]))
RunSubTest([TaskD], set([]), TaskA, set([]))
RunSubTest([TaskD], set([]), TaskD, set([TaskA]))
RunSubTest([TaskE, TaskF], set([TaskA]), TaskB, set([TaskA]))
RunSubTest([TaskE, TaskF], set([TaskA]), TaskC, set([TaskA, TaskB]))
RunSubTest([TaskE, TaskF], set([TaskA]), TaskE, set([TaskC]))
RunSubTest([TaskE, TaskF], set([TaskA]), TaskF, set([TaskC, TaskE]))
def testRegisterTask(self):
builder = task_manager.Builder(self.output_directory, None)
@builder.RegisterTask('hello.txt')
def TaskA():
TaskA.executed = True
TaskA.executed = False
self.assertEqual(os.path.join(self.output_directory, 'hello.txt'),
TaskA.path)
self.assertFalse(TaskA.executed)
TaskA.Execute()
self.assertTrue(TaskA.executed)
def testRegisterDuplicateTask(self):
builder = task_manager.Builder(self.output_directory, None)
@builder.RegisterTask('hello.txt')
def TaskA():
pass
del TaskA # unused
with self.assertRaises(task_manager.TaskError):
@builder.RegisterTask('hello.txt')
def TaskB():
pass
del TaskB # unused
def testOutputSubdirectory(self):
builder = task_manager.Builder(self.output_directory, 'subdir')
@builder.RegisterTask('world.txt')
def TaskA():
pass
del TaskA # unused
self.assertIn('subdir/world.txt', builder._tasks)
self.assertNotIn('subdir/subdir/world.txt', builder._tasks)
self.assertNotIn('world.txt', builder._tasks)
@builder.RegisterTask('subdir/world.txt')
def TaskB():
pass
del TaskB # unused
self.assertIn('subdir/subdir/world.txt', builder._tasks)
self.assertNotIn('world.txt', builder._tasks)
def testCycleError(self):
builder = task_manager.Builder(self.output_directory, None)
@builder.RegisterTask('a')
def TaskA():
pass
@builder.RegisterTask('b', dependencies=[TaskA])
def TaskB():
pass
@builder.RegisterTask('c', dependencies=[TaskB])
def TaskC():
pass
@builder.RegisterTask('d', dependencies=[TaskC])
def TaskD():
pass
TaskA._dependencies.append(TaskC)
with self.assertRaises(task_manager.TaskError):
task_manager.GenerateScenario([TaskD], set())
def Execute(self, *command_line_args):
builder = task_manager.Builder(self.output_directory)
@builder.RegisterTask('a')
def TaskA():
pass
@builder.RegisterTask('b')
def TaskB():
pass
@builder.RegisterTask('c', dependencies=[TaskA, TaskB])
def TaskC():
pass
@builder.RegisterTask('d', dependencies=[TaskA])
def TaskD():
pass
@builder.RegisterTask('e', dependencies=[TaskC])
def TaskE():
pass
@builder.RegisterTask('raise_exception', dependencies=[TaskB])
def TaskF():
raise TestException('Expected error.')
default_final_tasks = [TaskD, TaskE]
parser = task_manager.CommandLineParser()
cmd = ['-o', self.output_directory]
cmd.extend([i for i in command_line_args])
args = parser.parse_args(cmd)
with EatStdoutAndStderr():
return task_manager.ExecuteWithCommandLine(
args, [TaskA, TaskB, TaskC, TaskD, TaskE, TaskF],
default_final_tasks)
def testCreateStaticTask(self):
builder = task_manager.Builder(self.output_directory)
task = builder.CreateStaticTask('hello.py', __file__)
self.assertTrue(task.IsStatic())
def testDuplicateStaticTask(self):
builder = task_manager.Builder(self.output_directory)
builder.CreateStaticTask('hello.py', __file__)
with self.assertRaises(task_manager.TaskError):
builder.CreateStaticTask('hello.py', __file__)
def Execute(self, command_line_args):
self.task_execution_history = []
builder = task_manager.Builder(self.output_directory, None)
@builder.RegisterTask('a')
def TaskA():
self.task_execution_history.append(TaskA.name)
@builder.RegisterTask('b')
def TaskB():
self.task_execution_history.append(TaskB.name)
@builder.RegisterTask('c', dependencies=[TaskA, TaskB])
def TaskC():
self.task_execution_history.append(TaskC.name)
@builder.RegisterTask('d', dependencies=[TaskA])
def TaskD():
self.task_execution_history.append(TaskD.name)
@builder.RegisterTask('e', dependencies=[TaskC])
def TaskE():
self.task_execution_history.append(TaskE.name)
@builder.RegisterTask('raise_exception', dependencies=[TaskD])
def RaiseExceptionTask():
self.task_execution_history.append(RaiseExceptionTask.name)
raise TestException('Expected error.')
@builder.RegisterTask('raise_keyboard_interrupt', dependencies=[TaskD])
def RaiseKeyboardInterruptTask():
self.task_execution_history.append(RaiseKeyboardInterruptTask.name)
raise KeyboardInterrupt
@builder.RegisterTask('sudden_death', dependencies=[TaskD])
def SimulateKillTask():
self.task_execution_history.append(SimulateKillTask.name)
raise MemoryError
@builder.RegisterTask('timeout_error', dependencies=[TaskD])
def SimulateTimeoutError():
self.task_execution_history.append(SimulateTimeoutError.name)
raise common_util.TimeoutError
@builder.RegisterTask('errno_ENOSPC', dependencies=[TaskD])
def SimulateENOSPC():
self.task_execution_history.append(SimulateENOSPC.name)
raise IOError(errno.ENOSPC, os.strerror(errno.ENOSPC))
@builder.RegisterTask('errno_EPERM', dependencies=[TaskD])
def SimulateEPERM():
self.task_execution_history.append(SimulateEPERM.name)
raise IOError(errno.EPERM, os.strerror(errno.EPERM))
default_final_tasks = [TaskD, TaskE]
if self.with_raise_exception_tasks:
default_final_tasks.extend([
RaiseExceptionTask, RaiseKeyboardInterruptTask,
SimulateKillTask, SimulateTimeoutError, SimulateENOSPC,
SimulateEPERM
])
task_parser = task_manager.CommandLineParser()
parser = argparse.ArgumentParser(
parents=[task_parser],
fromfile_prefix_chars=task_manager.FROMFILE_PREFIX_CHARS)
cmd = ['-o', self.output_directory]
cmd.extend([i for i in command_line_args])
args = parser.parse_args(cmd)
with EatStdoutAndStderr():
return task_manager.ExecuteWithCommandLine(args,
default_final_tasks)
def testCreateUnexistingStaticTask(self):
builder = task_manager.Builder(self.output_directory)
with self.assertRaises(task_manager.TaskError):
builder.CreateStaticTask('hello.txt', '/__unexisting/file/path')
