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