← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_trace.py

  • Committer: Jelmer Vernooij
  • Date: 2011-08-19 22:34:02 UTC
  • mto: This revision was merged to the branch mainline in revision 6089.
  • Revision ID: jelmer@samba.org-20110819223402-wjywqb0fa1xxx522
Use get_transport_from_{url,path} in more places.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_trace.py
1
 
# Copyright (C) 2005, 2006 Canonical Ltd
 
1
# Copyright (C) 2005-2011 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
12
12
#
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
17
# "weren't nothing promised to you.  do i look like i got a promise face?"
18
18
 
21
21
from cStringIO import StringIO
22
22
import errno
23
23
import os
 
24
import re
24
25
import sys
 
26
import tempfile
25
27
 
26
28
from bzrlib import (
 
29
    debug,
27
30
    errors,
28
 
    )
29
 
from bzrlib.tests import TestCaseInTempDir, TestCase
30
 
from bzrlib.trace import mutter, report_exception
 
31
    trace,
 
32
    )
 
33
from bzrlib.tests import features, TestCaseInTempDir, TestCase
 
34
from bzrlib.trace import (
 
35
    mutter, mutter_callsite, report_exception,
 
36
    set_verbosity_level, get_verbosity_level, is_quiet, is_verbose, be_quiet,
 
37
    pop_log_file,
 
38
    push_log_file,
 
39
    _rollover_trace_maybe,
 
40
    show_error,
 
41
    )
31
42
 
32
43
 
33
44
def _format_exception():
40
51
class TestTrace(TestCase):
41
52
 
42
53
    def test_format_sys_exception(self):
 
54
        # Test handling of an internal/unexpected error that probably
 
55
        # indicates a bug in bzr.  The details of the message may vary
 
56
        # depending on whether apport is available or not.  See test_crash for
 
57
        # more.
43
58
        try:
44
59
            raise NotImplementedError, "time travel"
45
60
        except NotImplementedError:
48
63
        self.assertEqualDiff(err.splitlines()[0],
49
64
                'bzr: ERROR: exceptions.NotImplementedError: time travel')
50
65
        self.assertContainsRe(err,
51
 
                r'File.*test_trace.py')
 
66
            'Bazaar has encountered an internal error.')
52
67
 
53
68
    def test_format_interrupt_exception(self):
54
69
        try:
60
75
        self.assertTrue(len(msg) > 0)
61
76
        self.assertEqualDiff(msg, 'bzr: interrupted\n')
62
77
 
 
78
    def test_format_memory_error(self):
 
79
        try:
 
80
            raise MemoryError()
 
81
        except MemoryError:
 
82
            pass
 
83
        msg = _format_exception()
 
84
        self.assertEquals(msg,
 
85
            "bzr: out of memory\nUse -Dmem_dump to dump memory to a file.\n")
 
86
 
 
87
    def test_format_mem_dump(self):
 
88
        self.requireFeature(features.meliae)
 
89
        debug.debug_flags.add('mem_dump')
 
90
        try:
 
91
            raise MemoryError()
 
92
        except MemoryError:
 
93
            pass
 
94
        msg = _format_exception()
 
95
        self.assertStartsWith(msg,
 
96
            "bzr: out of memory\nMemory dumped to ")
 
97
 
63
98
    def test_format_os_error(self):
64
99
        try:
 
100
            os.rmdir('nosuchfile22222')
 
101
        except OSError, e:
 
102
            e_str = str(e)
 
103
        msg = _format_exception()
 
104
        # Linux seems to give "No such file" but Windows gives "The system
 
105
        # cannot find the file specified".
 
106
        self.assertEqual('bzr: ERROR: %s\n' % (e_str,), msg)
 
107
 
 
108
    def test_format_io_error(self):
 
109
        try:
65
110
            file('nosuchfile22222')
66
 
        except (OSError, IOError):
67
 
            pass
68
 
        msg = _format_exception()
69
 
        self.assertContainsRe(msg, r'^bzr: ERROR: \[Errno .*\] No such file.*nosuchfile')
 
111
        except IOError:
 
112
            pass
 
113
        msg = _format_exception()
 
114
        # Even though Windows and Linux differ for 'os.rmdir', they both give
 
