add unittest assertion for logging

Lib/unittest/case.py

 """Test case implementation"""
 
 import sys
 import functools
 import difflib
 import logging
 import pprint
 import re
 import warnings
 import collections
@@ skipping 701 matching lines @@
            This allows you to inspect the warning after the assertion::
 
                with self.assertWarns(SomeWarning) as cm:
                    do_something()
                the_warning = cm.warning
                self.assertEqual(the_warning.some_attribute, 147)
         """
         context = _AssertWarnsContext(expected_warning, self, callable_obj)
         return context.handle('assertWarns', callable_obj, args, kwargs)
 
-    def assertLogs(self, logger_name=None, level=None):
+    def assertLogs(self, logger=None, level=None):
         """Fail unless a log message of level *level* or higher is emitted
         on *logger_name* or its children.  If omitted, *level* defaults to
-        INFO and *logger_name* defaults to the root logger.
+        INFO and *logger* defaults to the root logger.
 
         This method must be used as a context manager, and will yield
         a recording object with two attributes: `output` and `records`.
         At the end of the context manager, the `output` attribute will
         be a list of the matching formatted log messages and the
         `records` attribute will be a list of the corresponding LogRecord
         objects.
 
         Example::
 
             with self.assertLogs('foo', level='INFO') as cm:
                 logging.getLogger('foo').info('first message')
                 logging.getLogger('foo.bar').error('second message')
             self.assertEqual(cm.output, ['INFO:foo:first message',
                                          'ERROR:foo.bar:second message'])
         """
-        return _AssertLogsContext(self, logger_name, level)
+        return _AssertLogsContext(self, logger, level)
 
     def _getAssertEqualityFunc(self, first, second):
         """Get a detailed comparison function for the types of the two args.
 
         Returns: A callable accepting (first, second, msg=None) that will
         raise a failure exception if first != second with a useful human
         readable error message for those types.
         """
         #
         # NOTE(gregory.p.smith): I considered isinstance(first, type(second))
@@ skipping 629 matching lines @@
         return "{} {}".format(self.test_case.id(), self._subDescription())
 
     def shortDescription(self):
         """Returns a one-line description of the subtest, or None if no
         description has been provided.
         """
         return self.test_case.shortDescription()
 
     def __str__(self):
         return "{} {}".format(self.test_case, self._subDescription())