Source Code for Module moap.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  from twisted.trial import unittest 
 23   
 24  import log 
 25   
 26  __version__ = "$Rev: 7971 $" 
 27   
 28   
 29 -class LogTester(log.Loggable): 
 30      logCategory = 'testlog' 
 31   
 32   
 33 -class LogFunctionTester(log.Loggable): 
 34   
 35 -    def logFunction(self, format, *args): 
 36          return (("override " + format), ) + args[1:] 
 37   
 38   
 39 -class TestLog(unittest.TestCase): 
 40   
 41 -    def setUp(self): 
 42          self.category = self.level = self.message = None 
 43          self.tester = LogTester() 
 44          # we want to remove the default handler so it doesn't show up stuff 
 45          log.reset() 
 46   
 47      # just test for parsing semi- or non-valid FLU_DEBUG variables 
 48   
 49 -    def testSetDebug(self): 
 50          log.setDebug(":5") 
 51          log.setDebug("*") 
 52          log.setDebug("5") 
 53   
 54 -    def testGetLevelName(self): 
 55          self.assertRaises(AssertionError, log.getLevelName, -1) 
 56          self.assertRaises(AssertionError, log.getLevelName, 6) 
 57   
 58 -    def testGetLevelInt(self): 
 59          self.assertRaises(AssertionError, log.getLevelInt, "NOLEVEL") 
 60   
 61 -    def testGetFormattedLevelName(self): 
 62          self.assertRaises(AssertionError, log.getFormattedLevelName, -1) 
 63          # FIXME: we're poking at internals here, but without calling this 
 64          # no format levels are set at all. 
 65          log._preformatLevels("ENVVAR") 
 66          self.failUnless("LOG" in log.getFormattedLevelName(log.LOG)) 
 67   
 68 -    def testGetFileLine(self): 
 69          # test a function object 
 70          (filename, line) = log.getFileLine(where=self.testGetFileLine) 
 71          self.failUnless(filename.endswith('test_log.py')) 
 72          self.assertEquals(line, 68) 
 73   
 74          # test a lambda 
 75          f = lambda x: x + 1 
 76          (filename, line) = log.getFileLine(where=f) 
 77          self.failUnless(filename.endswith('test_log.py')) 
 78          self.assertEquals(line, 75) 
 79   
 80          # test an eval 
 81          f = eval("lambda x: x + 1") 
 82          (filename, line) = log.getFileLine(where=f) 
 83          self.assertEquals(filename, '<string>') 
 84          self.assertEquals(line, 1) 
 85   
 86      # test for adding a log handler 
 87   
 88 -    def testEllipsize(self): 
 89          self.assertEquals(log.ellipsize("*" * 1000), 
 90              "'" + "*" * 59 + ' ... ' + "*" * 14 + "'") 
 91   
 92 -    def handler(self, level, object, category, file, line, message): 
 93          self.level = level 
 94          self.object = object 
 95          self.category = category 
 96          self.file = file 
 97          self.line = line 
 98          self.message = message 
 99   
