← 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: Vincent Ladeuil
  • Date: 2009-12-14 15:51:36 UTC
  • mto: (4894.1.1 integration)
  • mto: This revision was merged to the branch mainline in revision 4895.
  • Revision ID: v.ladeuil+lp@free.fr-20091214155136-rf4nkqvxda9oiw4u
Cleanup tests and tweak the text displayed.

* bzrlib/tests/blackbox/test_update.py:
Fix imports and replace the assertContainsRe with assertEqualDiff
to make the test clearer, more robust and easier to debug.

* bzrlib/tests/commands/test_update.py: 
Fix imports.

* bzrlib/tests/blackbox/test_filtered_view_ops.py: 
Fix imports and strange accesses to base class methods.
(TestViewTreeOperations.test_view_on_update): Avoid os.chdir()
call, simplify string matching assertions.

* bzrlib/builtins.py:
(cmd_update.run): Fix spurious space, get rid of the final '/' for
the base path, don't add a final period (it's a legal char in a
path and would be annoying for people that like to copy/paste).

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, e:
 
88
            e_str = str(e)
 
89
        msg = _format_exception()
 
90
        # Linux seems to give "No such file" but Windows gives "The system
 
91
        # cannot find the file specified".
 
92
        self.assertEqual('bzr: ERROR: %s\n' % (e_str,), msg)
 
93
 
 
94
    def test_format_io_error(self):
 
95
        try:
 
96
            file('nosuchfile22222')
 
97
        except IOError:
 
98
            pass
 
99
        msg = _format_exception()
 
100
        # Even though Windows and Linux differ for 'os.rmdir', they both give
 
101
        # 'No such file' for open()
 
102
        self.assertContainsRe(msg,
 
103
            r'^bzr: ERROR: \[Errno .*\] No such file.*nosuchfile')
 
104
 
 
105
    def test_format_unicode_error(self):
 
106
        try:
 
107
            raise errors.BzrCommandError(u'argument foo\xb5 does not exist')
 
108
        except errors.BzrCommandError:
 
109
            pass
 
110
        msg = _format_exception()
 
111
 
 
112
    def test_format_exception(self):
 
113
        """Short formatting of bzr exceptions"""
 
114
        try:
 
115
            raise errors.NotBranchError('wibble')
 
116
        except errors.NotBranchError:
 
117
            pass
 
118
        msg = _format_exception()
 
119
        self.assertTrue(len(msg) > 0)
 
120
        self.assertEqualDiff(msg, 'bzr: ERROR: Not a branch: \"wibble\".\n')
 
121
 
 
122
    def test_report_external_import_error(self):
 
123
        """Short friendly message for missing system modules."""
 
124
        try:
 
125
            import ImaginaryModule
 
126
        except ImportError, e:
 
127
            pass
 
128
        else:
 
129
            self.fail("somehow succeeded in importing %r" % ImaginaryModule)
 
130
        msg = _format_exception()
 
131
        self.assertEqual(msg,
 
132
            'bzr: ERROR: No module named ImaginaryModule\n'
 
133
            'You may need to install this Python library separately.\n')
 
134
 
 
135
    def test_report_import_syntax_error(self):
 
136
        try:
 
137
            raise ImportError("syntax error")
 
138
        except ImportError, e:
 
139
            pass
 
140
        msg = _format_exception()
 
141
        self.assertContainsRe(msg,
 
142
            r'Bazaar has encountered an internal error')
 
143
 
 
144
    def test_trace_unicode(self):
 
145
        """Write Unicode to trace log"""
 
146
        self.log(u'the unicode character for benzene is \N{BENZENE RING}')
 
147
        self.assertContainsRe(self._get_log(keep_log_file=True),
 
148
                              "the unicode character for benzene is")
 
149
 
 
150
    def test_trace_argument_unicode(self):
 
151
        """Write a Unicode argument to the trace log"""
 
152
        mutter(u'the unicode character for benzene is %s', u'\N{BENZENE RING}')
 
153
        self.assertContainsRe(self._get_log(keep_log_file=True),
 
154
                              'the unicode character')
 
155
 
 
156
    def test_trace_argument_utf8(self):
 
157
        """Write a Unicode argument to the trace log"""
 
158
        mutter(u'the unicode character for benzene is %s',
 
159
               u'\N{BENZENE RING}'.encode('utf-8'))
 
160
        self.assertContainsRe(self._get_log(keep_log_file=True),
 
161
                              'the unicode character')
 
162
 
 
163
    def test_report_broken_pipe(self):
 
164
        try:
 
165
            raise IOError(errno.EPIPE, 'broken pipe foofofo')
 
166
        except IOError, e:
 
167
            msg = _format_exception()
 
168
            self.assertEquals(msg, "bzr: broken pipe\n")
 
169
        else:
 
170
            self.fail("expected error not raised")
 
171
 
 
172
    def assertLogStartsWith(self, log, string):
 
173
        """Like assertStartsWith, but skips the log timestamp."""
 
174
        self.assertContainsRe(log,
 
175
            '^\\d+\\.\\d+  ' + re.escape(string))
 
