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_install(self): # Setup sim = TaskSimulator() sim.install(self.bindings) progress_report = {"steps": [], "details": {}} final_task = sim.add_task_state("TASK123", STATE_FINISHED) final_task.progress = progress_report final_task.result = TASK["result"] command = package.YumConsumerPackageInstallCommand(self.context) self.server_mock.request = Mock(side_effect=Request("install")) # Test args = { "consumer-id": "xyz", "name": ["zsh", "fail-test"], "no-commit": False, "import-keys": False, "reboot": False, } command.run(**args) # Verify passed = self.server_mock.request.call_args[0] self.assertEqual("POST", passed[0])
def test_update(self): # Setup sim = TaskSimulator() sim.install(self.bindings) progress_report = {'steps': [], 'details': {}} final_task = sim.add_task_state('TASK123', STATE_FINISHED) final_task.progress = progress_report final_task.result = TASK['result'] command = package.YumConsumerPackageUpdateCommand(self.context) self.server_mock.request = Mock(side_effect=Request('update')) # Test args = { 'consumer-id': 'xyz', 'name': ['zsh'], 'no-commit': False, 'import-keys': False, 'reboot': False, 'all': False, } command.run(**args) # Verify passed = self.server_mock.request.call_args[0] self.assertEqual('POST', passed[0])
def test_run(self): # Setup sim = TaskSimulator() sim.install(self.bindings) fake_progress_report = {'steps': [('name', 'status')], 'details': {}} sim.add_task_state('1', STATE_FINISHED, progress_report=fake_progress_report) self.server_mock.request.return_value = 201, POSTPONED_TASK kwargs = {OPTION_CONSUMER_ID.keyword: 'test-consumer', consumer_content.OPTION_CONTENT_TYPE_ID.keyword: 'rpm', consumer_content.OPTION_CONTENT_UNIT.keyword: []} self.command.run(**kwargs) self.assertEqual(self.server_mock.request.call_count, 1) self.assertEqual(self.server_mock.request.call_args[0][0], 'POST') url = self.server_mock.request.call_args[0][1] self.assertTrue(url.find('test-consumer') > 0) body = json.loads(self.server_mock.request.call_args[0][2]) self.assertEqual(body['units'], [])
def test_run(self): # Setup sim = TaskSimulator() sim.install(self.bindings) fake_progress_report = {"steps": [("name", "status")], "details": {}} sim.add_task_state("1", STATE_FINISHED, progress_report=fake_progress_report) self.server_mock.request.return_value = 201, POSTPONED_TASK kwargs = { OPTION_CONSUMER_ID.keyword: "test-consumer", consumer_content.OPTION_CONTENT_TYPE_ID.keyword: "rpm", consumer_content.OPTION_CONTENT_UNIT.keyword: [], } self.command.run(**kwargs) self.assertEqual(self.server_mock.request.call_count, 1) self.assertEqual(self.server_mock.request.call_args[0][0], "POST") url = self.server_mock.request.call_args[0][1] self.assertTrue(url.find("test-consumer") > 0) body = json.loads(self.server_mock.request.call_args[0][2]) self.assertEqual(body["units"], [])
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_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_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_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_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_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_install(self): """ Tests the correct API in the bindings is replaced by the simulator. """ # Test mock_bindings = mock.MagicMock() sim = TaskSimulator() sim.install(mock_bindings) # Verify self.assertEqual(sim, mock_bindings.tasks)
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_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_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_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_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_add_task_state(self): # Setup task_id = "123" state = "running" progress_report = "1/10" # Test sim = TaskSimulator() task = sim.add_task_state(task_id, state, progress_report=progress_report) # Verify self.assertTrue(task_id in sim.ordered_task_ids) self.assertTrue(task_id in sim.tasks_by_id) self.assertTrue(1, len(sim.tasks_by_id[task_id])) self.assertEqual(task.task_id, task_id) self.assertEqual(task.state, state) self.assertEqual(task.progress_report, progress_report)
def test_add_task_state(self): # Setup task_id = '123' state = 'running' response = 'success' progress_report = '1/10' # Test sim = TaskSimulator() task = sim.add_task_state(task_id, state, progress_report=progress_report) # Verify self.assertTrue(task_id in sim.ordered_task_ids) self.assertTrue(task_id in sim.tasks_by_id) self.assertTrue(1, len(sim.tasks_by_id[task_id])) self.assertEqual(task.task_id, task_id) self.assertEqual(task.state, state) self.assertEqual(task.progress_report, progress_report)
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_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_add_task_state(self): # Setup task_id = '123' state = 'running' progress_report = '1/10' # Test sim = TaskSimulator() task = sim.add_task_state(task_id, state, progress_report=progress_report) # Verify self.assertTrue(task_id in sim.ordered_task_ids) self.assertTrue(task_id in sim.tasks_by_id) self.assertTrue(1, len(sim.tasks_by_id[task_id])) self.assertEqual(task.task_id, task_id) self.assertEqual(task.state, state) self.assertEqual(task.progress_report, progress_report)
def test_run(self): # Setup sim = TaskSimulator() sim.install(self.bindings) fake_progress_report = {'steps': [('name', 'status')], 'details': {}} sim.add_task_state('1', STATE_FINISHED, progress_report=fake_progress_report) self.server_mock.request.return_value = 201, POSTPONED_TASK kwargs = { OPTION_CONSUMER_ID.keyword: 'test-consumer', consumer_content.OPTION_CONTENT_TYPE_ID.keyword: 'rpm', consumer_content.OPTION_CONTENT_UNIT.keyword: [] } self.command.run(**kwargs) self.assertEqual(self.server_mock.request.call_count, 1) self.assertEqual(self.server_mock.request.call_args[0][0], 'POST') url = self.server_mock.request.call_args[0][1] self.assertTrue(url.find('test-consumer') > 0) body = json.loads(self.server_mock.request.call_args[0][2]) self.assertEqual(body['units'], [])
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_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_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_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_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_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_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)