← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_trace.py

merge merge tweaks from aaron, which includes latest .dev

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