← Back to branch summary

~timo-jyrinki/ubuntu/trusty/pitivi/backport_utopic_fixes

« back to all changes in this revision

Viewing changes to tests/test_log.py

  • Committer: Package Import Robot
  • Author(s): Sebastian Dröge
  • Date: 2014-04-05 15:28:16 UTC
  • mfrom: (6.1.13 sid)
  • Revision ID: package-import@ubuntu.com-20140405152816-6lijoax4cngiz5j5
Tags: 0.93-3
http://bugs.debian.org/732813
http://bugs.debian.org/743692
* debian/control:
  + Depend on python-gi (>= 3.10), older versions do not work
    with pitivi (Closes: #732813).
  + Add missing dependency on gir1.2-clutter-gst-2.0 (Closes: #743692).
  + Add suggests on gir1.2-notify-0.7 and gir1.2-gnomedesktop-3.0.

Show diffs side-by-side

added added

removed removed

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