Package flumotion :: Package extern :: Package log :: Module test_log
[hide private]

Source Code for Module flumotion.extern.log.test_log

  1  # -*- Mode: Python; test-case-name: test_log -*- 
  2  # vi:si:et:sw=4:sts=4:ts=4 
  3   
  4  # Flumotion - a streaming media server 
  5  # Copyright (C) 2004,2005,2006,2007,2008,2009 Fluendo, S.L. 
  6  # Copyright (C) 2010,2011 Flumotion Services, S.A. 
  7  # All rights reserved. 
  8  # 
  9  # This file may be distributed and/or modified under the terms of 
 10  # the GNU Lesser General Public License version 2.1 as published by 
 11  # the Free Software Foundation. 
 12  # This file is distributed without any warranty; without even the implied 
 13  # warranty of merchantability or fitness for a particular purpose. 
 14  # See "LICENSE.LGPL" in the source distribution for more information. 
 15  # 
 16  # Headers in this file shall remain intact. 
 17   
 18   
 19  import logging 
 20   
 21  from twisted.trial import unittest 
 22   
 23  import log 
 24   
 25  __version__ = "$Rev$" 
 26   
 27   
28 -class LogTester(log.Loggable):
29 logCategory = 'testlog'
30 31
32 -class LogFunctionTester(log.Loggable):
33
34 - def logFunction(self, format, *args):
35 return (("override " + format), ) + args[1:]
36 37
38 -class TestLog(unittest.TestCase):
39
40 - def setUp(self):
41 self.category = self.level = self.message = None 42 self.tester = LogTester() 43 # we want to remove the default handler so it doesn't show up stuff 44 log.reset()
45 46 # just test for parsing semi- or non-valid FLU_DEBUG variables 47
48 - def testSetDebug(self):
49 log.setDebug(":5") 50 log.setDebug("*") 51 log.setDebug("5")
52
53 - def testGetLevelName(self):
54 self.assertRaises(AssertionError, log.getLevelName, -1) 55 self.assertRaises(AssertionError, log.getLevelName, 6)
56
57 - def testGetLevelInt(self):
58 self.assertRaises(AssertionError, log.getLevelInt, "NOLEVEL")
59
61 self.assertRaises(AssertionError, log.getFormattedLevelName, -1) 62 # FIXME: we're poking at internals here, but without calling this 63 # no format levels are set at all. 64 log._preformatLevels("ENVVAR") 65 self.failUnless("LOG" in log.getFormattedLevelName(log.LOG))
66
67 - def testGetFileLine(self):
68 # test a function object 69 (filename, line) = log.getFileLine(where=self.testGetFileLine) 70 self.failUnless(filename.endswith('test_log.py')) 71 self.assertEquals(line, 67) 72 73 # test a lambda 74 f = lambda x: x + 1 75 (filename, line) = log.getFileLine(where=f) 76 self.failUnless(filename.endswith('test_log.py')) 77 self.assertEquals(line, 74) 78 79 # test an eval 80 f = eval("lambda x: x + 1") 81 (filename, line) = log.getFileLine(where=f) 82 self.assertEquals(filename, '<string>') 83 self.assertEquals(line, 1)
84 85 # test for adding a log handler 86
87 - def testEllipsize(self):
88 self.assertEquals(log.ellipsize("*" * 1000), 89 "'" + "*" * 59 + ' ... ' + "*" * 14 + "'")
90
91 - def handler(self, level, object, category, file, line, message):
92 self.level = level 93 self.object = object 94 self.category = category 95 self.file = file 96 self.line = line 97 self.message = message
98
99 - def testLimitInvisible(self):
100 log.setDebug("testlog:3") 101 log.addLimitedLogHandler(self.handler) 102 103 # log 2 we shouldn't get 104 self.tester.log("not visible") 105 assert not self.category 106 assert not self.level 107 assert not self.message 108 109 self.tester.debug("not visible") 110 assert not self.category 111 assert not self.level 112 assert not self.message
113
114 - def testLimitedVisible(self):
115 log.setDebug("testlog:3") 116 log.addLimitedLogHandler(self.handler) 117 118 # log 3 we should get 119 self.tester.info("visible") 120 assert self.category == 'testlog' 121 assert self.level == log.INFO 122 assert self.message == 'visible' 123 124 self.tester.warning("also visible") 125 assert self.category == 'testlog' 126 assert self.level == log.WARN 127 assert self.message == 'also visible'
128
129 - def testFormatStrings(self):
130 log.setDebug("testlog:3") 131 log.addLimitedLogHandler(self.handler) 132 133 self.tester.info("%d %s", 42, 'the answer') 134 assert self.category == 'testlog' 135 assert self.level == log.INFO 136 assert self.message == '42 the answer'
137
138 - def testLimitedError(self):
139 log.setDebug("testlog:3") 140 log.addLimitedLogHandler(self.handler) 141 142 self.assertRaises(SystemExit, self.tester.error, "error") 143 assert self.category == 'testlog' 144 assert self.level == log.ERROR 145 assert self.message == 'error'
146
148 log.setDebug("testlog:3") 149 log.addLimitedLogHandler(self.handler) 150 151 # now try debug and log again too 152 log.setDebug("testlog:5") 153 154 self.tester.debug("debug") 155 assert self.category == 'testlog' 156 assert self.level == log.DEBUG 157 assert self.message == 'debug' 158 159 self.tester.log("log") 160 assert self.category == 'testlog' 161 assert self.level == log.LOG 162 assert self.message == 'log'
163 164 # test that we get all log messages 165
166 - def testLogHandler(self):
167 log.setDebug("testlog:3") 168 log.addLogHandler(self.handler) 169 170 self.tester.log("visible") 171 assert self.message == 'visible' 172 173 self.tester.warning("also visible") 174 assert self.message == 'also visible'
175
176 - def testAddLogHandlerRaises(self):
177 self.assertRaises(TypeError, log.addLogHandler, 1)
178
179 - def testAdaptStandardLogging(self):
180 # create a standard logger 181 logger = logging.getLogger('standard.logger') 182 183 # set the debug level for the "test" category 184 log.setDebug("test:3") 185 log.addLimitedLogHandler(self.handler) 186 187 logger.warning('invisible') 188 # should not get anything, because the std module has not been adapted 189 assert not self.category 190 assert not self.level 191 assert not self.message 192 193 log.adaptStandardLogging('standard.logger', 'test', 'test_log') 194 self.assertEquals(len(logger.handlers), 1) 195 196 # trying to adapt it again should be a noop 197 log.adaptStandardLogging('standard.logger', 'test', 'test_log') 198 self.assertEquals(len(logger.handlers), 1) 199 200 logger.info('invisible') 201 # should not get anything, because INFO translates to Flu debug 4 202 assert not self.category 203 assert not self.level 204 assert not self.message 205 206 logger.warning('visible') 207 # WARNING translates to INFO, see log.stdLevelToFluLevel 208 assert self.category == 'test', self.category 209 assert self.level == log.INFO 210 assert self.message == 'visible' 211 212 self.message = self.level = self.category = None 213 214 # lower the debug level 215 log.setDebug("test:2") 216 logger.warning('visible') 217 # should not get anything now 218 assert not self.category 219 assert not self.level 220 assert not self.message
221 222
223 -class TestOwnLogHandler(unittest.TestCase):
224
225 - def setUp(self):
226 self.category = self.level = self.message = None 227 self.tester = LogFunctionTester() 228 log.reset()
229
230 - def handler(self, level, object, category, file, line, message):
231 self.level = level 232 self.object = object 233 self.category = category 234 self.file = file 235 self.line = line 236 self.message = message
237 238 # test if our own log handler correctly mangles the message 239
240 - def testOwnLogHandlerLimited(self):
241 log.setDebug("testlog:3") 242 log.addLogHandler(self.handler) 243 244 self.tester.log("visible") 245 assert self.message == 'override visible'
246
247 - def testLogHandlerAssertion(self):
248 self.assertRaises(TypeError, log.addLimitedLogHandler, None)
249 250
251 -class TestGetExceptionMessage(unittest.TestCase):
252
253 - def setUp(self):
254 log.reset()
255
256 - def func3(self):
257 self.func2()
258
259 - def func2(self):
260 self.func1()
261
262 - def func1(self):
263 raise TypeError("I am in func1")
264
265 - def testLevel2(self):
266 try: 267 self.func2() 268 self.fail() 269 except TypeError, e: 270 self.verifyException(e)
271
272 - def testLevel3(self):
273 try: 274 self.func3() 275 self.fail() 276 except TypeError, e: 277 self.verifyException(e)
278
279 - def verifyException(self, e):
280 message = log.getExceptionMessage(e) 281 self.failUnless("func1()" in message) 282 self.failUnless("test_log.py" in message) 283 self.failUnless("TypeError" in message)
284 285
286 -class TestLogSettings(unittest.TestCase):
287
288 - def testSet(self):
289 old = log.getLogSettings() 290 log.setDebug('*:5') 291 self.assertNotEquals(old, log.getLogSettings()) 292 293 log.setLogSettings(old) 294 self.assertEquals(old, log.getLogSettings())
295 296
297 -class TestWriteMark(unittest.TestCase):
298
299 - def handler(self, level, object, category, file, line, message):
300 self.level = level 301 self.object = object 302 self.category = category 303 self.file = file 304 self.line = line 305 self.message = message
306
307 - def testWriteMarkInDebug(self):
308 loggable = log.Loggable() 309 log.setDebug("4") 310 log.addLogHandler(self.handler) 311 marker = 'test' 312 loggable.writeMarker(marker, log.DEBUG) 313 self.assertEquals(self.message, marker)
314
315 - def testWriteMarkInWarn(self):
316 loggable = log.Loggable() 317 log.setDebug("2") 318 log.addLogHandler(self.handler) 319 marker = 'test' 320 loggable.writeMarker(marker, log.WARN) 321 self.assertEquals(self.message, marker)
322
323 - def testWriteMarkInInfo(self):
324 loggable = log.Loggable() 325 log.setDebug("3") 326 log.addLogHandler(self.handler) 327 marker = 'test' 328 loggable.writeMarker(marker, log.INFO) 329 self.assertEquals(self.message, marker)
330
331 - def testWriteMarkInLog(self):
332 loggable = log.Loggable() 333 log.setDebug("5") 334 log.addLogHandler(self.handler) 335 marker = 'test' 336 loggable.writeMarker(marker, log.LOG) 337 self.assertEquals(self.message, marker)
338
339 - def testWriteMarkInError(self):
340 loggable = log.Loggable() 341 log.setDebug("4") 342 log.addLogHandler(self.handler) 343 marker = 'test' 344 self.assertRaises(SystemExit, loggable.writeMarker, marker, log.ERROR) 345 self.assertEquals(self.message, marker)
346 347
348 -class TestLogNames(unittest.TestCase):
349
350 - def testGetLevelNames(self):
351 self.assertEquals(['ERROR', 'WARN', 'INFO', 'DEBUG', 'LOG'], 352 log.getLevelNames())
353
354 - def testGetLevelCode(self):
355 self.assertEquals(1, log.getLevelInt('ERROR')) 356 self.assertEquals(2, log.getLevelInt('WARN')) 357 self.assertEquals(3, log.getLevelInt('INFO')) 358 self.assertEquals(4, log.getLevelInt('DEBUG')) 359 self.assertEquals(5, log.getLevelInt('LOG'))
360
361 - def testGetLevelName(self):
362 self.assertEquals('ERROR', log.getLevelName(1)) 363 self.assertEquals('WARN', log.getLevelName(2)) 364 self.assertEquals('INFO', log.getLevelName(3)) 365 self.assertEquals('DEBUG', log.getLevelName(4)) 366 self.assertEquals('LOG', log.getLevelName(5))
367 368
369 -class TestLogUnicode(unittest.TestCase):
370
371 - def setUp(self):
372 self.tester = LogTester() 373 # add stderrHandler to fully test unicode handling 374 log.addLogHandler(log.stderrHandler)
375
376 - def testUnicode(self):
377 # Test with a unicode input 378 self.tester.log(u'\xf3')
379
380 - def testUnicodeWithArgs(self):
381 self.tester.log('abc: %s', u'\xf3')
382
383 - def testNonASCIIByteString(self):
384 # Test with a non-ASCII bytestring 385 self.tester.log('\xc3\xa4')
386
388 self.tester.log('abc: %s', '\xc3\xa4')
389
391 # This should fail since were trying to combine 392 # a non-ascii string with a unicode string 393 self.assertRaises(UnicodeDecodeError, 394 self.tester.log, 395 'abc\xf3n%s:', 396 u'a')
397
399 self.tester.log('abc: %s', u'\xc3\xa4')
400 401 402 if __name__ == '__main__': 403 unittest.main() 404