100 -    def testLimitInvisible(self): 
101          log.setDebug("testlog:3") 
102          log.addLimitedLogHandler(self.handler) 
103   
104          # log 2 we shouldn't get 
105          self.tester.log("not visible") 
106          assert not self.category 
107          assert not self.level 
108          assert not self.message 
109   
110          self.tester.debug("not visible") 
111          assert not self.category 
112          assert not self.level 
113          assert not self.message 
114   
115 -    def testLimitedVisible(self): 
116          log.setDebug("testlog:3") 
117          log.addLimitedLogHandler(self.handler) 
118   
119          # log 3 we should get 
120          self.tester.info("visible") 
121          assert self.category == 'testlog' 
122          assert self.level == log.INFO 
123          assert self.message == 'visible' 
124   
125          self.tester.warning("also visible") 
126          assert self.category == 'testlog' 
127          assert self.level == log.WARN 
128          assert self.message == 'also visible' 
129   
130 -    def testFormatStrings(self): 
131          log.setDebug("testlog:3") 
132          log.addLimitedLogHandler(self.handler) 
133   
134          self.tester.info("%d %s", 42, 'the answer') 
135          assert self.category == 'testlog' 
136          assert self.level == log.INFO 
137          assert self.message == '42 the answer' 
138   
139 -    def testLimitedError(self): 
140          log.setDebug("testlog:3") 
141          log.addLimitedLogHandler(self.handler) 
142   
143          self.assertRaises(SystemExit, self.tester.error, "error") 
144          assert self.category == 'testlog' 
145          assert self.level == log.ERROR 
146          assert self.message == 'error' 
147   
148 -    def testLogHandlerLimitedLevels(self): 
149          log.setDebug("testlog:3") 
150          log.addLimitedLogHandler(self.handler) 
151   
152          # now try debug and log again too 
153          log.setDebug("testlog:5") 
154   
155          self.tester.debug("debug") 
156          assert self.category == 'testlog' 
157          assert self.level == log.DEBUG 
158          assert self.message == 'debug' 
159   
160          self.tester.log("log") 
161          assert self.category == 'testlog' 
162          assert self.level == log.LOG 
163          assert self.message == 'log' 
164   
165      # test that we get all log messages 
166   
167 -    def testLogHandler(self): 
168          log.setDebug("testlog:3") 
169          log.addLogHandler(self.handler) 
170   
171          self.tester.log("visible") 
172          assert self.message == 'visible' 
173   
174          self.tester.warning("also visible") 
175          assert self.message == 'also visible' 
176   
177 -    def testAddLogHandlerRaises(self): 
178          self.assertRaises(TypeError, log.addLogHandler, 1) 
179   
180   
181 -class TestOwnLogHandler(unittest.TestCase): 
182   
183 -    def setUp(self): 
184          self.category = self.level = self.message = None 
185          self.tester = LogFunctionTester() 
186   
187 -    def handler(self, level, object, category, file, line, message): 
188          self.level = level 
189          self.object = object 
190          self.category = category 
191          self.file = file 
192          self.line = line 
193          self.message = message 
194   
195      # test if our own log handler correctly mangles the message 
196   
197 -    def testOwnLogHandlerLimited(self): 
198          log.setDebug("testlog:3") 
199          log.addLogHandler(self.handler) 
200   
201          self.tester.log("visible") 
202          assert self.message == 'override visible' 
203   
204 -    def testLogHandlerAssertion(self): 
205          self.assertRaises(TypeError, log.addLimitedLogHandler, None) 
206   
207   
208 -class TestGetExceptionMessage(unittest.TestCase): 
209   
210 -    def func3(self): 
211          self.func2() 
212   
213 -    def func2(self): 
214          self.func1() 
215   
216 -    def func1(self): 
217          raise TypeError("I am in func1") 
218   
219 -    def testLevel2(self): 
220          try: 
221              self.func2() 
222              self.fail() 
223          except TypeError, e: 
224              self.verifyException(e) 
225   
226 -    def testLevel3(self): 
227          try: 
228              self.func3() 
229              self.fail() 
230          except TypeError, e: 
231              self.verifyException(e) 
232   
233 -    def verifyException(self, e): 
234          message = log.getExceptionMessage(e) 
235          self.failUnless("func1()" in message) 
236          self.failUnless("test_log.py" in message) 
237          self.failUnless("TypeError" in message) 
238   
239   
240 -class TestLogSettings(unittest.TestCase): 
241   
242 -    def testSet(self): 
243          old = log.getLogSettings() 
244          log.setDebug('*:5') 
245          self.assertNotEquals(old, log.getLogSettings()) 
246   
247          log.setLogSettings(old) 
248          self.assertEquals(old, log.getLogSettings()) 
249   
250   
251 -class TestWriteMark(unittest.TestCase): 
252   
253 -    def handler(self, level, object, category, file, line, message): 
254          self.level = level 
255          self.object = object 
256          self.category = category 
257          self.file = file 
258          self.line = line 
259          self.message = message 
260   
261 -    def testWriteMarkInDebug(self): 
262          loggable = log.Loggable() 
263          log.setDebug("4") 
264          log.addLogHandler(self.handler) 
265          marker = 'test' 
266          loggable.writeMarker(marker, log.DEBUG) 
267          self.assertEquals(self.message, marker) 
268   
269 -    def testWriteMarkInWarn(self): 
270          loggable = log.Loggable() 
271          log.setDebug("2") 
272          log.addLogHandler(self.handler) 
273          marker = 'test' 
274          loggable.writeMarker(marker, log.WARN) 
275          self.assertEquals(self.message, marker) 
276   
277 -    def testWriteMarkInInfo(self): 
278          loggable = log.Loggable() 
279          log.setDebug("3") 
280          log.addLogHandler(self.handler) 
281          marker = 'test' 
282          loggable.writeMarker(marker, log.INFO) 
283          self.assertEquals(self.message, marker) 
284   
285 -    def testWriteMarkInLog(self): 
286          loggable = log.Loggable() 
287          log.setDebug("5") 
288          log.addLogHandler(self.handler) 
289          marker = 'test' 
290          loggable.writeMarker(marker, log.LOG) 
291          self.assertEquals(self.message, marker) 
292   
293 -    def testWriteMarkInError(self): 
294          loggable = log.Loggable() 
295          log.setDebug("4") 
296          log.addLogHandler(self.handler) 
297          marker = 'test' 
298          self.assertRaises(SystemExit, loggable.writeMarker, marker, log.ERROR) 
299          self.assertEquals(self.message, marker) 
300   
301   
302 -class TestLogNames(unittest.TestCase): 
303   
304 -    def testGetLevelNames(self): 
305          self.assertEquals(['ERROR', 'WARN', 'INFO', 'DEBUG', 'LOG'], 
306                            log.getLevelNames()) 
307   
308 -    def testGetLevelCode(self): 
309          self.assertEquals(1, log.getLevelInt('ERROR')) 
310          self.assertEquals(2, log.getLevelInt('WARN')) 
311          self.assertEquals(3, log.getLevelInt('INFO')) 
312          self.assertEquals(4, log.getLevelInt('DEBUG')) 
313          self.assertEquals(5, log.getLevelInt('LOG')) 
314   
315 -    def testGetLevelName(self): 
316          self.assertEquals('ERROR', log.getLevelName(1)) 
317          self.assertEquals('WARN', log.getLevelName(2)) 
318          self.assertEquals('INFO', log.getLevelName(3)) 
319          self.assertEquals('DEBUG', log.getLevelName(4)) 
320          self.assertEquals('LOG', log.getLevelName(5)) 
321   
322  if __name__ == '__main__': 
323      unittest.main() 
324