/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_trace.py

  • Committer: Robert Collins
  • Date: 2010-05-06 07:48:22 UTC
  • mto: This revision was merged to the branch mainline in revision 5223.
  • Revision ID: robertc@robertcollins.net-20100506074822-0bsgf2j4h8jx0xkk
Added ``bzrlib.tests.matchers`` as a place to put matchers, along with
our first in-tree matcher. See the module docstring for details.
(Robert Collins)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_trace.py
 
1
# Copyright (C) 2005-2010 Canonical Ltd
 
2
#
 
3
# This program is free software; you can redistribute it and/or modify
 
4
# it under the terms of the GNU General Public License as published by
 
5
# the Free Software Foundation; either version 2 of the License, or
 
6
# (at your option) any later version.
 
7
#
 
8
# This program is distributed in the hope that it will be useful,
 
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
 
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
11
# GNU General Public License for more details.
 
12
#
 
13
# You should have received a copy of the GNU General Public License
 
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
 
16
 
 
17
# "weren't nothing promised to you.  do i look like i got a promise face?"
 
18
 
 
19
"""Tests for trace library"""
 
20
 
 
21
from cStringIO import StringIO
 
22
import errno
 
23
import os
 
24
import re
 
25
import sys
 
26
import tempfile
 
27
 
 
28
from bzrlib import (
 
29
    errors,
 
30
    trace,
 
31
    )
 
32
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
    )
 
41
 
 
42
 
 
43
def _format_exception():
 
44
    """Format an exception as it would normally be displayed to the user"""
 
45
    buf = StringIO()
 
46
    report_exception(sys.exc_info(), buf)
 
47
    return buf.getvalue()
 
48
 
 
49
 
 
50
class TestTrace(TestCase):
 
51
 
 
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.
 
57
        try:
 
58
            raise NotImplementedError, "time travel"
 
59
        except NotImplementedError:
 
60
            pass
 
61
        err = _format_exception()
 
62
        self.assertEqualDiff(err.splitlines()[0],
 
63
                'bzr: ERROR: exceptions.NotImplementedError: time travel')
 
64
        self.assertContainsRe(err,
 
65
            'Bazaar has encountered an internal error.')
 
66
 
 
67
    def test_format_interrupt_exception(self):
 
68
        try:
 
69
            raise KeyboardInterrupt()
 
70
        except KeyboardInterrupt:
 
71
            # XXX: Some risk that a *real* keyboard interrupt won't be seen
 
72
            pass
 
73
        msg = _format_exception()
 
74
        self.assertTrue(len(msg) > 0)
 
75
        self.assertEqualDiff(msg, 'bzr: interrupted\n')
 
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
 
 
86
    def test_format_os_error(self):
 
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:
 
98
            file('nosuchfile22222')
 
99
        except IOError:
 
100
            pass
 
101
        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')
 
106
 
 
107
    def test_format_unicode_error(self):
 
108
        try:
 
109
            raise errors.BzrCommandError(u'argument foo\xb5 does not exist')
 
110
        except errors.BzrCommandError:
 
111
            pass
 
112
        msg = _format_exception()
 
113
 
 
114
    def test_format_exception(self):
 
115
        """Short formatting of bzr exceptions"""
 
116
        try:
 
117
            raise errors.NotBranchError('wibble')
 
118
        except errors.NotBranchError:
 
119
            pass
 
120
        msg = _format_exception()
 
121
        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')
 
145
 
 
146
    def test_trace_unicode(self):
 
147
        """Write Unicode to trace log"""
 
148
        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
 
 
152
    def test_trace_argument_unicode(self):
 
153
        """Write a Unicode argument to the trace log"""
 
154
        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')
 
157
 
 
158
    def test_trace_argument_utf8(self):
 
159
        """Write a Unicode argument to the trace log"""
 
160
        mutter(u'the unicode character for benzene is %s',
 
161
               u'\N{BENZENE RING}'.encode('utf-8'))
 
162
        log = self.get_log()
 
163
        self.assertContainsRe(log, 'the unicode character')
 
164
 
 
165
    def test_report_broken_pipe(self):
 
166
        try:
 
167
            raise IOError(errno.EPIPE, 'broken pipe foofofo')
 
168
        except IOError, e:
 
169
            msg = _format_exception()
 
170
            self.assertEquals(msg, "bzr: broken pipe\n")
 
171
        else:
 
172
            self.fail("expected error not raised")
 
173
 
 
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
    def test_mutter_never_fails(self):
 
204
        # Even if the decode/encode stage fails, mutter should not
 
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*.
 
208
        mutter(u'Writing a greek mu (\xb5) works in a unicode string')
 
209
        mutter('But fails in an ascii string \xb5')
 
210
        mutter('and in an ascii argument: %s', '\xb5')
 
211
        log = self.get_log()
 
212
        self.assertContainsRe(log, 'Writing a greek mu')
 
213
        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))