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)