← 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: 2008-03-16 16:58:03 UTC
  • mfrom: (3224.3.1 news-typo)
  • Revision ID: pqm@pqm.ubuntu.com-20080316165803-tisoc9mpob9z544o
(Matt Nordhoff) Trivial NEWS typo fix

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_trace.py
1
 
# Copyright (C) 2005-2011 Canonical Ltd
 
1
# Copyright (C) 2005, 2006, 2007, 2008 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
17
17
# "weren't nothing promised to you.  do i look like i got a promise face?"
18
18
 
26
26
import tempfile
27
27
 
28
28
from bzrlib import (
29
 
    debug,
30
29
    errors,
31
 
    trace,
32
30
    )
33
 
from bzrlib.tests import features, TestCaseInTempDir, TestCase
 
31
from bzrlib.tests import TestCaseInTempDir, TestCase
34
32
from bzrlib.trace import (
35
33
    mutter, mutter_callsite, report_exception,
36
34
    set_verbosity_level, get_verbosity_level, is_quiet, is_verbose, be_quiet,
37
35
    pop_log_file,
38
36
    push_log_file,
39
37
    _rollover_trace_maybe,
40
 
    show_error,
41
38
    )
42
39
 
43
40
 
51
48
class TestTrace(TestCase):
52
49
 
53
50
    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.
58
51
        try:
59
52
            raise NotImplementedError, "time travel"
60
53
        except NotImplementedError:
63
56
        self.assertEqualDiff(err.splitlines()[0],
64
57
                'bzr: ERROR: exceptions.NotImplementedError: time travel')
65
58
        self.assertContainsRe(err,
66
 
            'Bazaar has encountered an internal error.')
 
59
                r'File.*test_trace.py')
67
60
 
68
61
    def test_format_interrupt_exception(self):
69
62
        try:
75
68
        self.assertTrue(len(msg) > 0)
76
69
        self.assertEqualDiff(msg, 'bzr: interrupted\n')
77
70
 
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
 
 
98
71
    def test_format_os_error(self):
99
72
        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:
110
73
            file('nosuchfile22222')
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
 
        # However it now gets translated so we can not test for a specific message
117
 
        self.assertContainsRe(msg,
118
 
            r'^bzr: ERROR: \[Errno .*\] .*nosuchfile')
119
 
 
120
 
    def test_format_pywintypes_error(self):
121
 
        self.requireFeature(features.pywintypes)
122
 
        import pywintypes, win32file
123
 
        try:
124
 
            win32file.RemoveDirectory('nosuchfile22222')
125
 
        except pywintypes.error:
126
 
            pass
127
 
        msg = _format_exception()
128
 
        # GZ 2010-05-03: Formatting for pywintypes.error is basic, a 3-tuple
129
 
        #                with errno, function name, and locale error message
130
 
        self.assertContainsRe(msg,
131
 
            r"^bzr: ERROR: \(2, 'RemoveDirectory[AW]?', .*\)")
132
 
            
133
 
    def test_format_sockets_error(self):
134
 
        try:
135
 
            import socket
136
 
            sock = socket.socket()
137
 
            sock.send("This should fail.")
138
 
        except socket.error:
139
 
            pass
140
 
        msg = _format_exception()
141
 
        
142
 
        self.assertNotContainsRe(msg,
143
 
            r"Traceback (most recent call last):")
 
74
        except (OSError, IOError):
 
75
            pass
 
76
        msg = _format_exception()
 
77
        self.assertContainsRe(msg, r'^bzr: ERROR: \[Errno .*\] No such file.*nosuchfile')
144
78
 
145
79
    def test_format_unicode_error(self):
146
80
        try:
159
93
        self.assertTrue(len(msg) > 0)
160
94
        self.assertEqualDiff(msg, 'bzr: ERROR: Not a branch: \"wibble\".\n')
161
95
 
162
 
    def test_report_external_import_error(self):
163
 
        """Short friendly message for missing system modules."""
164
 
        try:
165
 
            import ImaginaryModule
