← Back to branch summary

~ubuntu-branches/ubuntu/trusty/cinder/trusty

« back to all changes in this revision

Viewing changes to cinder/tests/test_log.py

  • Committer: Package Import Robot
  • Author(s): Chuck Short
  • Date: 2012-05-22 09:57:46 UTC
  • Revision ID: package-import@ubuntu.com-20120522095746-9lm71yvzltjybk4b
Tags: upstream-2012.2~f1~20120503.2
Import upstream version 2012.2~f1~20120503.2

Show diffs side-by-side

added added

removed removed

Lines of Context:
cinder/tests/test_log.py
 
1
import cStringIO
 
2
import json
 
3
import logging
 
4
import sys
 
5
 
 
6
from cinder import context
 
7
from cinder import flags
 
8
from cinder import log
 
9
from cinder.notifier import api as notifier
 
10
from cinder import test
 
11
 
 
12
FLAGS = flags.FLAGS
 
13
flags.DECLARE('list_notifier_drivers',
 
14
              'cinder.notifier.list_notifier')
 
15
 
 
16
 
 
17
def _fake_context():
 
18
    return context.RequestContext(1, 1)
 
19
 
 
20
 
 
21
class LoggerTestCase(test.TestCase):
 
22
    def setUp(self):
 
23
        super(LoggerTestCase, self).setUp()
 
24
        self.log = log.getLogger()
 
25
 
 
26
    def test_handlers_have_cinder_formatter(self):
 
27
        formatters = []
 
28
        for h in self.log.logger.handlers:
 
29
            f = h.formatter
 
30
            if isinstance(f, log.LegacyCinderFormatter):
 
31
                formatters.append(f)
 
32
        self.assert_(formatters)
 
33
        self.assertEqual(len(formatters), len(self.log.logger.handlers))
 
34
 
 
35
    def test_handles_context_kwarg(self):
 
36
        self.log.info("foo", context=_fake_context())
 
37
        self.assert_(True)  # didn't raise exception
 
38
 
 
39
    def test_audit_handles_context_arg(self):
 
40
        self.log.audit("foo", context=_fake_context())
 
41
        self.assert_(True)  # didn't raise exception
 
42
 
 
43
    def test_will_be_verbose_if_verbose_flag_set(self):
 
44
        self.flags(verbose=True)
 
45
        log.setup()
 
46
        self.assertEqual(logging.DEBUG, self.log.logger.getEffectiveLevel())
 
47
 
 
48
    def test_will_not_be_verbose_if_verbose_flag_not_set(self):
 
49
        self.flags(verbose=False)
 
50
        log.setup()
 
51
        self.assertEqual(logging.INFO, self.log.logger.getEffectiveLevel())
 
52
 
 
53
    def test_no_logging_via_module(self):
 
54
        for func in ('critical', 'error', 'exception', 'warning', 'warn',
 
55
                     'info', 'debug', 'log', 'audit'):
 
56
            self.assertRaises(AttributeError, getattr, log, func)
 
57
 
 
58
 
 
59
class LogHandlerTestCase(test.TestCase):
 
60
    def test_log_path_logdir(self):
 
61
        self.flags(logdir='/some/path', logfile=None)
 
62
        self.assertEquals(log._get_log_file_path(binary='foo-bar'),
 
63
                         '/some/path/foo-bar.log')
 
64
 
 
65
    def test_log_path_logfile(self):
 
66
        self.flags(logfile='/some/path/foo-bar.log')
 
67
        self.assertEquals(log._get_log_file_path(binary='foo-bar'),
 
68
                         '/some/path/foo-bar.log')
 
69
 
 
70
    def test_log_path_none(self):
 
71
        self.flags(logdir=None, logfile=None)
 
72
        self.assertTrue(log._get_log_file_path(binary='foo-bar') is None)
 
73
 
 
74
    def test_log_path_logfile_overrides_logdir(self):
 
75
        self.flags(logdir='/some/other/path',
 
76
                   logfile='/some/path/foo-bar.log')
 
77
        self.assertEquals(log._get_log_file_path(binary='foo-bar'),
 
78
                         '/some/path/foo-bar.log')
 
79
 
 
80
 
 
81
class PublishErrorsHandlerTestCase(test.TestCase):
 
82
    """Tests for cinder.log.PublishErrorsHandler"""
 
83
    def setUp(self):
 
84
        super(PublishErrorsHandlerTestCase, self).setUp()
 
85
        self.publiserrorshandler = log.PublishErrorsHandler(logging.ERROR)
 
86
 
 
87
    def test_emit_cfg_list_notifier_drivers_in_flags(self):
 
88
        self.stub_flg = False
 
89
 
 
90
        def fake_notifier(*args, **kwargs):
 
91
            self.stub_flg = True
 
92
 
 
93
        self.stubs.Set(notifier, 'notify', fake_notifier)
 
94
        logrecord = logging.LogRecord('name', 'WARN', '/tmp', 1,
 
95
                                      'Message', None, None)
 
96
        self.publiserrorshandler.emit(logrecord)
 
97
        self.assertTrue(self.stub_flg)
 
98
 
 
99
    def test_emit_cfg_log_notifier_in_list_notifier_drivers(self):
 
100
        self.flags(list_notifier_drivers=['cinder.notifier.rabbit_notifier',
 
101
                                          'cinder.notifier.log_notifier'])
 
102
        self.stub_flg = True
 
103
 
 
104
        def fake_notifier(*args, **kwargs):
 
105
            self.stub_flg = False
 
