Python actionchainrunner.get_runner函数代码示例

    def test_chain_runner_task_is_canceled_while_running(self, request):
        # Second task in the action is CANCELED, make sure runner doesn't get stuck in an infinite
        # loop
        chain_runner = acr.get_runner()
        chain_runner.entry_point = CHAIN_2_PATH
        chain_runner.action = ACTION_1

        original_run_action = chain_runner._run_action

        def mock_run_action(*args, **kwargs):
            original_live_action = args[0]
            if original_live_action.action == 'wolfpack.a2':
                status = LIVEACTION_STATUS_CANCELED
            else:
                status = LIVEACTION_STATUS_SUCCEEDED
            request.return_value = (DummyActionExecution(status=status), None)
            liveaction = original_run_action(*args, **kwargs)
            return liveaction

        chain_runner._run_action = mock_run_action

        action_ref = ResourceReference.to_string_reference(name=ACTION_1.name,
                                                           pack=ACTION_1.pack)
        chain_runner.liveaction = LiveActionDB(action=action_ref)
        chain_runner.container_service = RunnerContainerService()
        chain_runner.pre_run()
        status, _, _ = chain_runner.run({})

        self.assertEqual(status, LIVEACTION_STATUS_CANCELED)
        self.assertNotEqual(chain_runner.chain_holder.actionchain, None)
        # Chain count should be 2 since the last task doesn't get called since the second one was
        # canceled
        self.assertEqual(request.call_count, 2)

    def test_chain_runner_chain_second_task_times_out(self, request):
        # Second task in the chain times out so the action chain status should be timeout
        chain_runner = acr.get_runner()
        chain_runner.entry_point = CHAIN_2_PATH
        chain_runner.action = ACTION_1

        original_run_action = chain_runner._run_action

        def mock_run_action(*args, **kwargs):
            original_live_action = args[0]
            liveaction = original_run_action(*args, **kwargs)
            if original_live_action.action == 'wolfpack.a2':
                # Mock a timeout for second task
                liveaction.status = LIVEACTION_STATUS_TIMED_OUT
            return liveaction

        chain_runner._run_action = mock_run_action

        action_ref = ResourceReference.to_string_reference(name=ACTION_1.name,
                                                           pack=ACTION_1.pack)
        chain_runner.liveaction = LiveActionDB(action=action_ref)
        chain_runner.container_service = RunnerContainerService()
        chain_runner.pre_run()
        status, _, _ = chain_runner.run({})

        self.assertEqual(status, LIVEACTION_STATUS_TIMED_OUT)
        self.assertNotEqual(chain_runner.chain_holder.actionchain, None)
        # based on the chain the callcount is known to be 3. Not great but works.
        self.assertEqual(request.call_count, 3)

 def test_chain_runner_bad_default(self, request):
     chain_runner = acr.get_runner()
     chain_runner.entry_point = CHAIN_BAD_DEFAULT
     chain_runner.action = ACTION_1
     chain_runner.container_service = RunnerContainerService()
     expected_msg = 'Unable to find node with name "bad_default" referenced in "default".'
     self.assertRaisesRegexp(runnerexceptions.ActionRunnerPreRunError,
                             expected_msg, chain_runner.pre_run)

 def test_chain_runner_missing_param_temp(self, schedule):
     chain_runner = acr.get_runner()
     chain_runner.entry_point = CHAIN_STR_TEMP_PATH
     chain_runner.action = ACTION_1
     chain_runner.container_service = RunnerContainerService()
     chain_runner.pre_run()
     chain_runner.run({})
     self.assertEqual(schedule.call_count, 0, 'No call expected.')

 def test_chain_runner_missing_param_temp(self, request):
     chain_runner = acr.get_runner()
     chain_runner.entry_point = CHAIN_FIRST_TASK_RENDER_FAIL_PATH
     chain_runner.action = ACTION_1
     chain_runner.container_service = RunnerContainerService()
     chain_runner.pre_run()
     chain_runner.run({})
     self.assertEqual(request.call_count, 0, 'No call expected.')

 def test_chain_runner_str_param_temp(self, schedule):
     chain_runner = acr.get_runner()
     chain_runner.entry_point = CHAIN_FIRST_TASK_RENDER_FAIL_PATH
     chain_runner.action = ACTION_1
     chain_runner.container_service = RunnerContainerService()
     chain_runner.pre_run()
     chain_runner.run({'s1': 1, 's2': 2, 's3': 3, 's4': 4})
     self.assertNotEqual(chain_runner.chain_holder.actionchain, None)
     mock_args, _ = schedule.call_args
     self.assertEqual(mock_args[0].parameters, {"p1": "1"})

 def test_chain_runner_action_exception(self, schedule):
     chain_runner = acr.get_runner()
     chain_runner.entry_point = CHAIN_1_PATH
     chain_runner.action = ACTION_1
     chain_runner.container_service = RunnerContainerService()
     chain_runner.pre_run()
     chain_runner.run({})
     self.assertNotEqual(chain_runner.action_chain, None)
     # based on the chain the callcount is known to be 2. Not great but works.
     self.assertEqual(schedule.call_count, 2)

 def test_malformed_chain(self):
     try:
         chain_runner = acr.get_runner()
         chain_runner.entry_point = MALFORMED_CHAIN_PATH
         chain_runner.action = ACTION_1
         chain_runner.container_service = RunnerContainerService()
         chain_runner.pre_run()
         self.assertTrue(False, 'Expected pre_run to fail.')
     except runnerexceptions.ActionRunnerPreRunError:
         self.assertTrue(True)

 def test_chain_runner_success_path_with_wait(self, schedule):
     chain_runner = acr.get_runner()
     chain_runner.entry_point = CHAIN_1_PATH
     chain_runner.action = DummyAction()
     chain_runner.container_service = RunnerContainerService()
     chain_runner.pre_run()
     chain_runner.run({})
     self.assertNotEqual(chain_runner.action_chain, None)
     # based on the chain the callcount is known to be 3. Not great but works.
     self.assertEqual(schedule.call_count, 3)

 def test_chain_runner_list_param_temp(self, request):
     chain_runner = acr.get_runner()
     chain_runner.entry_point = CHAIN_LIST_TEMP_PATH
     chain_runner.action = ACTION_1
     chain_runner.container_service = RunnerContainerService()
     chain_runner.pre_run()
     chain_runner.run({'s1': 1, 's2': 2, 's3': 3, 's4': 4})
     self.assertNotEqual(chain_runner.chain_holder.actionchain, None)
     mock_args, _ = request.call_args
     self.assertEqual(mock_args[0].parameters, {"p1": "[2, 3, 4]"})

    def test_exception_is_thrown_if_both_params_and_parameters_attributes_are_provided(self):
        chain_runner = acr.get_runner()
        chain_runner.entry_point = CHAIN_ACTION_PARAMS_AND_PARAMETERS_ATTRIBUTE
        chain_runner.action = ACTION_2
        chain_runner.container_service = RunnerContainerService()

        expected_msg = ('Either "params" or "parameters" attribute needs to be provided, but '
                       'not both')
        self.assertRaisesRegexp(runnerexceptions.ActionRunnerPreRunError, expected_msg,
                                chain_runner.pre_run)

 def test_chain_runner_str_param_temp(self, schedule):
     chain_runner = acr.get_runner()
     chain_runner.entry_point = CHAIN_STR_TEMP_PATH
     chain_runner.action = DummyAction()
     chain_runner.container_service = RunnerContainerService()
     chain_runner.pre_run()
     chain_runner.run({'s1': 1, 's2': 2, 's3': 3, 's4': 4})
     self.assertNotEqual(chain_runner.action_chain, None)
     mock_args, _ = schedule.call_args
     self.assertEqual(mock_args[0].parameters, {"p1": "1"})

    def test_chain_runner_broken_on_failure_path_static_task_name(self, request):
        chain_runner = acr.get_runner()
        chain_runner.entry_point = CHAIN_BROKEN_ON_FAILURE_PATH_STATIC_TASK_NAME
        chain_runner.action = ACTION_1
        chain_runner.container_service = RunnerContainerService()

        expected_msg = ('Unable to find node with name "c6" referenced in "on-failure" '
                        'in task "c2"')
        self.assertRaisesRegexp(runnerexceptions.ActionRunnerPreRunError,
                                expected_msg, chain_runner.pre_run)

 def test_chain_runner_success_path_with_wait(self, request):
     chain_runner = acr.get_runner()
     chain_runner.entry_point = CHAIN_1_PATH
     chain_runner.action = ACTION_1
     chain_runner.container_service = RunnerContainerService()
     chain_runner.pre_run()
     chain_runner.run({})
     self.assertNotEqual(chain_runner.chain_holder.actionchain, None)
     # based on the chain the callcount is known to be 3. Not great but works.
     self.assertEqual(request.call_count, 3)

    def test_params_and_parameters_attributes_both_work(self, _):
        # "params" attribute used
        chain_runner = acr.get_runner()
        chain_runner.entry_point = CHAIN_ACTION_PARAMS_ATTRIBUTE
        chain_runner.action = ACTION_2
        chain_runner.container_service = RunnerContainerService()
        chain_runner.pre_run()

        original_build_liveaction_object = chain_runner._build_liveaction_object

        def mock_build_liveaction_object(action_node, resolved_params, parent_context):
            # Verify parameters are correctly passed to the action
            self.assertEqual(resolved_params, {'pparams': 'v1'})
            original_build_liveaction_object(action_node=action_node,
                                             resolved_params=resolved_params,
                                             parent_context=parent_context)

        chain_runner._build_liveaction_object = mock_build_liveaction_object

        action_parameters = {}
        status, output, _ = chain_runner.run(action_parameters=action_parameters)
        self.assertEqual(status, LIVEACTION_STATUS_SUCCEEDED)

        # "parameters" attribute used
        chain_runner = acr.get_runner()
        chain_runner.entry_point = CHAIN_ACTION_PARAMETERS_ATTRIBUTE
        chain_runner.action = ACTION_2
        chain_runner.container_service = RunnerContainerService()
        chain_runner.pre_run()

        def mock_build_liveaction_object(action_node, resolved_params, parent_context):
            # Verify parameters are correctly passed to the action
            self.assertEqual(resolved_params, {'pparameters': 'v1'})
            original_build_liveaction_object(action_node=action_node,
                                             resolved_params=resolved_params,
                                             parent_context=parent_context)

        chain_runner._build_liveaction_object = mock_build_liveaction_object

        action_parameters = {}
        status, output, _ = chain_runner.run(action_parameters=action_parameters)
        self.assertEqual(status, LIVEACTION_STATUS_SUCCEEDED)