166
 
        except ImportError, e:
167
 
            pass
168
 
        else:
169
 
            self.fail("somehow succeeded in importing %r" % ImaginaryModule)
170
 
        msg = _format_exception()
171
 
        self.assertEqual(msg,
172
 
            'bzr: ERROR: No module named ImaginaryModule\n'
173
 
            'You may need to install this Python library separately.\n')
174
 
 
175
 
    def test_report_import_syntax_error(self):
176
 
        try:
177
 
            raise ImportError("syntax error")
178
 
        except ImportError, e:
179
 
            pass
180
 
        msg = _format_exception()
181
 
        self.assertContainsRe(msg,
182
 
            r'Bazaar has encountered an internal error')
183
 
 
184
96
    def test_trace_unicode(self):
185
97
        """Write Unicode to trace log"""
186
98
        self.log(u'the unicode character for benzene is \N{BENZENE RING}')
187
 
        log = self.get_log()
188
 
        self.assertContainsRe(log, "the unicode character for benzene is")
189
 
 
 
99
        self.assertContainsRe(self._get_log(keep_log_file=True),
 
100
                              "the unicode character for benzene is")
 
101
    
190
102
    def test_trace_argument_unicode(self):
191
103
        """Write a Unicode argument to the trace log"""
192
104
        mutter(u'the unicode character for benzene is %s', u'\N{BENZENE RING}')
193
 
        log = self.get_log()
194
 
        self.assertContainsRe(log, 'the unicode character')
 
105
        self.assertContainsRe(self._get_log(keep_log_file=True),
 
106
                              'the unicode character')
195
107
 
196
108
    def test_trace_argument_utf8(self):
197
109
        """Write a Unicode argument to the trace log"""
198
110
        mutter(u'the unicode character for benzene is %s',
199
111
               u'\N{BENZENE RING}'.encode('utf-8'))
200
 
        log = self.get_log()
201
 
        self.assertContainsRe(log, 'the unicode character')
 
112
        self.assertContainsRe(self._get_log(keep_log_file=True),
 
113
                              'the unicode character')
202
114
 
203
115
    def test_report_broken_pipe(self):
204
116
        try:
217
129
    def test_mutter_callsite_1(self):
218
130
        """mutter_callsite can capture 1 level of stack frame."""
219
131
        mutter_callsite(1, "foo %s", "a string")
220
 
        log = self.get_log()
 
132
        log = self._get_log(keep_log_file=True)
221
133
        # begin with the message
222
134
        self.assertLogStartsWith(log, 'foo a string\nCalled from:\n')
223
135
        # should show two frame: this frame and the one above
229
141
    def test_mutter_callsite_2(self):
230
142
        """mutter_callsite can capture 2 levels of stack frame."""
231
143
        mutter_callsite(2, "foo %s", "a string")
232
 
        log = self.get_log()
 
144
        log = self._get_log(keep_log_file=True)
233
145
        # begin with the message
234
146
        self.assertLogStartsWith(log, 'foo a string\nCalled from:\n')
235
147
        # should show two frame: this frame and the one above
241
153
    def test_mutter_never_fails(self):
242
154
        # Even if the decode/encode stage fails, mutter should not
243
155
        # raise an exception
244
 
        # This test checks that mutter doesn't fail; the current behaviour
245
 
        # is that it doesn't fail *and writes non-utf8*.
246
156
        mutter(u'Writing a greek mu (\xb5) works in a unicode string')
247
157
        mutter('But fails in an ascii string \xb5')
248
158
        mutter('and in an ascii argument: %s', '\xb5')
249
 
        log = self.get_log()
 
159
        log = self._get_log(keep_log_file=True)
250
160
        self.assertContainsRe(log, 'Writing a greek mu')
251
161
        self.assertContainsRe(log, "But fails in an ascii string")
252
 
        # However, the log content object does unicode replacement on reading
253
 
        # to let it get unicode back where good data has been written. So we
254
 
        # have to do a replaceent here as well.
