3.7 unittest之断言

3.7 unittest之断言

前言
在测试用例中，执行完测试用例后，最后一步是判断测试结果是pass还是fail，自动化测试脚本里面一般把这种生成测试结果的方法称为断言（assert）。
用unittest组件测试用例的时候，断言的方法还是很多的，下面介绍几种常用的断言方法：assertEqual、assertIn、assertTrue

3.7.1 简单案例

1）.下面写了4个case，其中第四个是执行失败的

# coding:utf-8
import unittest

class Test(unittest.TestCase):
    def test01(self):
        '''判断 a == b '''
        a = 1
        b = 1
        self.assertEqual(a, b)
    def test02(self):
        '''判断 a in b'''
        a = "hello"
        b = "hello world!"
        self.assertIn(a, b)

    def test03(self):
        '''判断 a isTrue '''
        a = True
        self.assertTrue(a)
    def test04(self):
        '''失败案例'''
        a = "上海-悠悠"
        b = "yoyo"
        self.assertEqual(a, b)

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

2）.执行结果如下
Failure
Expected :'\xe4\xb8\x8a\xe6\xb5\xb7-\xe6\x82\xa0\xe6\x82\xa0'
Actual   :'yoyo'
 <Click to see difference>
Traceback (most recent call last):
  File "D:\test\yoyotest\kecheng\test12.py", line 27, in test04
    self.assertEqual(a, b)
AssertionError: '\xe4\xb8\x8a\xe6\xb5\xb7-\xe6\x82\xa0\xe6\x82\xa0' != 'yoyo'
3.执行的结果，中文编码不对，没正常显示中文，遇到这种情况，可以自定义异常输出

3.7.2 自定义异常

1）.以assertEqual为例分析：
assertEqual(self, first, second, msg=None)
    Fail if the two objects are unequal as determined by the'=='
    operator.
2）.翻译：如果两个对象不能相等，就返回失败，相当于return: first==second
3）.这里除了相比较的两个参数first和second，还有第三个参数msg=None,这个msg参数就是遇到异常后自定义输出信息

3.7.3 unittest常用的断言方法

1）.assertEqual(self, first, second,msg=None)

--判断两个参数相等：first == second
2）.assertNotEqual(self, first, second,msg=None)
--判断两个参数不相等：first ！= second
3）.assertIn(self, member, container,msg=None)
--判断是字符串是否包含：member in container
4）.assertNotIn(self, member,container, msg=None)
--判断是字符串是否不包含：member not in container
5）.assertTrue(self, expr, msg=None)
--判断是否为真：expr is True
6）.assertFalse(self, expr, msg=None)
--判断是否为假：expr is False

7）.assertIsNone(self, obj, msg=None)
--判断是否为None：objis None
8）.assertIsNotNone(self, obj,msg=None)
--判断是否不为None：obj is not None
3.7.4 unittest所有断言方法
1）.下面是unittest框架支持的所有断言方法，有兴趣的同学可以慢慢看。(官方资料)

|  assertAlmostEqual(self, first, second, places=None, msg=None,delta=None)
|      Fail if the two objects are unequal asdetermined by their
|      difference rounded to the given number ofdecimal places
|      (default 7) and comparing to zero, or bycomparing that the
|      between the two objects is more than the givendelta.
|
|      Note that decimal places (from zero) areusually not the same
|      as significant digits (measured from the mostsignficant digit).
|
|      If the two objects compare equal then they willautomatically
|      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 ofexpected.
|
|  assertDictEqual(self, d1, d2, msg=None)
|
|  assertEqual(self, first, second, msg=None)
|      Fail if the two objects are unequal asdetermined 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 anicer default message.
|
|  assertGreaterEqual(self, a, b, msg=None)
|      Just like self.assertTrue(a >= b), but witha nicer default message.
|
|  assertIn(self, member, container, msg=None)
|      Just like self.assertTrue(a in b), but with anicer default message.
|
|  assertIs(self, expr1, expr2, msg=None)
|      Just like self.assertTrue(a is b), but with anicer 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 anicer default message.
|
|  assertIsNot(self, expr1, expr2, msg=None)
|      Just like self.assertTrue(a is not b), but witha 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. Itasserts that
|      actual_seq and expected_seq have the sameelement counts.
|      Equivalent to::
|
|         self.assertEqual(Counter(iter(actual_seq)),
|                          Counter(iter(expected_seq)))
|
|      Asserts that each element has the same count inboth 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 anicer default message.
|
|  assertLessEqual(self, a, b, msg=None)
|      Just like self.assertTrue(a <= b), but witha nicer default message.
|
|  assertListEqual(self, list1, list2, msg=None)
|      A list-specific equality assertion.
|
|      Args:
|          list1: The first listto compare.
|          list2: The second listto compare.
|          msg: Optional messageto 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 determinedby their
|      difference rounded to the given number ofdecimal places
|      (default 7) and comparing to zero, or bycomparing that the
|      between the two objects is less than the givendelta.
|
|      Note that decimal places (from zero) areusually not the same
|      as significant digits (measured from the mostsignficant 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 determinedby the '!='
|      operator.
|
|  assertNotEquals = assertNotEqual(self, first, second, msg=None)
|
|  assertNotIn(self, member, container, msg=None)
|      Just like self.assertTrue(a not in b), but witha 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 regularexpression.
|
|  assertRaises(self, excClass, callableObj=None, *args, **kwargs)
|      Fail unless an exception of class excClass israised
|      by callableObj when invoked with arguments argsand keyword
|      arguments kwargs. If a different type ofexception is
|      raised, it will not be caught, and the testcase will be
|      deemed to have suffered an error, exactly asfor an
|      unexpected exception.
|
|      If called with callableObj omitted or None,will return a
|      context object used like this::
|
|           withself.assertRaises(SomeException):
|              do_something()
|
|      The context manager keeps a reference to theexception as
|      the 'exception' attribute. This allows you toinspect the
|      exception after the assertion::
|
|          withself.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 exceptionmatches 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: Functionto be called.
|          args: Extra args.
|          kwargs: Extra kwargs.
|
|  assertRegexpMatches(self, text, expected_regexp, msg=None)
|      Fail the test unless the text matches theregular 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 validordered sequence type is one
one
|      which can be indexed, has a length, and has anequality operator.
|
|      Args:
|          seq1: The firstsequence to compare.
|          seq2: The secondsequence to compare.
|          seq_type: The expecteddatatype of the sequences, or None if no
|                 datatype should be enforced.
|          msg: Optional messageto 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 tocompare.
|          set2: The second set tocompare.
|          msg: Optional messageto use on failure instead of a list of
|                 differences.
|
|      assertSetEqual uses ducktyping to supportdifferent types of sets, and
|      is optimized for sets specifically (parametersmust 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 tupleto compare.
|          tuple2: The secondtuple to compare.
|          msg: Optional messageto use on failure instead of a list of
|                 differences.