← 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: Canonical.com Patch Queue Manager
  • Date: 2010-10-18 11:57:18 UTC
  • mfrom: (5505.1.1 trunk)
  • Revision ID: pqm@pqm.ubuntu.com-20101018115718-cbuoc2gafnjldngk
(vila) Document hunk editing when shelving.(Neil Martinsen-Burrell)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_trace.py
1
 
# Copyright (C) 2005, 2006 by Canonical Ltd
 
1
# Copyright (C) 2005-2010 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]?', .*\)")
70
131
 
71
132
    def test_format_unicode_error(self):
72
133
        try:
78
139
    def test_format_exception(self):
79
140
        """Short formatting of bzr exceptions"""
80
141
        try:
81
 
            raise errors.NotBranchError, 'wibble'
 
142
            raise errors.NotBranchError('wibble')
82
143
        except errors.NotBranchError:
83
144
            pass
84
145
        msg = _format_exception()
85
146
        self.assertTrue(len(msg) > 0)
86
 
        self.assertEqualDiff(msg, 'bzr: ERROR: Not a branch: wibble\n')
 
147
        self.assertEqualDiff(msg, 'bzr: ERROR: Not a branch: \"wibble\".\n')
 
148
 
 
149
    def test_report_external_import_error(self):
 
150
        """Short friendly message for missing system modules."""
 
151
        try:
 
152
            import ImaginaryModule
 
153
        except ImportError, e:
 
154
            pass
 
155
        else:
 
156
            self.fail("somehow succeeded in importing %r" % ImaginaryModule)
 
157
        msg = _format_exception()
 
158
        self.assertEqual(msg,
 
159
            'bzr: ERROR: No module named ImaginaryModule\n'
 
160
            'You may need to install this Python library separately.\n')
 
161
 
 
162
    def test_report_import_syntax_error(self):
 
163
        try:
 
164
            raise ImportError("syntax error")
 
165
        except ImportError, e:
 
166
            pass
 
167
        msg = _format_exception()
 
168
        self.assertContainsRe(msg,
 
169
            r'Bazaar has encountered an internal error')
87
170
 
88
171
    def test_trace_unicode(self):
89
172
        """Write Unicode to trace log"""
90
 
        mutter(u'the unicode character for benzene is \N{BENZENE RING}')
91
 
        self._log_file.flush()
92
 
        self.assertContainsRe(self._get_log(), 'the unicode character',)
93
 
    
 
173
        self.log(u'the unicode character for benzene is \N{BENZENE RING}')
 
174
        log = self.get_log()
 
175
        self.assertContainsRe(log, "the unicode character for benzene is")
 
176
 
94
177
    def test_trace_argument_unicode(self):
95
178
        """Write a Unicode argument to the trace log"""
96
179
        mutter(u'the unicode character for benzene is %s', u'\N{BENZENE RING}')
97
 
        self._log_file.flush()
98
 
        self.assertContainsRe(self._get_log(), 'the unicode character')
 
180
        log = self.get_log()
 
181
        self.assertContainsRe(log, 'the unicode character')
99
182
 
100
183
    def test_trace_argument_utf8(self):
101
184
        """Write a Unicode argument to the trace log"""
102
185
        mutter(u'the unicode character for benzene is %s',
103
186
               u'\N{BENZENE RING}'.encode('utf-8'))
104
 
        self._log_file.flush()
105
 
        self.assertContainsRe(self._get_log(), 'the unicode character')
 
187
        log = self.get_log()
 
188
        self.assertContainsRe(log, 'the unicode character')
106
189
 
107
190
    def test_report_broken_pipe(self):
108
191
        try:
113
196
        else:
114
197
            self.fail("expected error not raised")
115
198
 
 
199
    def assertLogStartsWith(self, log, string):
 
200
        """Like assertStartsWith, but skips the log timestamp."""
 
201
        self.assertContainsRe(log,
 
202
            '^\\d+\\.\\d+  ' + re.escape(string))
 
203
 
 
204
    def test_mutter_callsite_1(self):
 
205
        """mutter_callsite can capture 1 level of stack frame."""
 
