← 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-03-11 13:47:06 UTC
  • mfrom: (5051.3.16 use-branch-open)
  • Revision ID: pqm@pqm.ubuntu.com-20100311134706-kaerqhx3lf7xn6rh
(Jelmer) Pass colocated branch names further down the call stack.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_trace.py
1
 
# Copyright (C) 2005, 2006, 2007, 2008 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
 
27
27
 
28
28
from bzrlib import (
29
29
    errors,
 
30
    trace,
30
31
    )
31
32
from bzrlib.tests import TestCaseInTempDir, TestCase
32
33
from bzrlib.trace import (
35
36
    pop_log_file,
36
37
    push_log_file,
37
38
    _rollover_trace_maybe,
 
39
    show_error,
38
40
    )
39
41
 
40
42
 
48
50
class TestTrace(TestCase):
49
51
 
50
52
    def test_format_sys_exception(self):
 
53
        # Test handling of an internal/unexpected error that probably
 
54
        # indicates a bug in bzr.  The details of the message may vary
 
55
        # depending on whether apport is available or not.  See test_crash for
 
56
        # more.
51
57
        try:
52
58
            raise NotImplementedError, "time travel"
53
59
        except NotImplementedError:
56
62
        self.assertEqualDiff(err.splitlines()[0],
57
63
                'bzr: ERROR: exceptions.NotImplementedError: time travel')
58
64
        self.assertContainsRe(err,
59
 
                r'File.*test_trace.py')
 
65
            'Bazaar has encountered an internal error.')
60
66
 
61
67
    def test_format_interrupt_exception(self):
62
68
        try:
68
74
        self.assertTrue(len(msg) > 0)
69
75
        self.assertEqualDiff(msg, 'bzr: interrupted\n')
70
76
 
 
77
    def test_format_memory_error(self):
 
78
        try:
 
79
            raise MemoryError()
 
80
        except MemoryError:
 
81
            pass
 
82
        msg = _format_exception()
 
83
        self.assertEquals(msg,
 
84
            "bzr: out of memory\n")
 
85
 
71
86
    def test_format_os_error(self):
72
87
        try:
 
88
            os.rmdir('nosuchfile22222')
 
89
        except OSError, e:
 
90
            e_str = str(e)
 
91
        msg = _format_exception()
 
92
        # Linux seems to give "No such file" but Windows gives "The system
 
93
        # cannot find the file specified".
 
94
        self.assertEqual('bzr: ERROR: %s\n' % (e_str,), msg)
 
95
 
 
96
    def test_format_io_error(self):
 
97
        try:
73
98
            file('nosuchfile22222')
74
 
        except (OSError, IOError):
 
99
        except IOError:
75
100
            pass
76
101
        msg = _format_exception()
77
 
        self.assertContainsRe(msg, r'^bzr: ERROR: \[Errno .*\] No such file.*nosuchfile')
 
102
        # Even though Windows and Linux differ for 'os.rmdir', they both give
 
103
        # 'No such file' for open()
 
104
        self.assertContainsRe(msg,
 
105
            r'^bzr: ERROR: \[Errno .*\] No such file.*nosuchfile')
78
106
 
79
107
    def test_format_unicode_error(self):
80
108
        try:
113
141
            pass
114
142
        msg = _format_exception()
115
143
        self.assertContainsRe(msg,
116
 
            r"Traceback \(most recent call last\)")
 
144
            r'Bazaar has encountered an internal error')
117
145
 
118
146
    def test_trace_unicode(self):
119
147
        """Write Unicode to trace log"""
120
148
        self.log(u'the unicode character for benzene is \N{BENZENE RING}')
121
 
        self.assertContainsRe(self._get_log(keep_log_file=True),
122
 
                              "the unicode character for benzene is")
123
 
    
 
149
        log = self.get_log()
 
150
        self.assertContainsRe(log, "the unicode character for benzene is")
 
151
 
124
152
    def test_trace_argument_unicode(self):
125
153
        """Write a Unicode argument to the trace log"""
126
154
        mutter(u'the unicode character for benzene is %s', u'\N{BENZENE RING}')
127
 
        self.assertContainsRe(self._get_log(keep_log_file=True),
128
 
                              'the unicode character')
 
155
        log = self.get_log()
 
156
        self.assertContainsRe(log, 'the unicode character')
129
157
 
130
158
    def test_trace_argument_utf8(self):
131
159
        """Write a Unicode argument to the trace log"""
132
160
        mutter(u'the unicode character for benzene is %s',
133
161
               u'\N{BENZENE RING}'.encode('utf-8'))
134
 
        self.assertContainsRe(self._get_log(keep_log_file=True),
135
 
                              'the unicode character')
 
162
        log = self.get_log()
 
163
        self.assertContainsRe(log, 'the unicode character')
136
164
 
137
165
    def test_report_broken_pipe(self):
138
166
        try:
151
179
    def test_mutter_callsite_1(self):
152
180
        """mutter_callsite can capture 1 level of stack frame."""
