Python单元测试unittest加载方式之二：加载测试套件
在运用测试套件进行单元测试之前，还是稍微研究一下unittest模块的内容有哪些，其大概的运行方式是什么样的。而后在给出根据各种情况如何制定单元测试套件。
一、查看unittest模块有哪些成员
>>> import unittest
>>> dir(unittest)
['BaseTestSuite', 'FunctionTestCase', 'SkipTest', 'TestCase', 'TestLoader', 'TestProgram', 'TestResult', 'TestSuite', 'TextTestResult', 'TextTestRunner', '_TextTestResult', '__all__', '__builtins__', '__doc__', '__file__', '__name__', '__package__', '__path__', '__unittest', 'case', 'defaultTestLoader', 'expectedFailure', 'findTestCases', 'getTestCaseNames', 'installHandler', 'loader', 'main', 'makeSuite', 'registerResult', 'removeHandler', 'removeResult', 'result', 'runner', 'signals', 'skip', 'skipIf', 'skipUnless', 'suite', 'util']
可以看到其自身的成员也不是很多，大概包括有：
['FunctionTestCase', 'TestCase', 'TestLoader', 'TestProgram', 'TestResult',
'TestSuite','TextTestRunner', '_CmpToKey', '_TextTestResult', '_WritelnDecorator',
'defaultTestLoader','findTestCases', 'getTestCaseNames', 'main', 'makeSuite']
我们来看看他们到底是干什么的？
>>> import unittest
>>> memblist = ['FunctionTestCase', 'TestCase', 'TestLoader', 'TestProgram', 'TestResult',
'TestSuite','TextTestRunner', 'defaultTestLoader','findTestCases', 'getTestCaseNames',
'main', 'makeSuite']
>>> for memb in memblist:
cur = getattr(unittest, memb)
print help(cur)IDLE中返回的结果为： 待插入
'FunctionTestCase':函数测试用例，即给一个函数作为参数，返回一个testcase实例，可选参数有set-up，tear-down方法
'TestCase'：所有测试用例的基本类，给一个测试方法的名字，返回一个测试用例实例
'TestLoader'：测试用例加载器，其包括多个加载测试用例的方法。返回一个测试套件
loadTestsFromModule(self, module)--根据给定的模块实例来获取测试用例套件
loadTestsFromName(self, name, module=None)
--根据给定的字符串来获取测试用例套件，字符串可以是模块名，测试类名，测试类中的测试方法名，或者一个可调用的是实例对象
这个实例对象返回一个测试用例或一个测试套件
loadTestsFromNames(self, names, module=None) --和上面功能相同，只不过接受的是字符串列表
loadTestsFromTestCase(self, testCaseClass)--根据给定的测试类，获取其中的所有测试方法，并返回一个测试套件
'TestProgram'：命令行进行单元测试的调用方法，作用是执行一个测试用例。其实unittest.main()方法执行的就是这个命令，
而这个类实例时默认加载当前执行的作为测试对象，
原型为 __init__(self, module='__main__', defaultTest=None, argv=None, testRunner=xx, testLoader=xx)
其中module='__main__'就是默认加载自身
'TestResult'：测试用例的结果保存实例，通常有测试框架调用
'TestSuite'：组织测试用例的实例，支持测试用例的添加和删除，最终将传递给testRunner进行测试执行
'TextTestRunner'：进行测试用例执行的实例，其中Text的意思是以文本形式显示测试结果。显示测试名称，即完成的测试结果，其过同执行单元测试脚本时添加-v参数
'defaultTestLoader':其实就是TestLoader
'findTestCases', 'getTestCaseNames'：这个2个就不用解释了
'main': 其实就是TestProgram
'makeSuite'：通常是由单元测试框架调用的，用于生产testsuite对象的实例
IDLE中返回的结果为：
Help on class FunctionTestCase in module unittest.case:
class FunctionTestCase(TestCase)
| A test case that wraps a test function.
|
| This is useful for slipping pre-existing test functions into the
| unittest framework. Optionally, set-up and tidy-up functions can be
| supplied. As with TestCase, the tidy-up ('tearDown') function will
| always be called if the set-up ('setUp') function ran successfully.
|
| Method resolution order:
| FunctionTestCase
| TestCase
| __builtin__.object
|
| Methods defined here:
|
| __eq__(self, other)
|
| __hash__(self)
|
| __init__(self, testFunc, setUp=None, tearDown=None, description=None)
|
| __ne__(self, other)
|
| __repr__(self)
|
| __str__(self)
|
| id(self)
|
| runTest(self)
|
| setUp(self)
|
| shortDescription(self)
|
| tearDown(self)
|
| ----------------------------------------------------------------------
| Methods inherited from TestCase:
|
| __call__(self, *args, **kwds)
|
| addCleanup(self, function, *args, **kwargs)
| Add a function, with arguments, to be called when the test is
| completed. Functions added are called on a LIFO basis and are
| called after tearDown on test failure or success.
|
| Cleanup items are called even if setUp fails (unlike tearDown).
|
| addTypeEqualityFunc(self, typeobj, function)
| Add a type specific assertEqual style function to compare a type.
|
| This method is for use by TestCase subclasses that need to register
| their own type equality functions to provide nicer error messages.
|
| Args:
| typeobj: The data type to call this function on when both values
| are of the same type in assertEqual().
| function: The callable taking two arguments and an optional
| msg= argument that raises self.failureException with a
| useful error message when the two arguments are not equal.
|
| assertAlmostEqual(self, first, second, places=None, msg=None, delta=None)
| Fail if the two objects are unequal as determined by their
| difference rounded to the given number of decimal places
| (default 7) and comparing to zero, or by comparing that the
| between the two objects is more than the given delta.
|
| Note that decimal places (from zero) are usually not the same
| as significant digits (measured from the most signficant digit).
|
| If the two objects compare equal then they will automatically
| compare almost equal.
|
| assertAlmostEquals = assertAlmostEqual(self, first, second, places=None, msg=None, delta=None)
| Fail if the two objects are unequal as determined by their
| difference rounded to the given number of decimal places
| (default 7) and comparing to zero, or by comparing that the
| between the two objects is more than the given delta.
|
| Note that decimal places (from zero) are usually not the same
| as significant digits (measured from the most signficant digit).
|
| If the two objects compare equal then they will automatically
| compare almost equal.
|
| assertDictContainsSubset(self, expected, actual, msg=None)
| Checks whether actual is a superset of expected.
|
| assertDictEqual(self, d1, d2, msg=None)
|
| assertEqual(self, first, second, msg=None)
| Fail if the two objects are unequal as determined by the '=='
| operator.
|
| assertEquals = assertEqual(self, first, second, msg=None)
| Fail if the two objects are unequal as determined by the '=='
| operator.
|
| assertFalse(self, expr, msg=None)
| Check that the expression is false.
|
| assertGreater(self, a, b, msg=None)
| Just like self.assertTrue(a > b), but with a nicer default message.
|
| assertGreaterEqual(self, a, b, msg=None)
| Just like self.assertTrue(a >= b), but with a nicer default message.
|
| assertIn(self, member, container, msg=None)
| Just like self.assertTrue(a in b), but with a nicer default message.
|
| assertIs(self, expr1, expr2, msg=None)
| Just like self.assertTrue(a is b), but with a nicer default message.
|
| assertIsInstance(self, obj, cls, msg=None)
| Same as self.assertTrue(isinstance(obj, cls)), with a nicer
| default message.
|
| assertIsNone(self, obj, msg=None)
| Same as self.assertTrue(obj is None), with a nicer default message.
|
| assertIsNot(self, expr1, expr2, msg=None)
| Just like self.assertTrue(a is not b), but with a nicer default message.
|
| assertIsNotNone(self, obj, msg=None)
| Included for symmetry with assertIsNone.
|
| assertItemsEqual(self, expected_seq, actual_seq, msg=None)
| An unordered sequence specific comparison. It asserts that
| actual_seq and expected_seq have the same element counts.
| Equivalent to::
|
| self.assertEqual(Counter(iter(actual_seq)),
| Counter(iter(expected_seq)))
|
| Asserts that each element has the same count in both sequences.
| Example:
| - [0, 1, 1] and [1, 0, 1] compare equal.
| - [0, 0, 1] and [0, 1] compare unequal.
|
| assertLess(self, a, b, msg=None)
| Just like self.assertTrue(a < b), but with a nicer default message.
|
| assertLessEqual(self, a, b, msg=None)
| Just like self.assertTrue(a <= b), but with a nicer default message.
|
| assertListEqual(self, list1, list2, msg=None)
| A list-specific equality assertion.
|
| Args:
| list1: The first list to compare.
| list2: The second list to compare.
| msg: Optional message to use on failure instead of a list of
| differences.
|
| assertMultiLineEqual(self, first, second, msg=None)
| Assert that two multi-line strings are equal.
|
| assertNotAlmostEqual(self, first, second, places=None, msg=None, delta=None)
| Fail if the two objects are equal as determined by their
| difference rounded to the given number of decimal places
| (default 7) and comparing to zero, or by comparing that the
| between the two objects is less than the given delta.
|
| Note that decimal places (from zero) are usually not the same
| as significant digits (measured from the most signficant digit).
|
| Objects that are equal automatically fail.
|
| assertNotAlmostEquals = assertNotAlmostEqual(self, first, second, places=None, msg=None, delta=None)
| Fail if the two objects are equal as determined by their
| difference rounded to the given number of decimal places
| (default 7) and comparing to zero, or by comparing that the
| between the two objects is less than the given delta.
|
| Note that decimal places (from zero) are usually not the same
| as significant digits (measured from the most signficant digit).
|
| Objects that are equal automatically fail.
|
| assertNotEqual(self, first, second, msg=None)
| Fail if the two objects are equal as determined by the '!='
| operator.
|
| assertNotEquals = assertNotEqual(self, first, second, msg=None)
| Fail if the two objects are equal as determined by the '!='
| operator.
|
| assertNotIn(self, member, container, msg=None)
| Just like self.assertTrue(a not in b), but with a nicer default message.
|
| assertNotIsInstance(self, obj, cls, msg=None)
| Included for symmetry with assertIsInstance.
|
| assertNotRegexpMatches(self, text, unexpected_regexp, msg=None)
| Fail the test if the text matches the regular expression.
|
| assertRaises(self, excClass, callableObj=None, *args, **kwargs)
| Fail unless an exception of class excClass is raised
| by callableObj when invoked with arguments args and keyword
| arguments kwargs. If a different type of exception is
| raised, it will not be caught, and the test case will be
| deemed to have suffered an error, exactly as for an
| unexpected exception.
|
| If called with callableObj omitted or None, will return a
| context object used like this::
|
| with self.assertRaises(SomeException):
| do_something()
|
| The context manager keeps a reference to the exception as
| the 'exception' attribute. This allows you to inspect the
| exception after the assertion::
|
| with self.assertRaises(SomeException) as cm:
| do_something()
| the_exception = cm.exception
| self.assertEqual(the_exception.error_code, 3)
|
| assertRaisesRegexp(self, expected_exception, expected_regexp, callable_obj=None, *args, **kwargs)
| Asserts that the message in a raised exception matches a regexp.
|
| Args:
| expected_exception: Exception class expected to be raised.
| expected_regexp: Regexp (re pattern object or string) expected
| to be found in error message.
| callable_obj: Function to be called.
| args: Extra args.
| kwargs: Extra kwargs.
|
| assertRegexpMatches(self, text, expected_regexp, msg=None)
| Fail the test unless the text matches the regular expression.
|
| assertSequenceEqual(self, seq1, seq2, msg=None, seq_type=None)
| An equality assertion for ordered sequences (like lists and tuples).
|
| For the purposes of this function, a valid ordered sequence type is one
| which can be indexed, has a length, and has an equality operator.
|
| Args:
| seq1: The first sequence to compare.
| seq2: The second sequence to compare.
| seq_type: The expected datatype of the sequences, or None if no
| datatype should be enforced.
| msg: Optional message to use on failure instead of a list of
| differences.
|
| assertSetEqual(self, set1, set2, msg=None)
| A set-specific equality assertion.
|
| Args:
| set1: The first set to compare.
| set2: The second set to compare.
| msg: Optional message to use on failure instead of a list of
| differences.
|
| assertSetEqual uses ducktyping to support different types of sets, and
| is optimized for sets specifically (parameters must support a
| difference method).
|
| assertTrue(self, expr, msg=None)
| Check that the expression is true.
|
| assertTupleEqual(self, tuple1, tuple2, msg=None)
| A tuple-specific equality assertion.
|
| Args:
| tuple1: The first tuple to compare.
| tuple2: The second tuple to compare.
| msg: Optional message to use on failure instead of a list of
| differences.
|
| assert_ = assertTrue(self, expr, msg=None)
| Check that the expression is true.
|
| countTestCases(self)
|
| debug(self)
| Run the test without collecting errors in a TestResult
|
| defaultTestResult(self)
|
| doCleanups(self)
| Execute all cleanup functions. Normally called for you after
| tearDown.
|
| fail(self, msg=None)
| Fail immediately, with the given message.
|
| failIf = deprecated_func(*args, **kwargs)
|
| failIfAlmostEqual = deprecated_func(*args, **kwargs)
|
| failIfEqual = deprecated_func(*args, **kwargs)
|
| failUnless = deprecated_func(*args, **kwargs)
|
| failUnlessAlmostEqual = deprecated_func(*args, **kwargs)
|
| failUnlessEqual = deprecated_func(*args, **kwargs)
|
| failUnlessRaises = deprecated_func(*args, **kwargs)
|
| run(self, result=None)
|
| skipTest(self, reason)
| Skip this test.
|
| ----------------------------------------------------------------------
| Class methods inherited from TestCase:
|
| setUpClass(cls) from __builtin__.type
| Hook method for setting up class fixture before running tests in the class.
|
| tearDownClass(cls) from __builtin__.type
| Hook method for deconstructing the class fixture after running all tests in the class.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from TestCase:
|
| __dict__
| dictionary for instance variables (if defined)
|
| __weakref__
| list of weak references to the object (if defined)
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from TestCase:
|
| failureException = <type 'exceptions.AssertionError'>
| Assertion failed.
|
| longMessage = False
|
| maxDiff = 640
None
Help on class TestCase in module unittest.case:
class TestCase(__builtin__.object)
| A class whose instances are single test cases.
|
| By default, the test code itself should be placed in a method named
| 'runTest'.
|
| If the fixture may be used for many test cases, create as
| many test methods as are needed. When instantiating such a TestCase
| subclass, specify in the constructor arguments the name of the test method
| that the instance is to execute.
|
| Test authors should subclass TestCase for their own tests. Construction
| and deconstruction of the test's environment ('fixture') can be
| implemented by overriding the 'setUp' and 'tearDown' methods respectively.
|
| If it is necessary to override the __init__ method, the base class
| __init__ method must always be called. It is important that subclasses
| should not change the signature of their __init__ method, since instances
| of the classes are instantiated automatically by parts of the framework
| in order to be run.
|
| When subclassing TestCase, you can set these attributes:
| * failureException: determines which exception will be raised when
| the instance's assertion methods fail; test methods raising this
| exception will be deemed to have 'failed' rather than 'errored'.
| * longMessage: determines whether long messages (including repr of
| objects used in assert methods) will be printed on failure in *addition*
| to any explicit message passed.
| * maxDiff: sets the maximum length of a diff in failure messages
| by assert methods using difflib. It is looked up as an instance
| attribute so can be configured by individual tests if required.
|
| Methods defined here:
|
| __call__(self, *args, **kwds)
|
| __eq__(self, other)
|
| __hash__(self)
|
| __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.
|
| __ne__(self, other)
|
| __repr__(self)
|
| __str__(self)
|
| addCleanup(self, function, *args, **kwargs)
| Add a function, with arguments, to be called when the test is
| completed. Functions added are called on a LIFO basis and are
| called after tearDown on test failure or success.
|
| Cleanup items are called even if setUp fails (unlike tearDown).
|
| addTypeEqualityFunc(self, typeobj, function)
| Add a type specific assertEqual style function to compare a type.
|
| This method is for use by TestCase subclasses that need to register
| their own type equality functions to provide nicer error messages.
|
| Args:
| typeobj: The data type to call this function on when both values
| are of the same type in assertEqual().
| function: The callable taking two arguments and an optional
| msg= argument that raises self.failureException with a
| useful error message when the two arguments are not equal.
|
| assertAlmostEqual(self, first, second, places=None, msg=None, delta=None)
| Fail if the two objects are unequal as determined by their
| difference rounded to the given number of decimal places
| (default 7) and comparing to zero, or by comparing that the
| between the two objects is more than the given delta.
|
| Note that decimal places (from zero) are usually not the same
| as significant digits (measured from the most signficant digit).
|
| If the two objects compare equal then they will automatically
| compare almost equal.
|
| assertAlmostEquals = assertAlmostEqual(self, first, second, places=None, msg=None, delta=None)
|
| assertDictContainsSubset(self, expected, actual, msg=None)
| Checks whether actual is a superset of expected.
|
| assertDictEqual(self, d1, d2, msg=None)
|
| assertEqual(self, first, second, msg=None)
| Fail if the two objects are unequal as determined by the '=='
| operator.
|
| assertEquals = assertEqual(self, first, second, msg=None)
|
| assertFalse(self, expr, msg=None)
| Check that the expression is false.
|
| assertGreater(self, a, b, msg=None)
| Just like self.assertTrue(a > b), but with a nicer default message.
|
| assertGreaterEqual(self, a, b, msg=None)
| Just like self.assertTrue(a >= b), but with a nicer default message.
|
| assertIn(self, member, container, msg=None)
| Just like self.assertTrue(a in b), but with a nicer default message.
|
| assertIs(self, expr1, expr2, msg=None)
| Just like self.assertTrue(a is b), but with a nicer default message.
|
| assertIsInstance(self, obj, cls, msg=None)
| Same as self.assertTrue(isinstance(obj, cls)), with a nicer
| default message.
|
| assertIsNone(self, obj, msg=None)
| Same as self.assertTrue(obj is None), with a nicer default message.
|
| assertIsNot(self, expr1, expr2, msg=None)
| Just like self.assertTrue(a is not b), but with a nicer default message.
|
| assertIsNotNone(self, obj, msg=None)
| Included for symmetry with assertIsNone.
|
| assertItemsEqual(self, expected_seq, actual_seq, msg=None)
| An unordered sequence specific comparison. It asserts that
| actual_seq and expected_seq have the same element counts.
| Equivalent to::
|
| self.assertEqual(Counter(iter(actual_seq)),
| Counter(iter(expected_seq)))
|
| Asserts that each element has the same count in both sequences.
| Example:
| - [0, 1, 1] and [1, 0, 1] compare equal.
| - [0, 0, 1] and [0, 1] compare unequal.
|
| assertLess(self, a, b, msg=None)
| Just like self.assertTrue(a < b), but with a nicer default message.
|
| assertLessEqual(self, a, b, msg=None)
| Just like self.assertTrue(a <= b), but with a nicer default message.
|
| assertListEqual(self, list1, list2, msg=None)
| A list-specific equality assertion.
|
| Args:
| list1: The first list to compare.
| list2: The second list to compare.
| msg: Optional message to use on failure instead of a list of
| differences.
|
| assertMultiLineEqual(self, first, second, msg=None)
| Assert that two multi-line strings are equal.
|
| assertNotAlmostEqual(self, first, second, places=None, msg=None, delta=None)
| Fail if the two objects are equal as determined by their
| difference rounded to the given number of decimal places
| (default 7) and comparing to zero, or by comparing that the
| between the two objects is less than the given delta.
|
| Note that decimal places (from zero) are usually not the same
| as significant digits (measured from the most signficant digit).
|
| Objects that are equal automatically fail.
|
| assertNotAlmostEquals = assertNotAlmostEqual(self, first, second, places=None, msg=None, delta=None)
|
| assertNotEqual(self, first, second, msg=None)
| Fail if the two objects are equal as determined by the '!='
| operator.
|
| assertNotEquals = assertNotEqual(self, first, second, msg=None)
|
| assertNotIn(self, member, container, msg=None)
| Just like self.assertTrue(a not in b), but with a nicer default message.
|
| assertNotIsInstance(self, obj, cls, msg=None)
| Included for symmetry with assertIsInstance.
|
| assertNotRegexpMatches(self, text, unexpected_regexp, msg=None)
| Fail the test if the text matches the regular expression.
|
| assertRaises(self, excClass, callableObj=None, *args, **kwargs)
| Fail unless an exception of class excClass is raised
| by callableObj when invoked with arguments args and keyword
| arguments kwargs. If a different type of exception is
| raised, it will not be caught, and the test case will be
| deemed to have suffered an error, exactly as for an
| unexpected exception.
|
| If called with callableObj omitted or None, will return a
| context object used like this::
|
| with self.assertRaises(SomeException):
| do_something()
|
| The context manager keeps a reference to the exception as
| the 'exception' attribute. This allows you to inspect the
| exception after the assertion::
|
| with self.assertRaises(SomeException) as cm:
| do_something()
| the_exception = cm.exception
| self.assertEqual(the_exception.error_code, 3)
|
| assertRaisesRegexp(self, expected_exception, expected_regexp, callable_obj=None, *args, **kwargs)
| Asserts that the message in a raised exception matches a regexp.
|
| Args:
| expected_exception: Exception class expected to be raised.
| expected_regexp: Regexp (re pattern object or string) expected
| to be found in error message.
| callable_obj: Function to be called.
| args: Extra args.
| kwargs: Extra kwargs.
|
| assertRegexpMatches(self, text, expected_regexp, msg=None)
| Fail the test unless the text matches the regular expression.
|
| assertSequenceEqual(self, seq1, seq2, msg=None, seq_type=None)
| An equality assertion for ordered sequences (like lists and tuples).
|
| For the purposes of this function, a valid ordered sequence type is one
| which can be indexed, has a length, and has an equality operator.
|
| Args:
| seq1: The first sequence to compare.
| seq2: The second sequence to compare.
| seq_type: The expected datatype of the sequences, or None if no
| datatype should be enforced.
| msg: Optional message to use on failure instead of a list of
| differences.
|
| assertSetEqual(self, set1, set2, msg=None)
| A set-specific equality assertion.
|
| Args:
| set1: The first set to compare.
| set2: The second set to compare.
| msg: Optional message to use on failure instead of a list of
| differences.
|
| assertSetEqual uses ducktyping to support different types of sets, and
| is optimized for sets specifically (parameters must support a
| difference method).
|
| assertTrue(self, expr, msg=None)
| Check that the expression is true.
|
| assertTupleEqual(self, tuple1, tuple2, msg=None)
| A tuple-specific equality assertion.
|
| Args:
| tuple1: The first tuple to compare.
| tuple2: The second tuple to compare.
| msg: Optional message to use on failure instead of a list of
| differences.
|
| assert_ = assertTrue(self, expr, msg=None)
|
| countTestCases(self)
|
| debug(self)
| Run the test without collecting errors in a TestResult
|
| defaultTestResult(self)
|
| doCleanups(self)
| Execute all cleanup functions. Normally called for you after
| tearDown.
|
| fail(self, msg=None)
| Fail immediately, with the given message.
|
| failIf = deprecated_func(*args, **kwargs)
|
| failIfAlmostEqual = deprecated_func(*args, **kwargs)
|
| failIfEqual = deprecated_func(*args, **kwargs)
|
| failUnless = deprecated_func(*args, **kwargs)
|
| failUnlessAlmostEqual = deprecated_func(*args, **kwargs)
|
| failUnlessEqual = deprecated_func(*args, **kwargs)
|
| failUnlessRaises = deprecated_func(*args, **kwargs)
|
| id(self)
|
| run(self, result=None)
|
| setUp(self)
| Hook method for setting up the test fixture before exercising it.
|
| shortDescription(self)
| Returns a one-line description of the test, or None if no
| description has been provided.
|
| The default implementation of this method returns the first line of
| the specified test method's docstring.
|
| skipTest(self, reason)
| Skip this test.
|
| tearDown(self)
| Hook method for deconstructing the test fixture after testing it.
|
| ----------------------------------------------------------------------
| Class methods defined here:
|
| setUpClass(cls) from __builtin__.type
| Hook method for setting up class fixture before running tests in the class.
|
| tearDownClass(cls) from __builtin__.type
| Hook method for deconstructing the class fixture after running all tests in the class.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables (if defined)
|
| __weakref__
| list of weak references to the object (if defined)
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| failureException = <type 'exceptions.AssertionError'>
| Assertion failed.
|
| longMessage = False
|
| maxDiff = 640
None
Help on class TestLoader in module unittest.loader:
class TestLoader(__builtin__.object)
| This class is responsible for loading tests according to various criteria
| and returning them wrapped in a TestSuite
|
| Methods defined here:
|
| discover(self, start_dir, pattern='test*.py', top_level_dir=None)
| Find and return all test modules from the specified start
| directory, recursing into subdirectories to find them. Only test files
| that match the pattern will be loaded. (Using shell style pattern
| matching.)
|
| All test modules must be importable from the top level of the project.
| If the start directory is not the top level directory then the top
| level directory must be specified separately.
|
| If a test package name (directory with '__init__.py') matches the
| pattern then the package will be checked for a 'load_tests' function. If
| this exists then it will be called with loader, tests, pattern.
|
| If load_tests exists then discovery does *not* recurse into the package,
| load_tests is responsible for loading all tests in the package.
|
| The pattern is deliberately not stored as a loader attribute so that
| packages can continue discovery themselves. top_level_dir is stored so
| load_tests does not need to pass this argument in to loader.discover().
|
| getTestCaseNames(self, testCaseClass)
| Return a sorted sequence of method names found within testCaseClass
|
| loadTestsFromModule(self, module, use_load_tests=True)
| Return a suite of all tests cases contained in the given module
|
| loadTestsFromName(self, name, module=None)
| Return a suite of all tests cases given a string specifier.
|
| The name may resolve either to a module, a test case class, a
| test method within a test case class, or a callable object which
| returns a TestCase or TestSuite instance.
|
| The method optionally resolves the names relative to a given module.
|
| loadTestsFromNames(self, names, module=None)
| Return a suite of all tests cases found using the given sequence
| of string specifiers. See 'loadTestsFromName()'.
|
| loadTestsFromTestCase(self, testCaseClass)
| Return a suite of all tests cases contained in testCaseClass
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables (if defined)
|
| __weakref__
| list of weak references to the object (if defined)
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| sortTestMethodsUsing = <built-in function cmp>
| cmp(x, y) -> integer
|
| Return negative if x<y, zero if x==y, positive if x>y.
|
| suiteClass = <class 'unittest.suite.TestSuite'>
| A test suite is a composite test consisting of a number of TestCases.
|
| For use, create an instance of TestSuite, then add test case instances.
| When all tests have been added, the suite can be passed to a test
| runner, such as TextTestRunner. It will run the individual test cases
| in the order in which they were added, aggregating the results. When
| subclassing, do not forget to call the base class constructor.
|
| testMethodPrefix = 'test'
None
Help on class TestProgram in module unittest.main:
class TestProgram(__builtin__.object)
| A command-line program that runs a set of tests; this is primarily
| for making test modules conveniently executable.
|
| Methods defined here:
|
| __init__(self, module='__main__', defaultTest=None, argv=None, testRunner=None, testLoader=<unittest.loader.TestLoader object>, exit=True, verbosity=1, failfast=None, catchbreak=None, buffer=None)
|
| createTests(self)
|
| parseArgs(self, argv)
|
| runTests(self)
|
| usageExit(self, msg=None)
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables (if defined)
|
| __weakref__
| list of weak references to the object (if defined)
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| USAGE = 'Usage: %(progName)s [options] [test] [...]
Opti... ...
|
| buffer = None
|
| catchbreak = None
|
| failfast = None
|
| progName = None
None
Help on class TestResult in module unittest.result:
class TestResult(__builtin__.object)
| Holder for test result information.
|
| Test results are automatically managed by the TestCase and TestSuite
| classes, and do not need to be explicitly manipulated by writers of tests.
|
| Each instance holds the total number of tests run, and collections of
| failures and errors that occurred among those test runs. The collections
| contain tuples of (testcase, exceptioninfo), where exceptioninfo is the
| formatted traceback of the error that occurred.
|
| Methods defined here:
|
| __init__(self, stream=None, descriptions=None, verbosity=None)
|
| __repr__(self)
|
| addError(self, *args, **kw)
| Called when an error has occurred. 'err' is a tuple of values as
| returned by sys.exc_info().
|
| addExpectedFailure(self, test, err)
| Called when an expected failure/error occured.
|
| addFailure(self, *args, **kw)
| Called when an error has occurred. 'err' is a tuple of values as
| returned by sys.exc_info().
|
| addSkip(self, test, reason)
| Called when a test is skipped.
|
| addSuccess(self, test)
| Called when a test has completed successfully
|
| addUnexpectedSuccess(self, *args, **kw)
| Called when a test was expected to fail, but succeed.
|
| printErrors(self)
| Called by TestRunner after test run
|
| startTest(self, test)
| Called when the given test is about to be run
|
| startTestRun(self)
| Called once before any tests are executed.
|
| See startTest for a method called before each test.
|
| stop(self)
| Indicates that the tests should be aborted
|
| stopTest(self, test)
| Called when the given test has been run
|
| stopTestRun(self)
| Called once after all tests are executed.
|
| See stopTest for a method called after each test.
|
| wasSuccessful(self)
| Tells whether or not this result was a success
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables (if defined)
|
| __weakref__
| list of weak references to the object (if defined)
None
Help on class TestSuite in module unittest.suite:
class TestSuite(BaseTestSuite)
| A test suite is a composite test consisting of a number of TestCases.
|
| For use, create an instance of TestSuite, then add test case instances.
| When all tests have been added, the suite can be passed to a test
| runner, such as TextTestRunner. It will run the individual test cases
| in the order in which they were added, aggregating the results. When
| subclassing, do not forget to call the base class constructor.
|
| Method resolution order:
| TestSuite
| BaseTestSuite
| __builtin__.object
|
| Methods defined here:
|
| debug(self)
| Run the tests without collecting errors in a TestResult
|
| run(self, result, debug=False)
|
| ----------------------------------------------------------------------
| Methods inherited from BaseTestSuite:
|
| __call__(self, *args, **kwds)
|
| __eq__(self, other)
|
| __init__(self, tests=())
|
| __iter__(self)
|
| __ne__(self, other)
|
| __repr__(self)
|
| addTest(self, test)
|
| addTests(self, tests)
|
| countTestCases(self)
|
| ----------------------------------------------------------------------
| Data descriptors inherited from BaseTestSuite:
|
| __dict__
| dictionary for instance variables (if defined)
|
| __weakref__
| list of weak references to the object (if defined)
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from BaseTestSuite:
|
| __hash__ = None
None
Help on class TextTestRunner in module unittest.runner:
class TextTestRunner(__builtin__.object)
| A test runner class that displays results in textual form.
|
| It prints out the names of tests as they are run, errors as they
| occur, and a summary of the results at the end of the test run.
|
| Methods defined here:
|
| __init__(self, stream=<idlelib.PyShell.PseudoOutputFile object>, descriptions=True, verbosity=1, failfast=False, buffer=False, resultclass=None)
|
| run(self, test)
| Run the given test case or test suite.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables (if defined)
|
| __weakref__
| list of weak references to the object (if defined)
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| resultclass = <class 'unittest.runner.TextTestResult'>
| A test result class that can print formatted text results to a stream.
|
| Used by TextTestRunner.
None
Help on TestLoader in module unittest.loader object:
class TestLoader(__builtin__.object)
| This class is responsible for loading tests according to various criteria
| and returning them wrapped in a TestSuite
|
| Methods defined here:
|
| discover(self, start_dir, pattern='test*.py', top_level_dir=None)
| Find and return all test modules from the specified start
| directory, recursing into subdirectories to find them. Only test files
| that match the pattern will be loaded. (Using shell style pattern
| matching.)
|
| All test modules must be importable from the top level of the project.
| If the start directory is not the top level directory then the top
| level directory must be specified separately.
|
| If a test package name (directory with '__init__.py') matches the
| pattern then the package will be checked for a 'load_tests' function. If
| this exists then it will be called with loader, tests, pattern.
|
| If load_tests exists then discovery does *not* recurse into the package,
| load_tests is responsible for loading all tests in the package.
|
| The pattern is deliberately not stored as a loader attribute so that
| packages can continue discovery themselves. top_level_dir is stored so
| load_tests does not need to pass this argument in to loader.discover().
|
| getTestCaseNames(self, testCaseClass)
| Return a sorted sequence of method names found within testCaseClass
|
| loadTestsFromModule(self, module, use_load_tests=True)
| Return a suite of all tests cases contained in the given module
|
| loadTestsFromName(self, name, module=None)
| Return a suite of all tests cases given a string specifier.
|
| The name may resolve either to a module, a test case class, a
| test method within a test case class, or a callable object which
| returns a TestCase or TestSuite instance.
|
| The method optionally resolves the names relative to a given module.
|
| loadTestsFromNames(self, names, module=None)
| Return a suite of all tests cases found using the given sequence
| of string specifiers. See 'loadTestsFromName()'.
|
| loadTestsFromTestCase(self, testCaseClass)
| Return a suite of all tests cases contained in testCaseClass
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables (if defined)
|
| __weakref__
| list of weak references to the object (if defined)
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| sortTestMethodsUsing = <built-in function cmp>
| cmp(x, y) -> integer
|
| Return negative if x<y, zero if x==y, positive if x>y.
|
| suiteClass = <class 'unittest.suite.TestSuite'>
| A test suite is a composite test consisting of a number of TestCases.
|
| For use, create an instance of TestSuite, then add test case instances.
| When all tests have been added, the suite can be passed to a test
| runner, such as TextTestRunner. It will run the individual test cases
| in the order in which they were added, aggregating the results. When
| subclassing, do not forget to call the base class constructor.
|
| testMethodPrefix = 'test'
None
Help on function findTestCases in module unittest.loader:
findTestCases(module, prefix='test', sortUsing=<built-in function cmp>, suiteClass=<class 'unittest.suite.TestSuite'>)
None
Help on function getTestCaseNames in module unittest.loader:
getTestCaseNames(testCaseClass, prefix, sortUsing=<built-in function cmp>)
None
Help on class TestProgram in module unittest.main:
class TestProgram(__builtin__.object)
| A command-line program that runs a set of tests; this is primarily
| for making test modules conveniently executable.
|
| Methods defined here:
|
| __init__(self, module='__main__', defaultTest=None, argv=None, testRunner=None, testLoader=<unittest.loader.TestLoader object>, exit=True, verbosity=1, failfast=None, catchbreak=None, buffer=None)
|
| createTests(self)
|
| parseArgs(self, argv)
|
| runTests(self)
|
| usageExit(self, msg=None)
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables (if defined)
|
| __weakref__
| list of weak references to the object (if defined)
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| USAGE = 'Usage: %(progName)s [options] [test] [...]
Opti... ...
|
| buffer = None
|
| catchbreak = None
|
| failfast = None
|
| progName = None
None
Help on function makeSuite in module unittest.loader:
makeSuite(testCaseClass, prefix='test', sortUsing=<built-in function cmp>, suiteClass=<class 'unittest.suite.TestSuite'>)
None三、总结
至此，我们知道了。其实整个单元测试框架的逻辑出来了。分三步走：第一步testloader根据传入的参数获得相应的测试用例，即对应具体的测试方法， 然后makesuite在把所有的测试用例组装成testsuite，最后把testsiute传给testrunner进行执行。 而我们通常执行的unittest.main()，其实就是unittest.testprom方法，其执行的功能就是上面分析的三步，在第一步中其传入的参数是自身的模块__main__； 在第二步中把自身模块中的所有测试类中中的测试方法提取出来，并生成测试套件；最后再把测试套件传递给testrunner进行具体的测试。 最后给出一个完整的单元测试组织代码，把该代码放到单元测试用例文件的同一个目录后执行该脚本，即可执行所有的测试用例文件。
参考文章：http://blog.csdn.net/five3/article/details/7104466