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_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_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_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_get_tasks_to_poll_duplicate_tasks(self): sim = TaskSimulator() sim.add_task_state('1', STATE_FINISHED) task_list = sim.get_all_tasks().response_body tasks_to_poll = self.command._get_tasks_to_poll([task_list[0], task_list[0]]) self.assertEquals(1, len(tasks_to_poll))
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 # 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(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_get_tasks_to_poll_duplicate_tasks(self): sim = TaskSimulator() sim.add_task_state('1', STATE_FINISHED) task_list = sim.get_all_tasks().response_body tasks_to_poll = self.command._get_tasks_to_poll( [task_list[0], task_list[0]]) self.assertEquals(1, len(tasks_to_poll))
def test_get_tasks_to_poll_source_task_list(self): sim = TaskSimulator() sim.add_task_state('1', STATE_FINISHED) sim.add_task_state('2', STATE_FINISHED) task_list = sim.get_all_tasks().response_body source_task = task_list[0] nested_task = task_list[1] source_task.spawned_tasks = [nested_task] tasks_to_poll = self.command._get_tasks_to_poll([source_task]) self.assertEquals(2, len(tasks_to_poll))
def test_poll_background(self): # Setup sim = TaskSimulator() sim.add_task_state('1', STATE_FINISHED) # Test task_list = sim.get_all_tasks().response_body result = self.command.poll(task_list, {FLAG_BACKGROUND.keyword: True}) # Verify self.assertEqual(result, RESULT_BACKGROUND)
def test_poll_background(self): # Setup sim = TaskSimulator() sim.add_task_state('1', STATE_FINISHED) # Test task_list = sim.get_all_tasks().response_body result = self.command.poll(task_list, {FLAG_BACKGROUND.keyword : True}) # Verify self.assertEqual(result, RESULT_BACKGROUND)
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_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_run(self, mock_poll): # Setup data = {OPTION_REPO_ID.keyword: "test-repo"} sim = TaskSimulator() sim.add_task_state("123", STATE_FINISHED) mock_binding_delete = mock.MagicMock().delete mock_binding_delete.return_value = sim.get_all_tasks() self.bindings.repo.delete = mock_binding_delete # Test self.command.run(**data) # Verify self.assertEqual(1, mock_binding_delete.call_count) self.assertEqual("test-repo", mock_binding_delete.call_args[0][0]) self.assertEqual(1, mock_poll.call_count)
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_keyboard_interrupt(self): # Setup mock_poll_call = mock.MagicMock()._poll_task mock_poll_call.side_effect = KeyboardInterrupt() self.command._poll_task = mock_poll_call sim = TaskSimulator() sim.install(self.bindings) sim.add_task_state('1', STATE_WAITING) # Test task_list = sim.get_all_tasks().response_body result = self.command.poll(task_list, {}) # Verify self.assertEqual(result, RESULT_ABORTED) self.assertEqual(['abort'], self.prompt.get_write_tags())
def test_run(self, mock_poll): # Setup data = { OPTION_REPO_ID.keyword: 'test-repo', } sim = TaskSimulator() sim.add_task_state('123', STATE_FINISHED) mock_binding_delete = mock.MagicMock().delete mock_binding_delete.return_value = sim.get_all_tasks() self.bindings.repo.delete = mock_binding_delete # Test self.command.run(**data) # Verify self.assertEqual(1, mock_binding_delete.call_count) self.assertEqual('test-repo', mock_binding_delete.call_args[0][0]) self.assertEqual(1, mock_poll.call_count)
def test_poll_rejected(self): """ Task Count: 2 Statuses: Rejected (according to server behavior, all will be rejected if one is) """ # Setup sim = TaskSimulator() sim.install(self.bindings) sim.add_task_state('1', STATE_ERROR, response=RESPONSE_REJECTED) sim.add_task_state('2', STATE_ERROR, response=RESPONSE_REJECTED) # Test task_list = sim.get_all_tasks().response_body completed_tasks = self.command.poll(task_list, {}) # Verify self.assertEqual(completed_tasks, RESULT_REJECTED) self.assertEqual(self.prompt.get_write_tags(), ['rejected'])
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)