255
 
        self.assertContainsRe(log, "ascii argument: \xb5".decode('utf8',
256
 
            'replace'))
257
 
        
258
 
    def test_show_error(self):
259
 
        show_error('error1')
260
 
        show_error(u'error2 \xb5 blah')
261
 
        show_error('arg: %s', 'blah')
262
 
        show_error('arg2: %(key)s', {'key':'stuff'})
263
 
        try:
264
 
            raise Exception("oops")
265
 
        except:
266
 
            show_error('kwarg', exc_info=True)
267
 
        log = self.get_log()
268
 
        self.assertContainsRe(log, 'error1')
269
 
        self.assertContainsRe(log, u'error2 \xb5 blah')
270
 
        self.assertContainsRe(log, 'arg: blah')
271
 
        self.assertContainsRe(log, 'arg2: stuff')
272
 
        self.assertContainsRe(log, 'kwarg')
273
 
        self.assertContainsRe(log, 'Traceback \\(most recent call last\\):')
274
 
        self.assertContainsRe(log, 'File ".*test_trace.py", line .*, in test_show_error')
275
 
        self.assertContainsRe(log, 'raise Exception\\("oops"\\)')
276
 
        self.assertContainsRe(log, 'Exception: oops')
 
162
        self.assertContainsRe(log, u"ascii argument: \xb5")
277
163
 
278
164
    def test_push_log_file(self):
279
165
        """Can push and pop log file, and this catches mutter messages.
280
166
 
281
 
        This is primarily for use in the test framework.
 
167
        This is primarily for use in the test framework. 
282
168
        """
283
169
        tmp1 = tempfile.NamedTemporaryFile()
284
170
        tmp2 = tempfile.NamedTemporaryFile()
308
194
            tmp1.close()
309
195
            tmp2.close()
310
196
 
311
 
    def test__open_bzr_log_uses_stderr_for_failures(self):
312
 
        # If _open_bzr_log cannot open the file, then we should write the
313
 
        # warning to stderr. Since this is normally happening before logging is
314
 
        # set up.
315
 
        self.overrideAttr(sys, 'stderr', StringIO())
316
 
        # Set the log file to something that cannot exist
317
 
        self.overrideEnv('BZR_LOG', os.getcwd() + '/no-dir/bzr.log')
318
 
        self.overrideAttr(trace, '_bzr_log_filename')
319
 
        logf = trace._open_bzr_log()
320
 
        self.assertIs(None, logf)
321
 
        self.assertContainsRe(sys.stderr.getvalue(),
322
 
                              'failed to open trace file: .*/no-dir/bzr.log')
323
 
 
324
197
 
325
198
class TestVerbosityLevel(TestCase):
326
199
 
351
224
    def test_log_rollover(self):
352
225
        temp_log_name = 'test-log'
353
226
        trace_file = open(temp_log_name, 'at')
354
 
        trace_file.writelines(['test_log_rollover padding\n'] * 200000)
 
227
        trace_file.write('test_log_rollover padding\n' * 1000000)
355
228
        trace_file.close()
356
229
        _rollover_trace_maybe(temp_log_name)
357
230
        # should have been rolled over
358
231
        self.assertFalse(os.access(temp_log_name, os.R_OK))
359
 
 
360
 
 
361
 
class TestTraceConfiguration(TestCaseInTempDir):
362
 
 
363
 
    def test_default_config(self):
364
 
        config = trace.DefaultConfig()
365
 
        self.overrideAttr(trace, "_bzr_log_filename", None)
366
 
        trace._bzr_log_filename = None
367
 
        expected_filename = trace._get_bzr_log_filename()
368
 
        self.assertEqual(None, trace._bzr_log_filename)
369
 
        config.__enter__()
370
 
        try:
371
 
            # Should have entered and setup a default filename.
372
 
            self.assertEqual(expected_filename, trace._bzr_log_filename)
373
 
        finally:
374
 
            config.__exit__(None, None, None)
375
 
            # Should have exited and cleaned up.
376
 
            self.assertEqual(None, trace._bzr_log_filename)