Python TaskSimulator.get_all_tasks方法代码示例

# 需要导入模块: from pulp.devel.unit.task_simulator import TaskSimulator [as 别名]
# 或者: from pulp.devel.unit.task_simulator.TaskSimulator import get_all_tasks [as 别名]
    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())

# 需要导入模块: from pulp.devel.unit.task_simulator import TaskSimulator [as 别名]
# 或者: from pulp.devel.unit.task_simulator.TaskSimulator import get_all_tasks [as 别名]
    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())

# 需要导入模块: from pulp.devel.unit.task_simulator import TaskSimulator [as 别名]
# 或者: from pulp.devel.unit.task_simulator.TaskSimulator import get_all_tasks [as 别名]
    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())

# 需要导入模块: from pulp.devel.unit.task_simulator import TaskSimulator [as 别名]
# 或者: from pulp.devel.unit.task_simulator.TaskSimulator import get_all_tasks [as 别名]
    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))

# 需要导入模块: from pulp.devel.unit.task_simulator import TaskSimulator [as 别名]
# 或者: from pulp.devel.unit.task_simulator.TaskSimulator import get_all_tasks [as 别名]
    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)

# 需要导入模块: from pulp.devel.unit.task_simulator import TaskSimulator [as 别名]
# 或者: from pulp.devel.unit.task_simulator.TaskSimulator import get_all_tasks [as 别名]
    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)

# 需要导入模块: from pulp.devel.unit.task_simulator import TaskSimulator [as 别名]
# 或者: from pulp.devel.unit.task_simulator.TaskSimulator import get_all_tasks [as 别名]
    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)

# 需要导入模块: from pulp.devel.unit.task_simulator import TaskSimulator [as 别名]
# 或者: from pulp.devel.unit.task_simulator.TaskSimulator import get_all_tasks [as 别名]
    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))

# 需要导入模块: from pulp.devel.unit.task_simulator import TaskSimulator [as 别名]
# 或者: from pulp.devel.unit.task_simulator.TaskSimulator import get_all_tasks [as 别名]
    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)

# 需要导入模块: from pulp.devel.unit.task_simulator import TaskSimulator [as 别名]
# 或者: from pulp.devel.unit.task_simulator.TaskSimulator import get_all_tasks [as 别名]
    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)

# 需要导入模块: from pulp.devel.unit.task_simulator import TaskSimulator [as 别名]
# 或者: from pulp.devel.unit.task_simulator.TaskSimulator import get_all_tasks [as 别名]
    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)

# 需要导入模块: from pulp.devel.unit.task_simulator import TaskSimulator [as 别名]
# 或者: from pulp.devel.unit.task_simulator.TaskSimulator import get_all_tasks [as 别名]
    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)

# 需要导入模块: from pulp.devel.unit.task_simulator import TaskSimulator [as 别名]
# 或者: from pulp.devel.unit.task_simulator.TaskSimulator import get_all_tasks [as 别名]
    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())

# 需要导入模块: from pulp.devel.unit.task_simulator import TaskSimulator [as 别名]
# 或者: from pulp.devel.unit.task_simulator.TaskSimulator import get_all_tasks [as 别名]
    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'])