← 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: John Arbash Meinel
  • Date: 2007-01-25 15:54:29 UTC
  • mto: This revision was merged to the branch mainline in revision 2245.
  • Revision ID: john@arbash-meinel.com-20070125155429-x53892xqx4r17l8h
Clean up the documentation and imports for decorators (per Martin's suggestions)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_trace.py
1
 
# Copyright (C) 2005-2010 Canonical Ltd
 
1
# Copyright (C) 2005, 2006 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
 
21
21
from cStringIO import StringIO
22
22
import errno
23
23
import os
24
 
import re
25
24
import sys
26
 
import tempfile
27
25
 
28
26
from bzrlib import (
29
27
    errors,
30
 
    trace,
31
28
    )
32
29
from bzrlib.tests import TestCaseInTempDir, TestCase
33
 
from bzrlib.trace import (
34
 
    mutter, mutter_callsite, report_exception,
35
 
    set_verbosity_level, get_verbosity_level, is_quiet, is_verbose, be_quiet,
36
 
    pop_log_file,
37
 
    push_log_file,
38
 
    _rollover_trace_maybe,
39
 
    show_error,
40
 
    )
 
30
from bzrlib.trace import mutter, report_exception
41
31
 
42
32
 
43
33
def _format_exception():
50
40
class TestTrace(TestCase):
51
41
 
52
42
    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.
57
43
        try:
58
44
            raise NotImplementedError, "time travel"
59
45
        except NotImplementedError:
62
48
        self.assertEqualDiff(err.splitlines()[0],
63
49
                'bzr: ERROR: exceptions.NotImplementedError: time travel')
64
50
        self.assertContainsRe(err,
65
 
            'Bazaar has encountered an internal error.')
 
51
                r'File.*test_trace.py')
66
52
 
67
53
    def test_format_interrupt_exception(self):
68
54
        try:
74
60
        self.assertTrue(len(msg) > 0)
75
61
        self.assertEqualDiff(msg, 'bzr: interrupted\n')
76
62
 
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
 
 
86
63
    def test_format_os_error(self):
87
64
        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:
98
65
            file('nosuchfile22222')
99
 
        except IOError:
 
66
        except (OSError, IOError):
100
67
            pass
101
68
        msg = _format_exception()
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')
 
69
        self.assertContainsRe(msg, r'^bzr: ERROR: \[Errno .*\] No such file.*nosuchfile')
106
70
 
107
71
    def test_format_unicode_error(self):
108
72
        try:
119
83
            pass
120
84
        msg = _format_exception()
121
85
        self.assertTrue(len(msg) > 0)
122
 
        self.assertEqualDiff(msg, 'bzr: ERROR: Not a branch: \"wibble\".\n')
123
 
 
124
 
    def test_report_external_import_error(self):
125
 
        """Short friendly message for missing system modules."""
126
 
        try:
127
 
            import ImaginaryModule
128
 
        except ImportError, e:
129
 
            pass
130
 
        else:
131
 
            self.fail("somehow succeeded in importing %r" % ImaginaryModule)
132
 
        msg = _format_exception()
133
 
        self.assertEqual(msg,
134
 
            'bzr: ERROR: No module named ImaginaryModule\n'
135
 
            'You may need to install this Python library separately.\n')
136
 
 
137
 
    def test_report_import_syntax_error(self):
138
 
        try:
139
 
            raise ImportError("syntax error")
140
 
        except ImportError, e:
141
 
            pass
142
 
        msg = _format_exception()
143
 
        self.assertContainsRe(msg,
144
 
            r'Bazaar has encountered an internal error')
 
86
        self.assertEqualDiff(msg, 'bzr: ERROR: Not a branch: wibble\n')
145
87
 
146
88
    def test_trace_unicode(self):
147
89
        """Write Unicode to trace log"""
148
90
        self.log(u'the unicode character for benzene is \N{BENZENE RING}')
149
 
        log = self.get_log()
150
 
        self.assertContainsRe(log, "the unicode character for benzene is")
151
 
 
 
91
        self.assertContainsRe(self._get_log(keep_log_file=True),
 
92
                              "the unicode character for benzene is")
 
93
    
152
94
    def test_trace_argument_unicode(self):
153
95
        """Write a Unicode argument to the trace log"""
154
96
        mutter(u'the unicode character for benzene is %s', u'\N{BENZENE RING}')
155
 
        log = self.get_log()
156
 
        self.assertContainsRe(log, 'the unicode character')
 
97
        self.assertContainsRe(self._get_log(keep_log_file=True),
 
98
                              'the unicode character')
157
99
 
158
100
    def test_trace_argument_utf8(self):
159
101
        """Write a Unicode argument to the trace log"""
160
102
        mutter(u'the unicode character for benzene is %s',
161
103
               u'\N{BENZENE RING}'.encode('utf-8'))
162
 
        log = self.get_log()
163
 
        self.assertContainsRe(log, 'the unicode character')
 
104
        self.assertContainsRe(self._get_log(keep_log_file=True),
 
105
                              'the unicode character')
164
106
 
165
107
    def test_report_broken_pipe(self):
166
108
        try:
171
113
        else:
172
114
            self.fail("expected error not raised")
173
115
 
174
 
    def assertLogStartsWith(self, log, string):