115
        # 'No such file' for open()
 
116
        self.assertContainsRe(msg,
 
117
            r'^bzr: ERROR: \[Errno .*\] No such file.*nosuchfile')
 
118
 
 
119
    def test_format_pywintypes_error(self):
 
120
        self.requireFeature(features.pywintypes)
 
121
        import pywintypes, win32file
 
122
        try:
 
123
            win32file.RemoveDirectory('nosuchfile22222')
 
124
        except pywintypes.error:
 
125
            pass
 
126
        msg = _format_exception()
 
127
        # GZ 2010-05-03: Formatting for pywintypes.error is basic, a 3-tuple
 
128
        #                with errno, function name, and locale error message
 
129
        self.assertContainsRe(msg,
 
130
            r"^bzr: ERROR: \(2, 'RemoveDirectory[AW]?', .*\)")
 
131
            
 
132
    def test_format_sockets_error(self):
 
133
        try:
 
134
            import socket
 
135
            sock = socket.socket()
 
136
            sock.send("This should fail.")
 
137
        except socket.error:
 
138
            pass
 
139
        msg = _format_exception()
 
140
        
 
141
        self.assertNotContainsRe(msg,
 
142
            r"Traceback (most recent call last):")
70
143
 
71
144
    def test_format_unicode_error(self):
72
145
        try:
83
156
            pass
84
157
        msg = _format_exception()
85
158
        self.assertTrue(len(msg) > 0)
86
 
        self.assertEqualDiff(msg, 'bzr: ERROR: Not a branch: wibble\n')
 
159
        self.assertEqualDiff(msg, 'bzr: ERROR: Not a branch: \"wibble\".\n')
 
160
 
 
161
    def test_report_external_import_error(self):
 
162
        """Short friendly message for missing system modules."""
 
163
        try:
 
164
            import ImaginaryModule
 
165
        except ImportError, e:
 
166
            pass
 
167
        else:
 
168
            self.fail("somehow succeeded in importing %r" % ImaginaryModule)
 
169
        msg = _format_exception()
 
170
        self.assertEqual(msg,
 
171
            'bzr: ERROR: No module named ImaginaryModule\n'
 
172
            'You may need to install this Python library separately.\n')
 
173
 
 
174
    def test_report_import_syntax_error(self):
 
175
        try:
 
176
            raise ImportError("syntax error")
 
177
        except ImportError, e:
 
178
            pass
 
179
        msg = _format_exception()
 
180
        self.assertContainsRe(msg,
 
181
            r'Bazaar has encountered an internal error')
87
182
 
88
183
    def test_trace_unicode(self):
89
184
        """Write Unicode to trace log"""
90
185
        self.log(u'the unicode character for benzene is \N{BENZENE RING}')
91
 
        self.assertContainsRe(self._get_log(keep_log_file=True),
92
 
                              "the unicode character for benzene is")
93
 
    
 
186
        log = self.get_log()
 
187
        self.assertContainsRe(log, "the unicode character for benzene is")
 
188
 
94
189
    def test_trace_argument_unicode(self):
95
190
        """Write a Unicode argument to the trace log"""
96
191
        mutter(u'the unicode character for benzene is %s', u'\N{BENZENE RING}')
97
 
        self.assertContainsRe(self._get_log(keep_log_file=True),
98
 
                              'the unicode character')
 
192
        log = self.get_log()
 
193
        self.assertContainsRe(log, 'the unicode character')
99
194
 
100
195
    def test_trace_argument_utf8(self):
101
196
        """Write a Unicode argument to the trace log"""
102
197
        mutter(u'the unicode character for benzene is %s',
103
198
               u'\N{BENZENE RING}'.encode('utf-8'))
104
 
        self.assertContainsRe(self._get_log(keep_log_file=True),
105
 
                              'the unicode character')
 
199
        log = self.get_log()
 
200
        self.assertContainsRe(log, 'the unicode character')
106
201
 
107
202
    def test_report_broken_pipe(self):
108
203
        try:
113
208
        else:
114
209
            self.fail("expected error not raised")
115
210
 
 
211
    def assertLogStartsWith(self, log, string):
 
212
        """Like assertStartsWith, but skips the log timestamp."""
 
