Back to index

python3.2  3.2.2
Public Member Functions | Public Attributes | Static Public Attributes
test.test_logging.WarningsTest Class Reference
Inheritance diagram for test.test_logging.WarningsTest:
Inheritance graph
[legend]
Collaboration diagram for test.test_logging.WarningsTest:
Collaboration graph
[legend]

List of all members.

Public Member Functions

def test_warnings
def setUp
def tearDown
def assert_log_lines
def next_message

Public Attributes

 saved_handlers
 saved_handler_list
 saved_loggers
 saved_level_names
 logger_states
 logger1
 logger2
 root_logger
 original_logging_level
 stream
 root_hdlr
 root_formatter

Static Public Attributes

string log_format = "%(name)s -> %(levelname)s: %(message)s"
string expected_log_pat = r"^([\w.]+) -> ([\w]+): ([\d]+)$"
int message_num = 0

Detailed Description

Definition at line 1081 of file test_logging.py.


Member Function Documentation

def test.test_logging.BaseTest.assert_log_lines (   self,
  expected_values,
  stream = None 
) [inherited]
Match the collected log lines against the regular expression
self.expected_log_pat, and compare the extracted group values to
the expected_values list of tuples.

Definition at line 131 of file test_logging.py.

00131 
00132     def assert_log_lines(self, expected_values, stream=None):
00133         """Match the collected log lines against the regular expression
00134         self.expected_log_pat, and compare the extracted group values to
00135         the expected_values list of tuples."""
00136         stream = stream or self.stream
00137         pat = re.compile(self.expected_log_pat)
00138         try:
00139             stream.reset()
00140             actual_lines = stream.readlines()
00141         except AttributeError:
00142             # StringIO.StringIO lacks a reset() method.
00143             actual_lines = stream.getvalue().splitlines()
00144         self.assertEqual(len(actual_lines), len(expected_values),
00145                           '%s vs. %s' % (actual_lines, expected_values))
00146         for actual, expected in zip(actual_lines, expected_values):
00147             match = pat.search(actual)
00148             if not match:
00149                 self.fail("Log line does not match expected pattern:\n" +
00150                             actual)
00151             self.assertEqual(tuple(match.groups()), expected)
00152         s = stream.read()
00153         if s:
00154             self.fail("Remaining output at end of log stream:\n" + s)

Here is the call graph for this function:

Here is the caller graph for this function:

def test.test_logging.BaseTest.next_message (   self) [inherited]
Generate a message consisting solely of an auto-incrementing
integer.

Definition at line 155 of file test_logging.py.

00155 
00156     def next_message(self):
00157         """Generate a message consisting solely of an auto-incrementing
00158         integer."""
00159         self.message_num += 1
00160         return "%d" % self.message_num
00161 

Here is the caller graph for this function:

def test.test_logging.BaseTest.setUp (   self) [inherited]
Setup the default logging stream to an internal StringIO instance,
so that we can examine log output as we want.

Reimplemented in test.test_logging.BaseFileTest, test.test_logging.QueueHandlerTest, test.test_logging.LogRecordFactoryTest, test.test_logging.MemoryTest, test.test_logging.SocketHandlerTest, test.test_logging.MemoryHandlerTest, and test.test_logging.CustomLevelsAndFiltersTest.

Definition at line 63 of file test_logging.py.

00063 
00064     def setUp(self):
00065         """Setup the default logging stream to an internal StringIO instance,
00066         so that we can examine log output as we want."""
00067         logger_dict = logging.getLogger().manager.loggerDict
00068         logging._acquireLock()
00069         try:
00070             self.saved_handlers = logging._handlers.copy()
00071             self.saved_handler_list = logging._handlerList[:]
00072             self.saved_loggers = saved_loggers = logger_dict.copy()
00073             self.saved_level_names = logging._levelNames.copy()
00074             self.logger_states = logger_states = {}
00075             for name in saved_loggers:
00076                 logger_states[name] = getattr(saved_loggers[name],
00077                                               'disabled', None)
00078         finally:
00079             logging._releaseLock()
00080 
00081         # Set two unused loggers: one non-ASCII and one Unicode.
00082         # This is to test correct operation when sorting existing
00083         # loggers in the configuration code. See issue 8201.
00084         self.logger1 = logging.getLogger("\xab\xd7\xbb")
00085         self.logger2 = logging.getLogger("\u013f\u00d6\u0047")
00086 
00087         self.root_logger = logging.getLogger("")
00088         self.original_logging_level = self.root_logger.getEffectiveLevel()
00089 
00090         self.stream = io.StringIO()
00091         self.root_logger.setLevel(logging.DEBUG)
00092         self.root_hdlr = logging.StreamHandler(self.stream)
00093         self.root_formatter = logging.Formatter(self.log_format)
00094         self.root_hdlr.setFormatter(self.root_formatter)
00095         if self.logger1.hasHandlers():
00096             hlist = self.logger1.handlers + self.root_logger.handlers
00097             raise AssertionError('Unexpected handlers: %s' % hlist)
00098         if self.logger2.hasHandlers():
00099             hlist = self.logger2.handlers + self.root_logger.handlers
00100             raise AssertionError('Unexpected handlers: %s' % hlist)
00101         self.root_logger.addHandler(self.root_hdlr)
00102         self.assertTrue(self.logger1.hasHandlers())
00103         self.assertTrue(self.logger2.hasHandlers())

