Пример #1
0
 def test_basic_failure(self):
     flow = lf.Flow("test")
     flow.add(test_utils.TaskWithFailure("test-1"))
     e = self._make_engine(flow)
     log, handler = self._make_logger()
     with logging_listeners.LoggingListener(e, log=log):
         self.assertRaises(RuntimeError, e.run)
     self.assertGreater(0, handler.counts[logging.DEBUG])
     for levelno in _LOG_LEVELS - set([logging.DEBUG]):
         self.assertEqual(0, handler.counts[levelno])
     self.assertEqual(1, len(handler.exc_infos))
Пример #2
0
    def test_execution_failure_pipeline(self):
        task_classes = [
            test_utils.TaskWithFailure,
        ]
        executor, server = self._start_components(task_classes)

        t = test_utils.TaskWithFailure()
        f = executor.execute_task(t, uuidutils.generate_uuid(), {})
        executor.wait_for_any([f])

        _t2, _action, result = f.result()
        self.assertIsInstance(result, misc.Failure)
        self.assertEqual(RuntimeError, result.check(RuntimeError))
Пример #3
0
    def test_execution_failure_pipeline(self):
        task_classes = [
            test_utils.TaskWithFailure,
        ]
        executor, server = self._start_components(task_classes)

        t = test_utils.TaskWithFailure()
        progress_callback = lambda *args, **kwargs: None
        f = executor.execute_task(t,
                                  uuidutils.generate_uuid(), {},
                                  progress_callback=progress_callback)
        waiters.wait_for_any([f])

        action, result = f.result()
        self.assertIsInstance(result, failure.Failure)
        self.assertEqual(RuntimeError, result.check(RuntimeError))
        self.assertEqual(base_executor.EXECUTED, action)
Пример #4
0
    def test_process_request_task_failure(self, to_mock):
        failure_dict = {
            'failure': 'failure',
        }
        to_mock.return_value = failure_dict
        request = self.make_request(task=utils.TaskWithFailure(), arguments={})

        # create server and process request
        s = self.server(reset_master_mock=True)
        s._process_request(request, self.message_mock)

        # check calls
        master_mock_calls = [
            mock.call.Response(pr.RUNNING),
            mock.call.proxy.publish(self.response_inst_mock, self.reply_to,
                                    correlation_id=self.task_uuid),
            mock.call.Response(pr.FAILURE, result=failure_dict),
            mock.call.proxy.publish(self.response_inst_mock,
                                    self.reply_to,
                                    correlation_id=self.task_uuid)
        ]
        self.assertEqual(self.master_mock.mock_calls, master_mock_calls)