python 单元测试中处理用例失败的情况

今天有一个需求, 在单元测试失败的时候打印一些日志, 我们管他叫 dosomething 吧 ,反正就是做一些操作

查了下并没有查到相关的方法, 于是研究了一波unittest 的源码

发现了这个东西

try:

    self._outcome = outcome

    with outcome.testPartExecutor(self):

        self.setUp()

    if outcome.success:

        outcome.expecting_failure = expecting_failure

        with outcome.testPartExecutor(self, isTest=True):

            testMethod()

        outcome.expecting_failure = False

        with outcome.testPartExecutor(self):

            self.tearDown()

    self.doCleanups()

    for test, reason in outcome.skipped:

        self._addSkip(result, test, reason)

    self._feedErrorsToResult(result, outcome.errors)

    if outcome.success:

        if expecting_failure:

            if outcome.expectedFailure:

                self._addExpectedFailure(result, outcome.expectedFailure)

            else:

                self._addUnexpectedSuccess(result)

        else:

            result.addSuccess(self)

    return result

finally:

    result.stopTest(self)

    if orig_result is None:

        stopTestRun = getattr(result, 'stopTestRun', None)

        if stopTestRun is not None:

            stopTestRun()

    # explicitly break reference cycles:

    # outcome.errors -> frame -> outcome -> outcome.errors

    # outcome.expectedFailure -> frame -> outcome -> outcome.expectedFailure

    outcome.errors.clear()

    outcome.expectedFailure = None

    # clear the outcome, no more needed

    self._outcome = None

其中重点关注下testMethod() 这个正是我们执行的用例

于是去看了下testPartExecutor 用例失败的处理是在这里进行处理的

def testPartExecutor(self, test_case, isTest=False):

    old_success = self.success

    self.success = True

    try:

        yield

    except KeyboardInterrupt:

        raise

    except SkipTest as e:

        self.success = False

        self.skipped.append((test_case, str(e)))

    except _ShouldStop:

        pass

    except:

        exc_info = sys.exc_info()

        if self.expecting_failure:

            self.expectedFailure = exc_info

        else:

            self.success = False

            self.errors.append((test_case, exc_info))

        # explicitly break a reference cycle:

        # exc_info -> frame -> exc_info

        exc_info = None

    else:

        if self.result_supports_subtests and self.success:

            self.errors.append((test_case, None))

    finally:

        self.success = self.success and old_success

奈何, 他只是在self.errors (其中self为我们测试类的一个实例)中加了点东西

于是对self.errors 进行观察,发现及时用例是正常的,他依然由内容.

这..............于是我想到他最终是怎么打出来失败的log的

看到上面代码中的 self._feedErrorsToResult(result, outcome.errors)

于是找到了这个东西

def _feedErrorsToResult(self, result, errors):

    for test, exc_info in errors:

        if isinstance(test, _SubTest):

            result.addSubTest(test.test_case, test, exc_info)

        elif exc_info is not None:

            if issubclass(exc_info[0], self.failureException):

                result.addFailure(test, exc_info)

            else:

                result.addError(test, exc_info)

从上面的代码我们可以知道如果 error的第二项是None那么就是一个执行成功的用例,经过实验并确认了这个事情

现在知道了 unittest 是如何处理失败用例的了

于是便有了下面这种方法

def tearDown(self):

    errors = self._outcome.errors

    for test, exc_info in errors:

        if exc_info:

            # dosomething

            pass

上面这种方法尽量少的改变原来的逻辑, 想到一种新的方法解决问题

既然`unittest`没有处理这个事情,那我们魔改之

于是有了下面这种方法

注意: 不建议魔改代码

import sys

import contextlib

import unittest

from unittest.case import SkipTest, _ShouldStop, _Outcome

@contextlib.contextmanager

def testPartExecutor(self, test_case, isTest=False):

    old_success = self.success

    self.success = True

    try:

        yield

    except Exception:

        try:

            # if error

            getattr(test_case, test_case._testMethodName).__func__._error = True

            raise

        except KeyboardInterrupt:

            raise

        except SkipTest as e:

            self.success = False

            self.skipped.append((test_case, str(e)))

        except _ShouldStop:

            pass

        except:

            exc_info = sys.exc_info()

            if self.expecting_failure:

                self.expectedFailure = exc_info

            else:

                self.success = False

                self.errors.append((test_case, exc_info))

            # explicitly break a reference cycle:

            # exc_info -> frame -> exc_info

            exc_info = None

    else:

        if self.result_supports_subtests and self.success:

            self.errors.append((test_case, None))

    finally:

        self.success = self.success and old_success

_Outcome.testPartExecutor = testPartExecutor

class MyTest(unittest.TestCase):

    def test_1(self):

        print("test_1")

    def test_2(self):

        print("test_2")

        raise ValueError

    def tearDown(self):

        if hasattr(getattr(self, self._testMethodName), "_error"):

            # dosomething

            pass

    # def tearDown(self):

    #     推荐这种方法

    #     errors = self._outcome.errors

    #     for test, exc_info in errors:

    #         if exc_info:

    #             # dosomething

    #             pass

if __name__ == '__main__':

    unittest.main()

这样我们就可以在用例执行失败后在tearDown的时候做一些操作

巴特西

python 单元测试中处理用例失败的情况

于是便有了下面这种方法

上面这种方法尽量少的改变原来的逻辑, 想到一种新的方法解决问题

既然`unittest`没有处理这个事情,那我们魔改之

注意: 不建议魔改代码

最新文章

热门文章

巴特西

python 单元测试中处理用例失败的情况

于是便有了下面这种方法

上面这种方法尽量少的改变原来的逻辑, 想到一种新的方法解决问题

既然unittest没有处理这个事情,那我们魔改之

注意: 不建议魔改代码

最新文章

热门文章

既然`unittest`没有处理这个事情,那我们魔改之