Python接口测试实战7 - unittest单元测试框架

import unittest

class TestGetIssue(unittest.TestCase):
    def setUp(self):
        self.client = RedmineClient("https://redmine.xuh.me", "490592ea4e46348df29828edd597acbfdc5ebb4a")
    
    def test_get_issue(self):
        resp = self.client.get_issue("1")
        self.assertEqual(resp["issue"]["id"], 1)
    
    def test_bad_issue_id(self):
        resp = self.client.get_issue("-1")
        self.assertIsNone(resp["issue"])

if __name__ == "__main__":
    unittest.main()

- setUpModule
	- setUpClass <suite-1>
		- setUp
		- test-1-1
		- tearDown
		- setUp
		- test-1-2
		- tearDown
		...
	- tearDownClass <suite-1>
	...
- tearDownModule

    def getTestCaseNames(self, testCaseClass):
        """Return a sorted sequence of method names found within testCaseClass
        """
        def shouldIncludeMethod(attrname):
            if not attrname.startswith(self.testMethodPrefix):
                return False
            testFunc = getattr(testCaseClass, attrname)
            if not callable(testFunc):
                return False
            fullName = f'%s.%s.%s' % (
                testCaseClass.__module__, testCaseClass.__qualname__, attrname
            )
            return self.testNamePatterns is None or \
                any(fnmatchcase(fullName, pattern) for pattern in self.testNamePatterns)
        testFnNames = list(filter(shouldIncludeMethod, dir(testCaseClass)))
        if self.sortTestMethodsUsing:
            testFnNames.sort(key=functools.cmp_to_key(self.sortTestMethodsUsing))
        return testFnNames
 

    def loadTestsFromTestCase(self, testCaseClass):
        """Return a suite of all test cases contained in testCaseClass"""
        if issubclass(testCaseClass, suite.TestSuite):
            raise TypeError("Test cases should not be derived from "
                            "TestSuite. Maybe you meant to derive from "
                            "TestCase?")
        testCaseNames = self.getTestCaseNames(testCaseClass)
        if not testCaseNames and hasattr(testCaseClass, 'runTest'):
            testCaseNames = ['runTest']
        loaded_suite = self.suiteClass(map(testCaseClass, testCaseNames))
        return loaded_suite

class BaseTestSuite(object):
    """A simple test suite that doesn't provide class or module shared fixtures.
    """
    _cleanup = True

    def __init__(self, tests=()):
        self._tests = []
        self._removed_tests = 0
        self.addTests(tests)

    def __iter__(self):
        return iter(self._tests)

class TestSuite(BaseTestSuite):
    def run(self, result, debug=False):
        topLevel = False
        if getattr(result, '_testRunEntered', False) is False:
            result._testRunEntered = topLevel = True

        for index, test in enumerate(self):
            # 省略过程代码
            if not debug:
                test(result)
            else:
                test.debug()

class TestCase(object):
    def __init__(self, methodName='runTest'):
        """Create an instance of the class that will use the named test
           method when executed. Raises a ValueError if the instance does
           not have a method with the specified name.
        """
        self._testMethodName = methodName

    def __call__(self, *args, **kwds):
        return self.run(*args, **kwds)

    def run(self, result=None):

        testMethod = getattr(self, self._testMethodName)

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