213
        self.assertContainsRe(log,
 
214
            '^\\d+\\.\\d+  ' + re.escape(string))
 
215
 
 
216
    def test_mutter_callsite_1(self):
 
217
        """mutter_callsite can capture 1 level of stack frame."""
 
218
        mutter_callsite(1, "foo %s", "a string")
 
219
        log = self.get_log()
 
220
        # begin with the message
 
221
        self.assertLogStartsWith(log, 'foo a string\nCalled from:\n')
 
222
        # should show two frame: this frame and the one above
 
223
        self.assertContainsRe(log,
 
224
            'test_trace\\.py", line \\d+, in test_mutter_callsite_1\n')
 
225
        # this frame should be the final one
 
226
        self.assertEndsWith(log, ' "a string")\n')
 
227
 
 
228
    def test_mutter_callsite_2(self):
 
229
        """mutter_callsite can capture 2 levels of stack frame."""
 
230
        mutter_callsite(2, "foo %s", "a string")
 
231
        log = self.get_log()
 
232
        # begin with the message
 
233
        self.assertLogStartsWith(log, 'foo a string\nCalled from:\n')
 
234
        # should show two frame: this frame and the one above
 
235
        self.assertContainsRe(log,
 
236
            'test_trace.py", line \d+, in test_mutter_callsite_2\n')
 
237
        # this frame should be the final one
 
238
        self.assertEndsWith(log, ' "a string")\n')
 
239
 
116
240
    def test_mutter_never_fails(self):
117
241
        # Even if the decode/encode stage fails, mutter should not
118
242
        # raise an exception
 
243
        # This test checks that mutter doesn't fail; the current behaviour
 
244
        # is that it doesn't fail *and writes non-utf8*.
119
245
        mutter(u'Writing a greek mu (\xb5) works in a unicode string')
120
246
        mutter('But fails in an ascii string \xb5')
121
247
        mutter('and in an ascii argument: %s', '\xb5')
122
 
        log = self._get_log(keep_log_file=True)
 
248
        log = self.get_log()
123
249
        self.assertContainsRe(log, 'Writing a greek mu')
124
250
        self.assertContainsRe(log, "But fails in an ascii string")
125
 
        self.assertContainsRe(log, u"ascii argument: \xb5")
 
251
        # However, the log content object does unicode replacement on reading
 
252
        # to let it get unicode back where good data has been written. So we
 
253
        # have to do a replaceent here as well.
 
254
        self.assertContainsRe(log, "ascii argument: \xb5".decode('utf8',
 
255
            'replace'))
 
256
        
 
257
    def test_show_error(self):
 
258
        show_error('error1')
 
259
        show_error(u'error2 \xb5 blah')
 
260
        show_error('arg: %s', 'blah')
 
261
        show_error('arg2: %(key)s', {'key':'stuff'})
 
262
        try:
 
263
            raise Exception("oops")
 
264
        except:
 
265
            show_error('kwarg', exc_info=True)
 
266
        log = self.get_log()
 
267
        self.assertContainsRe(log, 'error1')
 
268
        self.assertContainsRe(log, u'error2 \xb5 blah')
 
269
        self.assertContainsRe(log, 'arg: blah')
 
270
        self.assertContainsRe(log, 'arg2: stuff')
 
271
        self.assertContainsRe(log, 'kwarg')
 
272
        self.assertContainsRe(log, 'Traceback \\(most recent call last\\):')
 
273
        self.assertContainsRe(log, 'File ".*test_trace.py", line .*, in test_show_error')
 
274
        self.assertContainsRe(log, 'raise Exception\\("oops"\\)')
 
275
        self.assertContainsRe(log, 'Exception: oops')
 
276
 
 
277
    def test_push_log_file(self):
 
278
        """Can push and pop log file, and this catches mutter messages.
 
279
 
 
280
        This is primarily for use in the test framework.
 
281
        """
 
282
        tmp1 = tempfile.NamedTemporaryFile()
 
283
        tmp2 = tempfile.NamedTemporaryFile()
 
284
        try:
 
285
            memento1 = push_log_file(tmp1)
 
286
            mutter("comment to file1")
 
287
            try:
 
288
                memento2 = push_log_file(tmp2)
 
