← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_trace.py

(jam) Some python2.4 fixes for the StaticTuple code.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_trace.py
 
1
# Copyright (C) 2005, 2006, 2007, 2008, 2009 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
    )
 
31
from bzrlib.tests import TestCaseInTempDir, TestCase
 
32
from bzrlib.trace import (
 
33
    mutter, mutter_callsite, report_exception,
 
34
    set_verbosity_level, get_verbosity_level, is_quiet, is_verbose, be_quiet,
 
35
    pop_log_file,
 
36
    push_log_file,
 
37
    _rollover_trace_maybe,
 
38
    )
 
39
 
 
40
 
 
41
def _format_exception():
 
42
    """Format an exception as it would normally be displayed to the user"""
 
43
    buf = StringIO()
 
44
    report_exception(sys.exc_info(), buf)
 
45
    return buf.getvalue()
 
46
 
 
47
 
 
48
class TestTrace(TestCase):
 
49
 
 
50
    def test_format_sys_exception(self):
 
51
        # Test handling of an internal/unexpected error that probably
 
52
        # indicates a bug in bzr.  The details of the message may vary
 
53
        # depending on whether apport is available or not.  See test_crash for
 
54
        # more.
 
55
        try:
 
56
            raise NotImplementedError, "time travel"
 
57
        except NotImplementedError:
 
58
            pass
 
59
        err = _format_exception()
 
60
        self.assertEqualDiff(err.splitlines()[0],
 
61
                'bzr: ERROR: exceptions.NotImplementedError: time travel')
 
62
        self.assertContainsRe(err,
 
63
            'Bazaar has encountered an internal error.')
 
64
 
 
65
    def test_format_interrupt_exception(self):
 
66
        try:
 
67
            raise KeyboardInterrupt()
 
68
        except KeyboardInterrupt:
 
69
            # XXX: Some risk that a *real* keyboard interrupt won't be seen
 
70
            pass
 
71
        msg = _format_exception()
 
72
        self.assertTrue(len(msg) > 0)
 
73
        self.assertEqualDiff(msg, 'bzr: interrupted\n')
 
74
 
 
75
    def test_format_memory_error(self):
 
76
        try:
 
77
            raise MemoryError()
 
78
        except MemoryError:
 
79
            pass
 
80
        msg = _format_exception()
 
81
        self.assertEquals(msg,
 
82
            "bzr: out of memory\n")
 
83
 
 
84
    def test_format_os_error(self):
 
85
        try:
 
86
            os.rmdir('nosuchfile22222')
 
87
        except OSError:
 
88
            pass
 
89
        msg = _format_exception()
 
90
        self.assertContainsRe(msg,
 
91
            r'^bzr: ERROR: \[Errno .*\] No such file.*nosuchfile22222')
 
92
 
 
93
    def test_format_io_error(self):
 
94
        try:
 
95
            file('nosuchfile22222')
 
96
        except IOError:
 
97
            pass
 
98
        msg = _format_exception()
 
99
        self.assertContainsRe(msg, r'^bzr: ERROR: \[Errno .*\] No such file.*nosuchfile')
 
100
 
 
101
    def test_format_unicode_error(self):
 
102
        try:
 
103
            raise errors.BzrCommandError(u'argument foo\xb5 does not exist')
 
104
        except errors.BzrCommandError:
 
105
            pass
 
106
        msg = _format_exception()
 
107
 
 
108
    def test_format_exception(self):
 
109
        """Short formatting of bzr exceptions"""
 
110
        try:
 
111
            raise errors.NotBranchError('wibble')
 
112
        except errors.NotBranchError:
 
113
            pass
 
114
        msg = _format_exception()
 
115
        self.assertTrue(len(msg) > 0)
 
116
        self.assertEqualDiff(msg, 'bzr: ERROR: Not a branch: \"wibble\".\n')
 
117
 
 
118
    def test_report_external_import_error(self):
 
119
        """Short friendly message for missing system modules."""
 
120
        try:
 
121
            import ImaginaryModule
 
122
        except ImportError, e:
 
123
            pass
 
124
        else:
 
125
            self.fail("somehow succeeded in importing %r" % ImaginaryModule)
 
126
        msg = _format_exception()
 
127
        self.assertEqual(msg,
 
128
            'bzr: ERROR: No module named ImaginaryModule\n'
 
129
            'You may need to install this Python library separately.\n')
 
130
 
 
131
    def test_report_import_syntax_error(self):
 
132
        try:
 
133
            raise ImportError("syntax error")
 
134
        except ImportError, e:
 
135
            pass
 
136
        msg = _format_exception()
 
137
        self.assertContainsRe(msg,
 
138
            r'Bazaar has encountered an internal error')
 
139
 
 
140
    def test_trace_unicode(self):
 
141
        """Write Unicode to trace log"""
 
142
        self.log(u'the unicode character for benzene is \N{BENZENE RING}')
 
143
        self.assertContainsRe(self._get_log(keep_log_file=True),
 
144
                              "the unicode character for benzene is")
 
145
 
 
146
    def test_trace_argument_unicode(self):
 
147
        """Write a Unicode argument to the trace log"""
 
148
        mutter(u'the unicode character for benzene is %s', u'\N{BENZENE RING}')
 
149
        self.assertContainsRe(self._get_log(keep_log_file=True),
 
150
                              'the unicode character')
 
151
 
 
152
    def test_trace_argument_utf8(self):
 
153
        """Write a Unicode argument to the trace log"""
 
154
        mutter(u'the unicode character for benzene is %s',
 
155
               u'\N{BENZENE RING}'.encode('utf-8'))
 
156
        self.assertContainsRe(self._get_log(keep_log_file=True),
 
157
                              'the unicode character')
 