175
 
        """Like assertStartsWith, but skips the log timestamp."""
176
 
        self.assertContainsRe(log,
177
 
            '^\\d+\\.\\d+  ' + re.escape(string))
178
 
 
179
 
    def test_mutter_callsite_1(self):
180
 
        """mutter_callsite can capture 1 level of stack frame."""
181
 
        mutter_callsite(1, "foo %s", "a string")
182
 
        log = self.get_log()
183
 
        # begin with the message
184
 
        self.assertLogStartsWith(log, 'foo a string\nCalled from:\n')
185
 
        # should show two frame: this frame and the one above
186
 
        self.assertContainsRe(log,
187
 
            'test_trace\\.py", line \\d+, in test_mutter_callsite_1\n')
188
 
        # this frame should be the final one
189
 
        self.assertEndsWith(log, ' "a string")\n')
190
 
 
191
 
    def test_mutter_callsite_2(self):
192
 
        """mutter_callsite can capture 2 levels of stack frame."""
193
 
        mutter_callsite(2, "foo %s", "a string")
194
 
        log = self.get_log()
195
 
        # begin with the message
196
 
        self.assertLogStartsWith(log, 'foo a string\nCalled from:\n')
197
 
        # should show two frame: this frame and the one above
198
 
        self.assertContainsRe(log,
199
 
            'test_trace.py", line \d+, in test_mutter_callsite_2\n')
200
 
        # this frame should be the final one
201
 
        self.assertEndsWith(log, ' "a string")\n')
202
 
 
203
116
    def test_mutter_never_fails(self):
204
117
        # Even if the decode/encode stage fails, mutter should not
205
118
        # 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*.
208
119
        mutter(u'Writing a greek mu (\xb5) works in a unicode string')
209
120
        mutter('But fails in an ascii string \xb5')
210
121
        mutter('and in an ascii argument: %s', '\xb5')
211
 
        log = self.get_log()
 
122
        log = self._get_log(keep_log_file=True)
212
123
        self.assertContainsRe(log, 'Writing a greek mu')
213
124
        self.assertContainsRe(log, "But fails in an ascii string")
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')
239
 
 
240
 
    def test_push_log_file(self):
241
 
        """Can push and pop log file, and this catches mutter messages.
242
 
 
243
 
        This is primarily for use in the test framework.
244
 
        """
245
 
        tmp1 = tempfile.NamedTemporaryFile()
246
 
        tmp2 = tempfile.NamedTemporaryFile()
247
 
        try:
248
 
            memento1 = push_log_file(tmp1)
249
 
            mutter("comment to file1")
250
 
            try:
251
 
                memento2 = push_log_file(tmp2)
252
 
                try:
253
 
                    mutter("comment to file2")
254
 
                finally:
255
 
                    pop_log_file(memento2)
256
 
                mutter("again to file1")
257
 
            finally:
258
 
                pop_log_file(memento1)
259
 
            # the files were opened in binary mode, so should have exactly
260
 
            # these bytes.  and removing the file as the log target should
261
 
            # have caused them to be flushed out.  need to match using regexps
262
 
            # as there's a timestamp at the front.
263
 
            tmp1.seek(0)
264
 
            self.assertContainsRe(tmp1.read(),
265
 
                r"\d+\.\d+  comment to file1\n\d+\.\d+  again to file1\n")
266
 
            tmp2.seek(0)
267
 
            self.assertContainsRe(tmp2.read(),
268
 
                r"\d+\.\d+  comment to file2\n")
269
 
        finally:
270
 
            tmp1.close()
271
 
            tmp2.close()
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
 
 
288
 
 
289
 
class TestVerbosityLevel(TestCase):
290
 
 
291
 
    def test_verbosity_level(self):
292
 
        set_verbosity_level(1)
293
 
        self.assertEqual(1, get_verbosity_level())
294
 
        self.assertTrue(is_verbose())
295
 
        self.assertFalse(is_quiet())
296
 
        set_verbosity_level(-1)
297
 
        self.assertEqual(-1, get_verbosity_level())
298
 
        self.assertFalse(is_verbose())
299
 
        self.assertTrue(is_quiet())
300
 
        set_verbosity_level(0)
301
 
        self.assertEqual(0, get_verbosity_level())
302
 
        self.assertFalse(is_verbose())
303
 
        self.assertFalse(is_quiet())
304
 
 
305
 
    def test_be_quiet(self):
306
 
        # Confirm the old API still works
307
 
        be_quiet(True)
308
 
        self.assertEqual(-1, get_verbosity_level())
309
 
        be_quiet(False)
310
 
        self.assertEqual(0, get_verbosity_level())
311
 
 
312
 
 
313
 
class TestBzrLog(TestCaseInTempDir):
314
 
 
315
 
    def test_log_rollover(self):
316
 
        temp_log_name = 'test-log'
317
 
        trace_file = open(temp_log_name, 'at')
318
 
        trace_file.writelines(['test_log_rollover padding\n'] * 200000)
319
 
        trace_file.close()
320
 
        _rollover_trace_maybe(temp_log_name)
321
 
        # should have been rolled over
322
 
        self.assertFalse(os.access(temp_log_name, os.R_OK))
 
125
        self.assertContainsRe(log, u"ascii argument: \xb5")