206
        mutter_callsite(1, "foo %s", "a string")
 
207
        log = self.get_log()
 
208
        # begin with the message
 
209
        self.assertLogStartsWith(log, 'foo a string\nCalled from:\n')
 
210
        # should show two frame: this frame and the one above
 
211
        self.assertContainsRe(log,
 
212
            'test_trace\\.py", line \\d+, in test_mutter_callsite_1\n')
 
213
        # this frame should be the final one
 
214
        self.assertEndsWith(log, ' "a string")\n')
 
215
 
 
216
    def test_mutter_callsite_2(self):
 
217
        """mutter_callsite can capture 2 levels of stack frame."""
 
218
        mutter_callsite(2, "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_2\n')
 
225
        # this frame should be the final one
 
226
        self.assertEndsWith(log, ' "a string")\n')
 
227
 
116
228
    def test_mutter_never_fails(self):
117
229
        # Even if the decode/encode stage fails, mutter should not
118
230
        # raise an exception
 
231
        # This test checks that mutter doesn't fail; the current behaviour
 
232
        # is that it doesn't fail *and writes non-utf8*.
119
233
        mutter(u'Writing a greek mu (\xb5) works in a unicode string')
120
234
        mutter('But fails in an ascii string \xb5')
121
235
        mutter('and in an ascii argument: %s', '\xb5')
122
 
        # TODO: jam 20051227 mutter() doesn't flush the log file, and
123
 
        #       self._get_log() opens the file directly and reads it.
124
 
        #       So we need to manually flush the log file
125
 
        self._log_file.flush()
126
 
        log = self._get_log()
 
236
        log = self.get_log()
127
237
        self.assertContainsRe(log, 'Writing a greek mu')
128
238
        self.assertContainsRe(log, "But fails in an ascii string")
129
 
        self.assertContainsRe(log, u"ascii argument: \xb5")
 
239
        # However, the log content object does unicode replacement on reading
 
240
        # to let it get unicode back where good data has been written. So we
 
241
        # have to do a replaceent here as well.
 
242
        self.assertContainsRe(log, "ascii argument: \xb5".decode('utf8',
 
243
            'replace'))
 
244
        
 
245
    def test_show_error(self):
 
246
        show_error('error1')
 
247
        show_error(u'error2 \xb5 blah')
 
248
        show_error('arg: %s', 'blah')
 
249
        show_error('arg2: %(key)s', {'key':'stuff'})
 
250
        try:
 
251
            raise Exception("oops")
 
252
        except:
 
253
            show_error('kwarg', exc_info=True)
 
254
        log = self.get_log()
 
255
        self.assertContainsRe(log, 'error1')
 
256
        self.assertContainsRe(log, u'error2 \xb5 blah')
 
257
        self.assertContainsRe(log, 'arg: blah')
 
258
        self.assertContainsRe(log, 'arg2: stuff')
 
259
        self.assertContainsRe(log, 'kwarg')
 
260
        self.assertContainsRe(log, 'Traceback \\(most recent call last\\):')
 
261
        self.assertContainsRe(log, 'File ".*test_trace.py", line .*, in test_show_error')
 
262
        self.assertContainsRe(log, 'raise Exception\\("oops"\\)')
 
263
        self.assertContainsRe(log, 'Exception: oops')
 
264
 
 
265
    def test_push_log_file(self):
 
266
        """Can push and pop log file, and this catches mutter messages.
 
267
 
 
268
        This is primarily for use in the test framework.
 
269
        """
 
270
        tmp1 = tempfile.NamedTemporaryFile()
 
271
        tmp2 = tempfile.NamedTemporaryFile()
 
272
        try:
 
273
            memento1 = push_log_file(tmp1)
 
274
            mutter("comment to file1")
 
275
            try:
 
276
                memento2 = push_log_file(tmp2)
 
277
                try:
 
278
                    mutter("comment to file2")
 
279
                finally:
 
280
                    pop_log_file(memento2)
 
281
                mutter("again to file1")
 
282
            finally:
 
283
                pop_log_file(memento1)
 
284
            # the files were opened in binary mode, so should have exactly
 
285
            # these bytes.  and removing the file as the log target should
 
286
            # have caused them to be flushed out.  need to match using regexps
 
287
            # as there's a timestamp at the front.
 
288
            tmp1.seek(0)
 
289
            self.assertContainsRe(tmp1.read(),
 
290
                r"\d+\.\d+  comment to file1\n\d+\.\d+  again to file1\n")
 
291
            tmp2.seek(0)
 
292
            self.assertContainsRe(tmp2.read(),
 
293
                r"\d+\.\d+  comment to file2\n")
 
294
        finally:
 
295
            tmp1.close()
 
296
            tmp2.close()
 
297
 
 
298
    def test__open_bzr_log_uses_stderr_for_failures(self):
 
299
        # If _open_bzr_log cannot open the file, then we should write the
 
300
        # warning to stderr. Since this is normally happening before logging is
 
301
        # set up.
 
302
        self.overrideAttr(sys, 'stderr', StringIO())
 
303
        # Set the log file to something that cannot exist
 
304
        # FIXME: A bit dangerous: we are not in an isolated dir here -- vilajam
 
305
        # 20100125
 
306
        os.environ['BZR_LOG'] = os.getcwd() + '/no-dir/bzr.log'
 
307
        self.overrideAttr(trace, '_bzr_log_filename')
 
308
        logf = trace._open_bzr_log()
 
309
        self.assertIs(None, logf)
 
310
        self.assertContainsRe(sys.stderr.getvalue(),
 
311
                              'failed to open trace file: .*/no-dir/bzr.log')
 
312
 
 
313
 
 
314
class TestVerbosityLevel(TestCase):
 
315
 
 
316
    def test_verbosity_level(self):
 
317
        set_verbosity_level(1)
 
318
        self.assertEqual(1, get_verbosity_level())
 
319
        self.assertTrue(is_verbose())
 
320
        self.assertFalse(is_quiet())
 
321
        set_verbosity_level(-1)
 
322
        self.assertEqual(-1, get_verbosity_level())
 
323
        self.assertFalse(is_verbose())
 
324
        self.assertTrue(is_quiet())
 
325
        set_verbosity_level(0)
 
326
        self.assertEqual(0, get_verbosity_level())
 
327
        self.assertFalse(is_verbose())
 
328
        self.assertFalse(is_quiet())
 
329
 
 
330
    def test_be_quiet(self):
 
331
        # Confirm the old API still works
 
332
        be_quiet(True)
 
333
        self.assertEqual(-1, get_verbosity_level())
 
334
        be_quiet(False)
 
335
        self.assertEqual(0, get_verbosity_level())
 
336
 
 
337
 
 
338
class TestBzrLog(TestCaseInTempDir):
 
339
 
 
340
    def test_log_rollover(self):
 
341
        temp_log_name = 'test-log'
 
342
        trace_file = open(temp_log_name, 'at')
 
343
        trace_file.writelines(['test_log_rollover padding\n'] * 200000)
 
344
        trace_file.close()
 
345
        _rollover_trace_maybe(temp_log_name)
 
346
        # should have been rolled over
 
347
        self.assertFalse(os.access(temp_log_name, os.R_OK))
 
348
 
 
349
 
 
350
class TestTraceConfiguration(TestCaseInTempDir):
 
351
 
 
352
    def test_default_config(self):
 
353
        config = trace.DefaultConfig()
 
354
        self.overrideAttr(trace, "_bzr_log_filename", None)
 
355
        trace._bzr_log_filename = None
 
356
        expected_filename = trace._get_bzr_log_filename()
 
357
        self.assertEqual(None, trace._bzr_log_filename)
 
358
        config.__enter__()
 
359
        try:
 
360
            # Should have entered and setup a default filename.
 
361
            self.assertEqual(expected_filename, trace._bzr_log_filename)
 
362
        finally:
 
363
            config.__exit__(None, None, None)
 
364
            # Should have exited and cleaned up.
 
365
            self.assertEqual(None, trace._bzr_log_filename)