289
                try:
 
290
                    mutter("comment to file2")
 
291
                finally:
 
292
                    pop_log_file(memento2)
 
293
                mutter("again to file1")
 
294
            finally:
 
295
                pop_log_file(memento1)
 
296
            # the files were opened in binary mode, so should have exactly
 
297
            # these bytes.  and removing the file as the log target should
 
298
            # have caused them to be flushed out.  need to match using regexps
 
299
            # as there's a timestamp at the front.
 
300
            tmp1.seek(0)
 
301
            self.assertContainsRe(tmp1.read(),
 
302
                r"\d+\.\d+  comment to file1\n\d+\.\d+  again to file1\n")
 
303
            tmp2.seek(0)
 
304
            self.assertContainsRe(tmp2.read(),
 
305
                r"\d+\.\d+  comment to file2\n")
 
306
        finally:
 
307
            tmp1.close()
 
308
            tmp2.close()
 
309
 
 
310
    def test__open_bzr_log_uses_stderr_for_failures(self):
 
311
        # If _open_bzr_log cannot open the file, then we should write the
 
312
        # warning to stderr. Since this is normally happening before logging is
 
313
        # set up.
 
314
        self.overrideAttr(sys, 'stderr', StringIO())
 
315
        # Set the log file to something that cannot exist
 
316
        self.overrideEnv('BZR_LOG', os.getcwd() + '/no-dir/bzr.log')
 
317
        self.overrideAttr(trace, '_bzr_log_filename')
 
318
        logf = trace._open_bzr_log()
 
319
        self.assertIs(None, logf)
 
320
        self.assertContainsRe(sys.stderr.getvalue(),
 
321
                              'failed to open trace file: .*/no-dir/bzr.log')
 
322
 
 
323
 
 
324
class TestVerbosityLevel(TestCase):
 
325
 
 
326
    def test_verbosity_level(self):
 
327
        set_verbosity_level(1)
 
328
        self.assertEqual(1, get_verbosity_level())
 
329
        self.assertTrue(is_verbose())
 
330
        self.assertFalse(is_quiet())
 
331
        set_verbosity_level(-1)
 
332
        self.assertEqual(-1, get_verbosity_level())
 
333
        self.assertFalse(is_verbose())
 
334
        self.assertTrue(is_quiet())
 
335
        set_verbosity_level(0)
 
336
        self.assertEqual(0, get_verbosity_level())
 
337
        self.assertFalse(is_verbose())
 
338
        self.assertFalse(is_quiet())
 
339
 
 
340
    def test_be_quiet(self):
 
341
        # Confirm the old API still works
 
342
        be_quiet(True)
 
343
        self.assertEqual(-1, get_verbosity_level())
 
344
        be_quiet(False)
 
345
        self.assertEqual(0, get_verbosity_level())
 
346
 
 
347
 
 
348
class TestBzrLog(TestCaseInTempDir):
 
349
 
 
350
    def test_log_rollover(self):
 
351
        temp_log_name = 'test-log'
 
352
        trace_file = open(temp_log_name, 'at')
 
353
        trace_file.writelines(['test_log_rollover padding\n'] * 200000)
 
354
        trace_file.close()
 
355
        _rollover_trace_maybe(temp_log_name)
 
356
        # should have been rolled over
 
357
        self.assertFalse(os.access(temp_log_name, os.R_OK))
 
358
 
 
359
 
 
360
class TestTraceConfiguration(TestCaseInTempDir):
 
361
 
 
362
    def test_default_config(self):
 
363
        config = trace.DefaultConfig()
 
364
        self.overrideAttr(trace, "_bzr_log_filename", None)
 
365
        trace._bzr_log_filename = None
 
366
        expected_filename = trace._get_bzr_log_filename()
 
367
        self.assertEqual(None, trace._bzr_log_filename)
 
368
        config.__enter__()
 
369
        try:
 
370
            # Should have entered and setup a default filename.
 
371
            self.assertEqual(expected_filename, trace._bzr_log_filename)
 
372
        finally:
 
373
            config.__exit__(None, None, None)
 
374
            # Should have exited and cleaned up.
 
375
            self.assertEqual(None, trace._bzr_log_filename)