158
 
 
159
    def test_report_broken_pipe(self):
 
160
        try:
 
161
            raise IOError(errno.EPIPE, 'broken pipe foofofo')
 
162
        except IOError, e:
 
163
            msg = _format_exception()
 
164
            self.assertEquals(msg, "bzr: broken pipe\n")
 
165
        else:
 
166
            self.fail("expected error not raised")
 
167
 
 
168
    def assertLogStartsWith(self, log, string):
 
169
        """Like assertStartsWith, but skips the log timestamp."""
 
170
        self.assertContainsRe(log,
 
171
            '^\\d+\\.\\d+  ' + re.escape(string))
 
172
 
 
173
    def test_mutter_callsite_1(self):
 
174
        """mutter_callsite can capture 1 level of stack frame."""
 
175
        mutter_callsite(1, "foo %s", "a string")
 
176
        log = self._get_log(keep_log_file=True)
 
177
        # begin with the message
 
178
        self.assertLogStartsWith(log, 'foo a string\nCalled from:\n')
 
179
        # should show two frame: this frame and the one above
 
180
        self.assertContainsRe(log,
 
181
            'test_trace\\.py", line \\d+, in test_mutter_callsite_1\n')
 
182
        # this frame should be the final one
 
183
        self.assertEndsWith(log, ' "a string")\n')
 
184
 
 
185
    def test_mutter_callsite_2(self):
 
186
        """mutter_callsite can capture 2 levels of stack frame."""
 
187
        mutter_callsite(2, "foo %s", "a string")
 
188
        log = self._get_log(keep_log_file=True)
 
189
        # begin with the message
 
190
        self.assertLogStartsWith(log, 'foo a string\nCalled from:\n')
 
191
        # should show two frame: this frame and the one above
 
192
        self.assertContainsRe(log,
 
193
            'test_trace.py", line \d+, in test_mutter_callsite_2\n')
 
194
        # this frame should be the final one
 
195
        self.assertEndsWith(log, ' "a string")\n')
 
196
 
 
197
    def test_mutter_never_fails(self):
 
198
        # Even if the decode/encode stage fails, mutter should not
 
199
        # raise an exception
 
200
        mutter(u'Writing a greek mu (\xb5) works in a unicode string')
 
201
        mutter('But fails in an ascii string \xb5')
 
202
        mutter('and in an ascii argument: %s', '\xb5')
 
203
        log = self._get_log(keep_log_file=True)
 
204
        self.assertContainsRe(log, 'Writing a greek mu')
 
205
        self.assertContainsRe(log, "But fails in an ascii string")
 
206
        self.assertContainsRe(log, u"ascii argument: \xb5")
 
207
 
 
208
    def test_push_log_file(self):
 
209
        """Can push and pop log file, and this catches mutter messages.
 
210
 
 
211
        This is primarily for use in the test framework.
 
212
        """
 
213
        tmp1 = tempfile.NamedTemporaryFile()
 
214
        tmp2 = tempfile.NamedTemporaryFile()
 
215
        try:
 
216
            memento1 = push_log_file(tmp1)
 
217
            mutter("comment to file1")
 
218
            try:
 
219
                memento2 = push_log_file(tmp2)
 
220
                try:
 
221
                    mutter("comment to file2")
 
222
                finally:
 
223
                    pop_log_file(memento2)
 
224
                mutter("again to file1")
 
225
            finally:
 
226
                pop_log_file(memento1)
 
227
            # the files were opened in binary mode, so should have exactly
 
228
            # these bytes.  and removing the file as the log target should
 
229
            # have caused them to be flushed out.  need to match using regexps
 
230
            # as there's a timestamp at the front.
 
231
            tmp1.seek(0)
 
232
            self.assertContainsRe(tmp1.read(),
 
233
                r"\d+\.\d+  comment to file1\n\d+\.\d+  again to file1\n")
 
234
            tmp2.seek(0)
 
235
            self.assertContainsRe(tmp2.read(),
 
236
                r"\d+\.\d+  comment to file2\n")
 
237
        finally:
 
238
            tmp1.close()
 
239
            tmp2.close()
 
240
 
 
241
 
 
242
class TestVerbosityLevel(TestCase):
 
243
 
 
244
    def test_verbosity_level(self):
 
245
        set_verbosity_level(1)
 
246
        self.assertEqual(1, get_verbosity_level())
 
247
        self.assertTrue(is_verbose())
 
248
        self.assertFalse(is_quiet())
 
249
        set_verbosity_level(-1)
 
250
        self.assertEqual(-1, get_verbosity_level())
 
251
        self.assertFalse(is_verbose())
 
252
        self.assertTrue(is_quiet())
 
253
        set_verbosity_level(0)
 
254
        self.assertEqual(0, get_verbosity_level())
 
255
        self.assertFalse(is_verbose())
 
256
        self.assertFalse(is_quiet())
 
257
 
 
258
    def test_be_quiet(self):
 
259
        # Confirm the old API still works
 
260
        be_quiet(True)
 
261
        self.assertEqual(-1, get_verbosity_level())
 
262
        be_quiet(False)
 
263
        self.assertEqual(0, get_verbosity_level())
 
264
 
 
265
 
 
266
class TestBzrLog(TestCaseInTempDir):
 
267
 
 
268
    def test_log_rollover(self):
 
269
        temp_log_name = 'test-log'
 
270
        trace_file = open(temp_log_name, 'at')
 
271
        trace_file.write('test_log_rollover padding\n' * 1000000)
 
272
        trace_file.close()
 
273
        _rollover_trace_maybe(temp_log_name)
 
274
        # should have been rolled over
 
275
        self.assertFalse(os.access(temp_log_name, os.R_OK))