~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_trace.py

doc

Show diffs side-by-side

added added

removed removed

Lines of Context:
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))