153
181
        mutter_callsite(1, "foo %s", "a string")
154
 
        log = self._get_log(keep_log_file=True)
 
182
        log = self.get_log()
155
183
        # begin with the message
156
184
        self.assertLogStartsWith(log, 'foo a string\nCalled from:\n')
157
185
        # should show two frame: this frame and the one above
163
191
    def test_mutter_callsite_2(self):
164
192
        """mutter_callsite can capture 2 levels of stack frame."""
165
193
        mutter_callsite(2, "foo %s", "a string")
166
 
        log = self._get_log(keep_log_file=True)
 
194
        log = self.get_log()
167
195
        # begin with the message
168
196
        self.assertLogStartsWith(log, 'foo a string\nCalled from:\n')
169
197
        # should show two frame: this frame and the one above
175
203
    def test_mutter_never_fails(self):
176
204
        # Even if the decode/encode stage fails, mutter should not
177
205
        # raise an exception
 
206
        # This test checks that mutter doesn't fail; the current behaviour
 
207
        # is that it doesn't fail *and writes non-utf8*.
178
208
        mutter(u'Writing a greek mu (\xb5) works in a unicode string')
179
209
        mutter('But fails in an ascii string \xb5')
180
210
        mutter('and in an ascii argument: %s', '\xb5')
181
 
        log = self._get_log(keep_log_file=True)
 
211
        log = self.get_log()
182
212
        self.assertContainsRe(log, 'Writing a greek mu')
183
213
        self.assertContainsRe(log, "But fails in an ascii string")
184
 
        self.assertContainsRe(log, u"ascii argument: \xb5")
 
214
        # However, the log content object does unicode replacement on reading
 
215
        # to let it get unicode back where good data has been written. So we
 
216
        # have to do a replaceent here as well.
 
217
        self.assertContainsRe(log, "ascii argument: \xb5".decode('utf8',
 
218
            'replace'))
 
219
        
 
220
    def test_show_error(self):
 
221
        show_error('error1')
 
222
        show_error(u'error2 \xb5 blah')
 
223
        show_error('arg: %s', 'blah')
 
224
        show_error('arg2: %(key)s', {'key':'stuff'})
 
225
        try:
 
226
            raise Exception("oops")
 
227
        except:
 
228
            show_error('kwarg', exc_info=True)
 
229
        log = self.get_log()
 
230
        self.assertContainsRe(log, 'error1')
 
231
        self.assertContainsRe(log, u'error2 \xb5 blah')
 
232
        self.assertContainsRe(log, 'arg: blah')
 
233
        self.assertContainsRe(log, 'arg2: stuff')
 
234
        self.assertContainsRe(log, 'kwarg')
 
235
        self.assertContainsRe(log, 'Traceback \\(most recent call last\\):')
 
236
        self.assertContainsRe(log, 'File ".*test_trace.py", line .*, in test_show_error')
 
237
        self.assertContainsRe(log, 'raise Exception\\("oops"\\)')
 
238
        self.assertContainsRe(log, 'Exception: oops')
185
239
 
186
240
    def test_push_log_file(self):
187
241
        """Can push and pop log file, and this catches mutter messages.
188
242
 
189
 
        This is primarily for use in the test framework. 
 
243
        This is primarily for use in the test framework.
190
244
        """
191
245
        tmp1 = tempfile.NamedTemporaryFile()
192
246
        tmp2 = tempfile.NamedTemporaryFile()
216
270
            tmp1.close()
217
271
            tmp2.close()
218
272
 
 
273
    def test__open_bzr_log_uses_stderr_for_failures(self):
 
274
        # If _open_bzr_log cannot open the file, then we should write the
 
275
        # warning to stderr. Since this is normally happening before logging is
 
276
        # set up.
 
277
        self.overrideAttr(sys, 'stderr', StringIO())
 
278
        # Set the log file to something that cannot exist
 
279
        # FIXME: A bit dangerous: we are not in an isolated dir here -- vilajam
 
280
        # 20100125
 
281
        os.environ['BZR_LOG'] = os.getcwd() + '/no-dir/bzr.log'
 
282
        self.overrideAttr(trace, '_bzr_log_filename')
 
283
        logf = trace._open_bzr_log()
 
284
        self.assertIs(None, logf)
 
285
        self.assertContainsRe(sys.stderr.getvalue(),
 
286
                              'failed to open trace file: .*/no-dir/bzr.log')
 
287
 
219
288
 
220
289
class TestVerbosityLevel(TestCase):
221
290
 
246
315
    def test_log_rollover(self):
247
316
        temp_log_name = 'test-log'
248
317
        trace_file = open(temp_log_name, 'at')
249
 
        trace_file.write('test_log_rollover padding\n' * 1000000)
 
318
        trace_file.writelines(['test_log_rollover padding\n'] * 200000)
250
319
        trace_file.close()
251
320
        _rollover_trace_maybe(temp_log_name)
252
321
        # should have been rolled over