aboutsummaryrefslogtreecommitdiffstats
path: root/contrib/tools/python3/src/Lib/unittest/_log.py
blob: 9ec03f1262ab4abb9d03f244b09099e83613d877 (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
import logging 
import collections 
 
from .case import _BaseTestCaseContext 
 
 
_LoggingWatcher = collections.namedtuple("_LoggingWatcher", 
                                         ["records", "output"]) 
 
class _CapturingHandler(logging.Handler): 
    """ 
    A logging handler capturing all (raw and formatted) logging output. 
    """ 
 
    def __init__(self): 
        logging.Handler.__init__(self) 
        self.watcher = _LoggingWatcher([], []) 
 
    def flush(self): 
        pass 
 
    def emit(self, record): 
        self.watcher.records.append(record) 
        msg = self.format(record) 
        self.watcher.output.append(msg) 
 
 
class _AssertLogsContext(_BaseTestCaseContext): 
    """A context manager used to implement TestCase.assertLogs().""" 
 
    LOGGING_FORMAT = "%(levelname)s:%(name)s:%(message)s" 
 
    def __init__(self, test_case, logger_name, level): 
        _BaseTestCaseContext.__init__(self, test_case) 
        self.logger_name = logger_name 
        if level: 
            self.level = logging._nameToLevel.get(level, level) 
        else: 
            self.level = logging.INFO 
        self.msg = None 
 
    def __enter__(self): 
        if isinstance(self.logger_name, logging.Logger): 
            logger = self.logger = self.logger_name 
        else: 
            logger = self.logger = logging.getLogger(self.logger_name) 
        formatter = logging.Formatter(self.LOGGING_FORMAT) 
        handler = _CapturingHandler() 
        handler.setFormatter(formatter) 
        self.watcher = handler.watcher 
        self.old_handlers = logger.handlers[:] 
        self.old_level = logger.level 
        self.old_propagate = logger.propagate 
        logger.handlers = [handler] 
        logger.setLevel(self.level) 
        logger.propagate = False 
        return handler.watcher 
 
    def __exit__(self, exc_type, exc_value, tb): 
        self.logger.handlers = self.old_handlers 
        self.logger.propagate = self.old_propagate 
        self.logger.setLevel(self.old_level) 
        if exc_type is not None: 
            # let unexpected exceptions pass through 
            return False 
        if len(self.watcher.records) == 0: 
            self._raiseFailure( 
                "no logs of level {} or higher triggered on {}" 
                .format(logging.getLevelName(self.level), self.logger.name))