106
 
 
107
        self.stubs.Set(notifier, 'notify', fake_notifier)
 
108
        logrecord = logging.LogRecord('name', 'WARN', '/tmp', 1,
 
109
                                      'Message', None, None)
 
110
        self.publiserrorshandler.emit(logrecord)
 
111
        self.assertTrue(self.stub_flg)
 
112
 
 
113
 
 
114
class CinderFormatterTestCase(test.TestCase):
 
115
    def setUp(self):
 
116
        super(CinderFormatterTestCase, self).setUp()
 
117
        self.flags(logging_context_format_string="HAS CONTEXT "
 
118
                                                 "[%(request_id)s]: "
 
119
                                                 "%(message)s",
 
120
                   logging_default_format_string="NOCTXT: %(message)s",
 
121
                   logging_debug_format_suffix="--DBG")
 
122
        self.log = log.getLogger()
 
123
        self.stream = cStringIO.StringIO()
 
124
        self.handler = logging.StreamHandler(self.stream)
 
125
        self.handler.setFormatter(log.LegacyCinderFormatter())
 
126
        self.log.logger.addHandler(self.handler)
 
127
        self.level = self.log.logger.getEffectiveLevel()
 
128
        self.log.logger.setLevel(logging.DEBUG)
 
129
 
 
130
    def tearDown(self):
 
131
        self.log.logger.setLevel(self.level)
 
132
        self.log.logger.removeHandler(self.handler)
 
133
        super(CinderFormatterTestCase, self).tearDown()
 
134
 
 
135
    def test_uncontextualized_log(self):
 
136
        self.log.info("foo")
 
137
        self.assertEqual("NOCTXT: foo\n", self.stream.getvalue())
 
138
 
 
139
    def test_contextualized_log(self):
 
140
        ctxt = _fake_context()
 
141
        self.log.info("bar", context=ctxt)
 
142
        expected = "HAS CONTEXT [%s]: bar\n" % ctxt.request_id
 
143
        self.assertEqual(expected, self.stream.getvalue())
 
144
 
 
145
    def test_debugging_log(self):
 
146
        self.log.debug("baz")
 
147
        self.assertEqual("NOCTXT: baz --DBG\n", self.stream.getvalue())
 
148
 
 
149
 
 
150
class CinderLoggerTestCase(test.TestCase):
 
151
    def setUp(self):
 
152
        super(CinderLoggerTestCase, self).setUp()
 
153
        levels = FLAGS.default_log_levels
 
154
        levels.append("cinder-test=AUDIT")
 
155
        self.flags(default_log_levels=levels,
 
156
                   verbose=True)
 
157
        log.setup()
 
158
        self.log = log.getLogger('cinder-test')
 
159
 
 
160
    def test_has_level_from_flags(self):
 
161
        self.assertEqual(logging.AUDIT, self.log.logger.getEffectiveLevel())
 
162
 
 
163
    def test_child_log_has_level_of_parent_flag(self):
 
164
        l = log.getLogger('cinder-test.foo')
 
165
        self.assertEqual(logging.AUDIT, l.logger.getEffectiveLevel())
 
166
 
 
167
 
 
168
class JSONFormatterTestCase(test.TestCase):
 
169
    def setUp(self):
 
170
        super(JSONFormatterTestCase, self).setUp()
 
171
        self.log = log.getLogger('test-json')
 
172
        self.stream = cStringIO.StringIO()
 
173
        handler = logging.StreamHandler(self.stream)
 
174
        handler.setFormatter(log.JSONFormatter())
 
175
        self.log.logger.addHandler(handler)
 
176
        self.log.logger.setLevel(logging.DEBUG)
 
177
 
 
178
    def test_json(self):
 
179
        test_msg = 'This is a %(test)s line'
 
180
        test_data = {'test': 'log'}
 
181
        self.log.debug(test_msg, test_data)
 
182
 
 
183
        data = json.loads(self.stream.getvalue())
 
184
        self.assertTrue(data)
 
185
        self.assertTrue('extra' in data)
 
186
        self.assertEqual('test-json', data['name'])
 
187
 
 
188
        self.assertEqual(test_msg % test_data, data['message'])
 
189
        self.assertEqual(test_msg, data['msg'])
 
190
        self.assertEqual(test_data, data['args'])
 
191
 
 
192
        self.assertEqual('test_log.py', data['filename'])
 
193
        self.assertEqual('test_json', data['funcname'])
 
194
 
 
195
        self.assertEqual('DEBUG', data['levelname'])
 
196
        self.assertEqual(logging.DEBUG, data['levelno'])
 
197
        self.assertFalse(data['traceback'])
 
198
 
 
199
    def test_json_exception(self):
 
200
        test_msg = 'This is %s'
 
201
        test_data = 'exceptional'
 
202
        try:
 
203
            raise Exception('This is exceptional')
 
204
        except Exception:
 
205
            self.log.exception(test_msg, test_data)
 
206
 
 
207
        data = json.loads(self.stream.getvalue())
 
208
        self.assertTrue(data)
 
209
        self.assertTrue('extra' in data)
 
210
        self.assertEqual('test-json', data['name'])
 
211
 
 
212
        self.assertEqual(test_msg % test_data, data['message'])
 
213
        self.assertEqual(test_msg, data['msg'])
 
214
        self.assertEqual([test_data], data['args'])
 
215
 
 
216
        self.assertEqual('ERROR', data['levelname'])
 
217
        self.assertEqual(logging.ERROR, data['levelno'])
 
218
        self.assertTrue(data['traceback'])