176
 
 
177
    def test_mutter_callsite_1(self):
 
178
        """mutter_callsite can capture 1 level of stack frame."""
 
179
        mutter_callsite(1, "foo %s", "a string")
 
180
        log = self._get_log(keep_log_file=True)
 
181
        # begin with the message
 
182
        self.assertLogStartsWith(log, 'foo a string\nCalled from:\n')
 
183
        # should show two frame: this frame and the one above
 
184
        self.assertContainsRe(log,
 
185
            'test_trace\\.py", line \\d+, in test_mutter_callsite_1\n')
 
186
        # this frame should be the final one
 
187
        self.assertEndsWith(log, ' "a string")\n')
 
188
 
 
189
    def test_mutter_callsite_2(self):
 
190
        """mutter_callsite can capture 2 levels of stack frame."""
 
191
        mutter_callsite(2, "foo %s", "a string")
 
192
        log = self._get_log(keep_log_file=True)
 
193
        # begin with the message
 
194
        self.assertLogStartsWith(log, 'foo a string\nCalled from:\n')
 
195
        # should show two frame: this frame and the one above
 
196
        self.assertContainsRe(log,
 
197
            'test_trace.py", line \d+, in test_mutter_callsite_2\n')
 
198
        # this frame should be the final one
 
199
        self.assertEndsWith(log, ' "a string")\n')
 
200
 
 
201
    def test_mutter_never_fails(self):
 
202
        # Even if the decode/encode stage fails, mutter should not
 
203
        # raise an exception
 
204
        mutter(u'Writing a greek mu (\xb5) works in a unicode string')
 
205
        mutter('But fails in an ascii string \xb5')
 
206
        mutter('and in an ascii argument: %s', '\xb5')
 
207
        log = self._get_log(keep_log_file=True)
 
208
        self.assertContainsRe(log, 'Writing a greek mu')
 
209
        self.assertContainsRe(log, "But fails in an ascii string")
 
210
        self.assertContainsRe(log, u"ascii argument: \xb5")
 
211
 
 
212
    def test_push_log_file(self):
 
213
        """Can push and pop log file, and this catches mutter messages.
 
214
 
 
215
        This is primarily for use in the test framework.
 
216
        """
 
217
        tmp1 = tempfile.NamedTemporaryFile()
 
218
        tmp2 = tempfile.NamedTemporaryFile()
 
219
        try:
 
220
            memento1 = push_log_file(tmp1)
 
221
            mutter("comment to file1")
 
222
            try:
 
223
                memento2 = push_log_file(tmp2)
 
224
                try:
 
225
                    mutter("comment to file2")
 
226
                finally:
 
227
                    pop_log_file(memento2)
 
228
                mutter("again to file1")
 
229
            finally:
 
230
                pop_log_file(memento1)
 
231
            # the files were opened in binary mode, so should have exactly
 
232
            # these bytes.  and removing the file as the log target should
 
233
            # have caused them to be flushed out.  need to match using regexps
 
234
            # as there's a timestamp at the front.
 
235
            tmp1.seek(0)
 
236
            self.assertContainsRe(tmp1.read(),
 
237
                r"\d+\.\d+  comment to file1\n\d+\.\d+  again to file1\n")
 
238
            tmp2.seek(0)
 
239
            self.assertContainsRe(tmp2.read(),
 
240
                r"\d+\.\d+  comment to file2\n")
 
241
        finally:
 
242
            tmp1.close()
 
243
            tmp2.close()
 
244
 
 
245
 
 
246
class TestVerbosityLevel(TestCase):
 
247
 
 
248
    def test_verbosity_level(self):
 
249
        set_verbosity_level(1)
 
250
        self.assertEqual(1, get_verbosity_level())
 
251
        self.assertTrue(is_verbose())
 
252
        self.assertFalse(is_quiet())
 
253
        set_verbosity_level(-1)
 
254
        self.assertEqual(-1, get_verbosity_level())
 
255
        self.assertFalse(is_verbose())
 
256
        self.assertTrue(is_quiet())
 
257
        set_verbosity_level(0)
 
258
        self.assertEqual(0, get_verbosity_level())
 
259
        self.assertFalse(is_verbose())
 
260
        self.assertFalse(is_quiet())
 
261
 
 
262
    def test_be_quiet(self):
 
263
        # Confirm the old API still works
 
264
        be_quiet(True)
 
265
        self.assertEqual(-1, get_verbosity_level())
 
266
        be_quiet(False)
 
267
        self.assertEqual(0, get_verbosity_level())
 
268
 
 
269
 
 
270
class TestBzrLog(TestCaseInTempDir):
 
271
 
 
272
    def test_log_rollover(self):
 
273
        temp_log_name = 'test-log'
 
274
        trace_file = open(temp_log_name, 'at')
 
275
        trace_file.writelines(['test_log_rollover padding\n'] * 200000)
 
276
        trace_file.close()
 
277
        _rollover_trace_maybe(temp_log_name)
 
278
        # should have been rolled over
 
279
        self.assertFalse(os.access(temp_log_name, os.R_OK))