Here is the call graph for this function:

Here is the caller graph for this function:

def test.test_logging.BaseTest.tearDown (   self) [inherited]
Remove our logging stream, and restore the original logging
level.

Reimplemented in test.test_logging.BaseFileTest, test.test_logging.QueueHandlerTest, test.test_logging.LogRecordFactoryTest, test.test_logging.SocketHandlerTest, and test.test_logging.MemoryHandlerTest.

Definition at line 104 of file test_logging.py.

00104 
00105     def tearDown(self):
00106         """Remove our logging stream, and restore the original logging
00107         level."""
00108         self.stream.close()
00109         self.root_logger.removeHandler(self.root_hdlr)
00110         while self.root_logger.handlers:
00111             h = self.root_logger.handlers[0]
00112             self.root_logger.removeHandler(h)
00113             h.close()
00114         self.root_logger.setLevel(self.original_logging_level)
00115         logging._acquireLock()
00116         try:
00117             logging._levelNames.clear()
00118             logging._levelNames.update(self.saved_level_names)
00119             logging._handlers.clear()
00120             logging._handlers.update(self.saved_handlers)
00121             logging._handlerList[:] = self.saved_handler_list
00122             loggerDict = logging.getLogger().manager.loggerDict
00123             loggerDict.clear()
00124             loggerDict.update(self.saved_loggers)
00125             logger_states = self.logger_states
00126             for name in self.logger_states:
00127                 if logger_states[name] is not None:
00128                     self.saved_loggers[name].disabled = logger_states[name]
00129         finally:
00130             logging._releaseLock()

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 1083 of file test_logging.py.

01083 
01084     def test_warnings(self):
01085         with warnings.catch_warnings():
01086             logging.captureWarnings(True)
01087             try:
01088                 warnings.filterwarnings("always", category=UserWarning)
01089                 file = io.StringIO()
01090                 h = logging.StreamHandler(file)
01091                 logger = logging.getLogger("py.warnings")
01092                 logger.addHandler(h)
01093                 warnings.warn("I'm warning you...")
01094                 logger.removeHandler(h)
01095                 s = file.getvalue()
01096                 h.close()
01097                 self.assertTrue(s.find("UserWarning: I'm warning you...\n") > 0)
01098 
01099                 #See if an explicit file uses the original implementation
01100                 file = io.StringIO()
01101                 warnings.showwarning("Explicit", UserWarning, "dummy.py", 42,
01102                                         file, "Dummy line")
01103                 s = file.getvalue()
01104                 file.close()
01105                 self.assertEqual(s,
01106                         "dummy.py:42: UserWarning: Explicit\n  Dummy line\n")
01107             finally:
01108                 logging.captureWarnings(False)
01109 

Here is the call graph for this function:


Member Data Documentation

string test.test_logging.BaseTest.expected_log_pat = r"^([\w.]+) -> ([\w]+): ([\d]+)$" [static, inherited]
string test.test_logging.BaseTest.log_format = "%(name)s -> %(levelname)s: %(message)s" [static, inherited]

Definition at line 59 of file test_logging.py.

Definition at line 83 of file test_logging.py.

Definition at line 84 of file test_logging.py.

Definition at line 73 of file test_logging.py.

Definition at line 61 of file test_logging.py.

Definition at line 87 of file test_logging.py.

Definition at line 92 of file test_logging.py.

Definition at line 91 of file test_logging.py.

Definition at line 86 of file test_logging.py.

Definition at line 70 of file test_logging.py.

Definition at line 69 of file test_logging.py.

Definition at line 72 of file test_logging.py.

Definition at line 71 of file test_logging.py.

Definition at line 89 of file test_logging.py.


The documentation for this class was generated from the following file: