您的位置:首页 > 编程语言 > Python开发

Python单元测试unittest加载方式之二:加载测试套件

2015-06-26 19:52 836 查看
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']
在IDLE中查看如下图:



可以看到其自身的成员也不是很多,大概包括有:

['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] [...]\n\nOpti...        ...
|
|  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] [...]\n\nOpti...        ...
|
|  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
内容来自用户分享和网络整理,不保证内容的准确性,如有侵权内容,可联系管理员处理 点击这里给我发消息
标签: