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_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_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_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_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_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_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_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_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_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_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)