def test_cancelled_task(self):
"""
Task Count: 1
Statuses: Cancelled after 2 in progress polls
Results: 1 Cancelled
"""
# Setup
sim = TaskSimulator()
sim.install(self.bindings)
states = [STATE_WAITING, STATE_RUNNING, STATE_RUNNING, STATE_CANCELED]
sim.add_task_states('1', states)
# Test
task_list = sim.get_all_tasks().response_body
completed_tasks = self.command.poll(task_list, {})
# Verify
self.assertTrue(isinstance(completed_tasks, list))
self.assertEqual(1, len(completed_tasks))
expected_tags = ['abort', 'delayed-spinner', 'running-spinner', 'running-spinner',
'running-spinner','cancelled']
self.assertEqual(expected_tags, self.prompt.get_write_tags())
def test_poll_task_list(self):
"""
Task Count: 3
Statuses: None; normal progression
Result: All Success
"""
# Setup
sim = TaskSimulator()
sim.install(self.bindings)
states_1 = [STATE_WAITING, STATE_RUNNING, STATE_FINISHED]
states_2 = [STATE_WAITING, STATE_WAITING, STATE_RUNNING, STATE_FINISHED]
states_3 = [STATE_WAITING, STATE_RUNNING, STATE_RUNNING, STATE_RUNNING, STATE_FINISHED]
sim.add_task_states('1', states_1)
sim.add_task_states('2', states_2)
sim.add_task_states('3', states_3)
# Test
task_list = sim.get_all_tasks().response_body
completed_tasks = self.command.poll(task_list)
expected_tags = ['abort', # default, always displayed
'header', 'waiting', 'spinner', 'succeeded', # states_1
'header', 'waiting', 'spinner', 'waiting', 'spinner', 'succeeded', # states_2
'header', 'waiting', 'spinner', 'succeeded', # states_3
]
found_tags = self.prompt.get_write_tags()
self.assertEqual(expected_tags, found_tags)
self.assertTrue(isinstance(completed_tasks, list))
self.assertEqual(3, len(completed_tasks))
for i in range(0, 3):
self.assertEqual(STATE_FINISHED, completed_tasks[i].state)
def test_failed_task(self):
"""
Task Count: 3
Statuses: None, tasks will run to completion
Results: 1 Success, 1 Failed, 1 Skipped
"""
# Setup
sim = TaskSimulator()
sim.install(self.bindings)
states_1 = [STATE_WAITING, STATE_FINISHED]
states_2 = [STATE_WAITING, STATE_ERROR]
states_3 = [STATE_WAITING, STATE_SKIPPED]
sim.add_task_states('1', states_1)
sim.add_task_states('2', states_2)
sim.add_task_states('3', states_3)
# Test
task_list = sim.get_all_tasks().response_body
completed_tasks = self.command.poll(task_list, {})
# Verify
self.assertTrue(isinstance(completed_tasks, list))
self.assertEqual(2, len(completed_tasks))
expected_tags = ['abort',
'header', 'delayed-spinner', 'running-spinner', 'succeeded', # states_1
'header', 'delayed-spinner', 'running-spinner', 'failed', 'failed_exception', # states_2
]
self.assertEqual(expected_tags, self.prompt.get_write_tags())
def test_cancelled_task(self):
"""
Task Count: 1
Statuses: Cancelled after 2 in progress polls
Results: 1 Cancelled
"""
# Setup
sim = TaskSimulator()
sim.install(self.bindings)
states = [STATE_WAITING, STATE_RUNNING, STATE_RUNNING, STATE_CANCELED]
sim.add_task_states('1', states)
# Test
task_list = sim.get_all_tasks().response_body
completed_tasks = self.command.poll(task_list, {})
# Verify
self.assertTrue(isinstance(completed_tasks, list))
self.assertEqual(1, len(completed_tasks))
expected_tags = [
'abort', 'delayed-spinner', 'running-spinner', 'running-spinner',
'running-spinner', 'canceled'
]
self.assertEqual(expected_tags, self.prompt.get_write_tags())
def test_postponed_task(self):
"""
Task Count: 1
Statuses: Postponed (test will eventually run it)
Results: 1 Success
"""
# Setup
sim = TaskSimulator()
sim.install(self.bindings)
# Remain postponed for two polls and then runs successfully
sim.add_task_state('1', STATE_WAITING, response=RESPONSE_POSTPONED)
sim.add_task_state('1', STATE_WAITING, response=RESPONSE_POSTPONED)
states = [STATE_RUNNING, STATE_FINISHED]
sim.add_task_states('1', states)
# Test
task_list = sim.get_all_tasks().response_body
completed_tasks = self.command.poll(task_list, {})
# Verify
self.assertTrue(isinstance(completed_tasks, list))
self.assertEqual(1, len(completed_tasks))
expected_tags = ['abort', 'delayed-spinner', 'delayed-spinner', 'running-spinner',
'running-spinner', 'succeeded']
self.assertEqual(expected_tags, self.prompt.get_write_tags())
def test_poll_task_list(self):
"""
Task Count: 3
Statuses: None; normal progression
Result: All Success
"""
# Setup
sim = TaskSimulator()
sim.install(self.bindings)
states_1 = [STATE_WAITING, STATE_RUNNING, STATE_FINISHED]
states_2 = [
STATE_WAITING, STATE_WAITING, STATE_RUNNING, STATE_FINISHED
]
states_3 = [
STATE_WAITING, STATE_RUNNING, STATE_RUNNING, STATE_RUNNING,
STATE_FINISHED
]
sim.add_task_states('1', states_1)
sim.add_task_states('2', states_2)
sim.add_task_states('3', states_3)
# Test
task_list = sim.get_all_tasks().response_body
completed_tasks = self.command.poll(task_list, {})
expected_tags = [
'abort', # default, always displayed
# states_1
'header',
'delayed-spinner',
'running-spinner',
'running-spinner',
'succeeded',
# states_2
'header',
'delayed-spinner',
'delayed-spinner',
'running-spinner',
'running-spinner',
'succeeded',
# states_3
'header',
'delayed-spinner',
'running-spinner',
'running-spinner',
'running-spinner',
'running-spinner',
'succeeded'
]
found_tags = self.prompt.get_write_tags()
self.assertEqual(set(expected_tags), set(found_tags))
self.assertTrue(isinstance(completed_tasks, list))
self.assertEqual(3, len(completed_tasks))
for i in range(0, 3):
self.assertEqual(STATE_FINISHED, completed_tasks[i].state)
def test_get_task(self):
# Setup
task_id = "123"
states = ["waiting", "running", "success"]
sim = TaskSimulator()
sim.add_task_states(task_id, states)
# Test & Verify
for state in states:
task = sim.get_task(task_id).response_body
self.assertEqual(task.state, state)
self.assertEqual(0, len(sim.tasks_by_id[task_id]))
def test_get_task(self):
# Setup
task_id = '123'
states = ['waiting', 'running', 'success']
sim = TaskSimulator()
sim.add_task_states(task_id, states)
# Test & Verify
for state in states:
task = sim.get_task(task_id).response_body
self.assertEqual(task.state, state)
self.assertEqual(0, len(sim.tasks_by_id[task_id]))
def test_get_all_tasks(self):
# Setup
sim = TaskSimulator()
for i in range(0, 3):
task_id = 'task-%s' % i
states = ['state-%s' % i]
sim.add_task_states(task_id, states)
# Test
all_tasks = sim.get_all_tasks().response_body
# Order is important here, they should be returned in the same order added
for i in range(0, 3):
task = all_tasks[i]
self.assertEqual(task.task_id, 'task-%s' % i)
def test_get_all_tasks(self):
# Setup
sim = TaskSimulator()
for i in range(0, 3):
task_id = "task-%s" % i
states = ["state-%s" % i]
sim.add_task_states(task_id, states)
# Test
all_tasks = sim.get_all_tasks().response_body
# Order is important here, they should be returned in the same order added
for i in range(0, 3):
task = all_tasks[i]
self.assertEqual(task.task_id, "task-%s" % i)
def test_poll_single_task(self, mock_sleep):
"""
Task Count: 1
Statuses: None; normal progression of waiting to running to completed
Result: Success
This test verifies the sleep and progress callback calls, which will be omitted
in most other tests cases where appropriate.
"""
# Setup
sim = TaskSimulator()
sim.install(self.bindings)
task_id = '123'
state_progression = [
STATE_WAITING, STATE_ACCEPTED, STATE_RUNNING, STATE_RUNNING,
STATE_FINISHED
]
sim.add_task_states(task_id, state_progression)
mock_progress_call = mock.MagicMock().progress
self.command.progress = mock_progress_call
# Test
task_list = sim.get_all_tasks().response_body
completed_tasks = self.command.poll(task_list, {})
# Verify
# The "header" tag should not be present since no headers are needed for single tasks
expected_tags = [
'abort', 'delayed-spinner', 'delayed-spinner', 'succeeded'
]
self.assertEqual(self.prompt.get_write_tags(), expected_tags)
self.assertEqual(4,
mock_sleep.call_count) # 2 for waiting, 2 for running
self.assertEqual(mock_sleep.call_args_list[0][0][0],
0) # frequency passed to sleep
self.assertEqual(3,
mock_progress_call.call_count) # 2 running, 1 final
self.assertTrue(isinstance(completed_tasks, list))
self.assertEqual(1, len(completed_tasks))
self.assertEqual(STATE_FINISHED, completed_tasks[0].state)
def test_poll_additional_spawned_tasks_list(self):
"""
Test polling over a list where a task has spawned additional tasks that need to be
added to the polling list
Task Count: 3
Statuses: None; normal progression
Result: All Success
"""
# Setup
sim = TaskSimulator()
sim.install(self.bindings)
states_1 = [STATE_WAITING, STATE_RUNNING, STATE_FINISHED]
states_2 = [STATE_WAITING, STATE_WAITING, STATE_RUNNING, STATE_FINISHED]
states_3 = [STATE_WAITING, STATE_RUNNING, STATE_RUNNING, STATE_RUNNING, STATE_FINISHED]
task_1_states = sim.add_task_states('1', states_1)
sim.add_task_states('2', states_2)
sim.add_task_states('3', states_3)
container_task = Task({})
task_list = sim.get_all_tasks().response_body
task_1_states[2].spawned_tasks = task_list[1:]
# Test
container_task.spawned_tasks = sim.get_all_tasks().response_body
completed_tasks = self.command.poll(task_list[:1], {})
expected_tags = ['abort', # default, always displayed
# states_1
'delayed-spinner', 'running-spinner', 'succeeded',
# states_2
'header', 'delayed-spinner', 'running-spinner', 'running-spinner',
'succeeded',
# states_3
'header', 'delayed-spinner', 'running-spinner', 'running-spinner',
'running-spinner', 'succeeded',
]
found_tags = self.prompt.get_write_tags()
self.assertEqual(expected_tags, found_tags)
self.assertTrue(isinstance(completed_tasks, list))
self.assertEqual(3, len(completed_tasks))
for i in range(0, 3):
self.assertEqual(STATE_FINISHED, completed_tasks[i].state)
def test_poll_spawned_tasks_list(self):
"""
Test the structure where a command has both synchronous and asynchronous sections
and returns a task structure with a result and a spawned_tasks list
Task Count: 3
Statuses: None; normal progression
Result: All Success
"""
# Setup
sim = TaskSimulator()
sim.install(self.bindings)
states_1 = [STATE_WAITING, STATE_RUNNING, STATE_FINISHED]
states_2 = [STATE_WAITING, STATE_WAITING, STATE_RUNNING, STATE_FINISHED]
states_3 = [STATE_WAITING, STATE_RUNNING, STATE_RUNNING, STATE_RUNNING, STATE_FINISHED]
sim.add_task_states('1', states_1)
sim.add_task_states('2', states_2)
sim.add_task_states('3', states_3)
container_task = Task({})
# Test
container_task.spawned_tasks = sim.get_all_tasks().response_body
completed_tasks = self.command.poll(container_task, {})
expected_tags = ['abort', # default, always displayed
# states_1
'header', 'delayed-spinner', 'running-spinner', 'running-spinner', 'succeeded',
# states_2
'header', 'delayed-spinner', 'delayed-spinner', 'running-spinner', 'running-spinner',
'succeeded',
# states_3
'header', 'delayed-spinner', 'running-spinner', 'running-spinner',
'running-spinner', 'running-spinner', 'succeeded',
]
found_tags = self.prompt.get_write_tags()
self.assertEqual(expected_tags, found_tags)
self.assertTrue(isinstance(completed_tasks, list))
self.assertEqual(3, len(completed_tasks))
for i in range(0, 3):
self.assertEqual(STATE_FINISHED, completed_tasks[i].state)
def test_poll_single_task(self, mock_sleep):
"""
Task Count: 1
Statuses: None; normal progression of waiting to running to completed
Result: Success
This test verifies the sleep and progress callback calls, which will be omitted
in most other tests cases where appropriate.
"""
# Setup
sim = TaskSimulator()
sim.install(self.bindings)
task_id = '123'
state_progression = [STATE_WAITING,
STATE_WAITING,
STATE_RUNNING,
STATE_RUNNING,
STATE_FINISHED]
sim.add_task_states(task_id, state_progression)
mock_progress_call = mock.MagicMock().progress
self.command.progress = mock_progress_call
# Test
task_list = sim.get_all_tasks().response_body
completed_tasks = self.command.poll(task_list, {})
# Verify
# The "header" tag should not be present since no headers are needed for single tasks
expected_tags = ['abort', 'delayed-spinner', 'delayed-spinner', 'succeeded']
self.assertEqual(self.prompt.get_write_tags(), expected_tags)
self.assertEqual(4, mock_sleep.call_count) # 2 for waiting, 2 for running
self.assertEqual(mock_sleep.call_args_list[0][0][0], 0) # frequency passed to sleep
self.assertEqual(3, mock_progress_call.call_count) # 2 running, 1 final
self.assertTrue(isinstance(completed_tasks, list))
self.assertEqual(1, len(completed_tasks))
self.assertEqual(STATE_FINISHED, completed_tasks[0].state)
def test_add_task_states(self):
# Setup
task_id = '123'
states = ['waiting', 'running']
# Test
sim = TaskSimulator()
sim.add_task_states(task_id, states)
# Verify
self.assertTrue(task_id in sim.ordered_task_ids)
self.assertTrue(task_id in sim.tasks_by_id)
self.assertTrue(len(states), len(sim.tasks_by_id[task_id]))
# Stored in reverse order
states.reverse()
for index, state in enumerate(states):
task = sim.tasks_by_id[task_id][index]
self.assertEqual(task.state, state)
def test_add_task_states(self):
# Setup
task_id = "123"
states = ["waiting", "running"]
# Test
sim = TaskSimulator()
sim.add_task_states(task_id, states)
# Verify
self.assertTrue(task_id in sim.ordered_task_ids)
self.assertTrue(task_id in sim.tasks_by_id)
self.assertTrue(len(states), len(sim.tasks_by_id[task_id]))
# Stored in reverse order
states.reverse()
for index, state in enumerate(states):
task = sim.tasks_by_id[task_id][index]
self.assertEqual(task.state, state)
def test_poll_spawned_tasks_list(self):
"""
Test the structure where a command has both synchronous and asynchronous sections
and returns a task structure with a result and a spawned_tasks list
Task Count: 3
Statuses: None; normal progression
Result: All Success
"""
# Setup
sim = TaskSimulator()
sim.install(self.bindings)
states_1 = [STATE_WAITING, STATE_RUNNING, STATE_FINISHED]
states_2 = [
STATE_WAITING, STATE_WAITING, STATE_RUNNING, STATE_FINISHED
]
states_3 = [
STATE_WAITING, STATE_RUNNING, STATE_RUNNING, STATE_RUNNING,
STATE_FINISHED
]
sim.add_task_states('1', states_1)
sim.add_task_states('2', states_2)
sim.add_task_states('3', states_3)
container_task = Task({})
# Test
container_task.spawned_tasks = sim.get_all_tasks().response_body
completed_tasks = self.command.poll(container_task, {})
expected_tags = [
'abort', # default, always displayed
# states_1
'header',
'delayed-spinner',
'running-spinner',
'running-spinner',
'succeeded',
# states_2
'header',
'delayed-spinner',
'delayed-spinner',
'running-spinner',
'running-spinner',
'succeeded',
# states_3
'header',
'delayed-spinner',
'running-spinner',
'running-spinner',
'running-spinner',
'running-spinner',
'succeeded',
]
found_tags = self.prompt.get_write_tags()
self.assertEqual(set(expected_tags), set(found_tags))
self.assertTrue(isinstance(completed_tasks, list))
self.assertEqual(3, len(completed_tasks))
for i in range(0, 3):
self.assertEqual(STATE_FINISHED, completed_tasks[i].state)
def test_poll_additional_spawned_tasks_list(self):
"""
Test polling over a list where a task has spawned additional tasks that need to be
added to the polling list
Task Count: 3
Statuses: None; normal progression
Result: All Success
"""
# Setup
sim = TaskSimulator()
sim.install(self.bindings)
states_1 = [STATE_WAITING, STATE_RUNNING, STATE_FINISHED]
states_2 = [
STATE_WAITING, STATE_WAITING, STATE_RUNNING, STATE_FINISHED
]
states_3 = [
STATE_WAITING, STATE_RUNNING, STATE_RUNNING, STATE_RUNNING,
STATE_FINISHED
]
task_1_states = sim.add_task_states('1', states_1)
sim.add_task_states('2', states_2)
sim.add_task_states('3', states_3)
container_task = Task({})
task_list = sim.get_all_tasks().response_body
task_1_states[2].spawned_tasks = task_list[1:]
# Test
container_task.spawned_tasks = sim.get_all_tasks().response_body
completed_tasks = self.command.poll(task_list[:1], {})
expected_tags = [
'abort', # default, always displayed
# states_1
'delayed-spinner',
'running-spinner',
'succeeded',
# states_2
'header',
'delayed-spinner',
'running-spinner',
'running-spinner',
'succeeded',
# states_3
'header',
'delayed-spinner',
'running-spinner',
'running-spinner',
'running-spinner',
'succeeded'
]
found_tags = self.prompt.get_write_tags()
self.assertEqual(set(expected_tags), set(found_tags))
self.assertTrue(isinstance(completed_tasks, list))
self.assertEqual(3, len(completed_tasks))
for i in range(0, 3):
self.assertEqual(STATE_FINISHED, completed_tasks[i].state)
