← 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: 2010-03-02 10:21:39 UTC
  • mfrom: (4797.2.24 2.1)
  • mto: This revision was merged to the branch mainline in revision 5069.
  • Revision ID: v.ladeuil+lp@free.fr-20100302102139-b5cba7h6xu13mekg
Merge 2.1 into trunk including fixes for #331095, #507557, #185103, #524184 and #369501

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_trace.py
1
 
# Copyright (C) 2005, 2006, 2007 Canonical Ltd
 
1
# Copyright (C) 2005-2010 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
12
12
#
13
13
# You should have received a copy of the GNU General Public License
14
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
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
17
# "weren't nothing promised to you.  do i look like i got a promise face?"
18
18
 
21
21
from cStringIO import StringIO
22
22
import errno
23
23
import os
 
24
import re
24
25
import sys
 
26
import tempfile
25
27
 
26
28
from bzrlib import (
27
29
    errors,
 
30
    trace,
28
31
    )
29
32
from bzrlib.tests import TestCaseInTempDir, TestCase
30
33
from bzrlib.trace import (
31
34
    mutter, mutter_callsite, report_exception,
32
35
    set_verbosity_level, get_verbosity_level, is_quiet, is_verbose, be_quiet,
 
36
    pop_log_file,
 
37
    push_log_file,
33
38
    _rollover_trace_maybe,
34
39
    )
35
40
 
44
49
class TestTrace(TestCase):
45
50
 
46
51
    def test_format_sys_exception(self):
 
52
        # Test handling of an internal/unexpected error that probably
 
53
        # indicates a bug in bzr.  The details of the message may vary
 
54
        # depending on whether apport is available or not.  See test_crash for
 
55
        # more.
47
56
        try:
48
57
            raise NotImplementedError, "time travel"
49
58
        except NotImplementedError:
52
61
        self.assertEqualDiff(err.splitlines()[0],
53
62
                'bzr: ERROR: exceptions.NotImplementedError: time travel')
54
63
        self.assertContainsRe(err,
55
 
                r'File.*test_trace.py')
 
64
            'Bazaar has encountered an internal error.')
56
65
 
57
66
    def test_format_interrupt_exception(self):
58
67
        try:
64
73
        self.assertTrue(len(msg) > 0)
65
74
        self.assertEqualDiff(msg, 'bzr: interrupted\n')
66
75
 
 
76
    def test_format_memory_error(self):
 
77
        try:
 
78
            raise MemoryError()
 
79
        except MemoryError:
 
80
            pass
 
81
        msg = _format_exception()
 
82
        self.assertEquals(msg,
 
83
            "bzr: out of memory\n")
 
84
 
67
85
    def test_format_os_error(self):
68
86
        try:
 
87
            os.rmdir('nosuchfile22222')
 
88
        except OSError, e:
 
89
            e_str = str(e)
 
90
        msg = _format_exception()
 
91
        # Linux seems to give "No such file" but Windows gives "The system
 
92
        # cannot find the file specified".
 
93
        self.assertEqual('bzr: ERROR: %s\n' % (e_str,), msg)
 
94
 
 
95
    def test_format_io_error(self):
 
96
        try:
69
97
            file('nosuchfile22222')
70
 
        except (OSError, IOError):
 
98
        except IOError:
71
99
            pass
72
100
        msg = _format_exception()
73
 
        self.assertContainsRe(msg, r'^bzr: ERROR: \[Errno .*\] No such file.*nosuchfile')
 
101
        # Even though Windows and Linux differ for 'os.rmdir', they both give
 
102
        # 'No such file' for open()
 
103
        self.assertContainsRe(msg,
 
104
            r'^bzr: ERROR: \[Errno .*\] No such file.*nosuchfile')
74
105
 
75
106
    def test_format_unicode_error(self):
76
107
        try:
89
120
        self.assertTrue(len(msg) > 0)
90
121
        self.assertEqualDiff(msg, 'bzr: ERROR: Not a branch: \"wibble\".\n')
91
122
 
 
123
    def test_report_external_import_error(self):
 
124
        """Short friendly message for missing system modules."""
 
125
        try:
 
126
            import ImaginaryModule
 
127
        except ImportError, e:
 
128
            pass
 
129
        else:
 
130
            self.fail("somehow succeeded in importing %r" % ImaginaryModule)
 
131
        msg = _format_exception()
 
132
        self.assertEqual(msg,
 
133
            'bzr: ERROR: No module named ImaginaryModule\n'
 
134
            'You may need to install this Python library separately.\n')
 
135
 
 
136
    def test_report_import_syntax_error(self):
 
137
        try:
 
138
            raise ImportError("syntax error")
 
139
        except ImportError, e:
 
140
            pass
 
141
        msg = _format_exception()
 
142
        self.assertContainsRe(msg,
 
143
            r'Bazaar has encountered an internal error')
 
144
 
92
145
    def test_trace_unicode(self):
93
146
        """Write Unicode to trace log"""
94
147
        self.log(u'the unicode character for benzene is \N{BENZENE RING}')
95
 
        self.assertContainsRe(self._get_log(keep_log_file=True),
96
 
                              "the unicode character for benzene is")
97
 
    
 
148
        log = self.get_log()
 
149
        self.assertContainsRe(log, "the unicode character for benzene is")
 
150
 
98
151
    def test_trace_argument_unicode(self):
99
152
        """Write a Unicode argument to the trace log"""
100
153
        mutter(u'the unicode character for benzene is %s', u'\N{BENZENE RING}')
101
 
        self.assertContainsRe(self._get_log(keep_log_file=True),
102
 
                              'the unicode character')
 
154
        log = self.get_log()
 
155
        self.assertContainsRe(log, 'the unicode character')
103
156
 
104
157
    def test_trace_argument_utf8(self):
105
158
        """Write a Unicode argument to the trace log"""
106
159
        mutter(u'the unicode character for benzene is %s',
107
160
               u'\N{BENZENE RING}'.encode('utf-8'))
108
 
        self.assertContainsRe(self._get_log(keep_log_file=True),
109
 
                              'the unicode character')
 
161
        log = self.get_log()
 
162
        self.assertContainsRe(log, 'the unicode character')
110
163
 
111
164
    def test_report_broken_pipe(self):
112
165
        try:
117
170
        else:
118
171
            self.fail("expected error not raised")
119
172
 
 
173
    def assertLogStartsWith(self, log, string):
 
174
        """Like assertStartsWith, but skips the log timestamp."""
 
175
        self.assertContainsRe(log,
 
176
            '^\\d+\\.\\d+  ' + re.escape(string))
 
177
 
120
178
    def test_mutter_callsite_1(self):
121
179
        """mutter_callsite can capture 1 level of stack frame."""
122
180
        mutter_callsite(1, "foo %s", "a string")
123
 
        log = self._get_log(keep_log_file=True)
 
181
        log = self.get_log()
124
182
        # begin with the message
125
 
        self.assertStartsWith(log, 'foo a string\nCalled from:\n')
 
183
        self.assertLogStartsWith(log, 'foo a string\nCalled from:\n')
126
184
        # should show two frame: this frame and the one above
127
185
        self.assertContainsRe(log,
128
 
            'test_trace\.py", line \d+, in test_mutter_callsite_1\n')
 
186
            'test_trace\\.py", line \\d+, in test_mutter_callsite_1\n')
129
187
        # this frame should be the final one
130
188
        self.assertEndsWith(log, ' "a string")\n')
131
189
 
132
190
    def test_mutter_callsite_2(self):
133
191
        """mutter_callsite can capture 2 levels of stack frame."""
134
192
        mutter_callsite(2, "foo %s", "a string")
135
 
        log = self._get_log(keep_log_file=True)
 
193
        log = self.get_log()
136
194
        # begin with the message
137
 
        self.assertStartsWith(log, 'foo a string\nCalled from:\n')
 
195
        self.assertLogStartsWith(log, 'foo a string\nCalled from:\n')
138
196
        # should show two frame: this frame and the one above
139
197
        self.assertContainsRe(log,
140
198
            'test_trace.py", line \d+, in test_mutter_callsite_2\n')
144
202
    def test_mutter_never_fails(self):
145
203
        # Even if the decode/encode stage fails, mutter should not
146
204
        # raise an exception
 
205
        # This test checks that mutter doesn't fail; the current behaviour
 
206
        # is that it doesn't fail *and writes non-utf8*.
147
207
        mutter(u'Writing a greek mu (\xb5) works in a unicode string')
148
208
        mutter('But fails in an ascii string \xb5')
149
209
        mutter('and in an ascii argument: %s', '\xb5')
150
 
        log = self._get_log(keep_log_file=True)
 
210
        log = self.get_log()
151
211
        self.assertContainsRe(log, 'Writing a greek mu')
152
212
        self.assertContainsRe(log, "But fails in an ascii string")
153
 
        self.assertContainsRe(log, u"ascii argument: \xb5")
 
213
        # However, the log content object does unicode replacement on reading
 
214
        # to let it get unicode back where good data has been written. So we
 
215
        # have to do a replaceent here as well.
 
216
        self.assertContainsRe(log, "ascii argument: \xb5".decode('utf8',
 
217
            'replace'))
 
218
 
 
219
    def test_push_log_file(self):
 
220
        """Can push and pop log file, and this catches mutter messages.
 
221
 
 
222
        This is primarily for use in the test framework.
 
223
        """
 
224
        tmp1 = tempfile.NamedTemporaryFile()
 
225
        tmp2 = tempfile.NamedTemporaryFile()
 
226
        try:
 
227
            memento1 = push_log_file(tmp1)
 
228
            mutter("comment to file1")
 
229
            try:
 
230
                memento2 = push_log_file(tmp2)
 
231
                try:
 
232
                    mutter("comment to file2")
 
233
                finally:
 
234
                    pop_log_file(memento2)
 
235
                mutter("again to file1")
 
236
            finally:
 
237
                pop_log_file(memento1)
 
238
            # the files were opened in binary mode, so should have exactly
 
239
            # these bytes.  and removing the file as the log target should
 
240
            # have caused them to be flushed out.  need to match using regexps
 
241
            # as there's a timestamp at the front.
 
242
            tmp1.seek(0)
 
243
            self.assertContainsRe(tmp1.read(),
 
244
                r"\d+\.\d+  comment to file1\n\d+\.\d+  again to file1\n")
 
245
            tmp2.seek(0)
 
246
            self.assertContainsRe(tmp2.read(),
 
247
                r"\d+\.\d+  comment to file2\n")
 
248
        finally:
 
249
            tmp1.close()
 
250
            tmp2.close()
 
251
 
 
252
    def test__open_bzr_log_uses_stderr_for_failures(self):
 
253
        # If _open_bzr_log cannot open the file, then we should write the
 
254
        # warning to stderr. Since this is normally happening before logging is
 
255
        # set up.
 
256
        self.overrideAttr(sys, 'stderr', StringIO())
 
257
        # Set the log file to something that cannot exist
 
258
        # FIXME: A bit dangerous: we are not in an isolated dir here -- vilajam
 
259
        # 20100125
 
260
        os.environ['BZR_LOG'] = os.getcwd() + '/no-dir/bzr.log'
 
261
        self.overrideAttr(trace, '_bzr_log_filename')
 
262
        logf = trace._open_bzr_log()
 
263
        self.assertIs(None, logf)
 
264
        self.assertContainsRe(sys.stderr.getvalue(),
 
265
                              'failed to open trace file: .*/no-dir/bzr.log')
154
266
 
155
267
 
156
268
class TestVerbosityLevel(TestCase):
182
294
    def test_log_rollover(self):
183
295
        temp_log_name = 'test-log'
184
296
        trace_file = open(temp_log_name, 'at')
185
 
        trace_file.write('test_log_rollover padding\n' * 1000000)
 
297
        trace_file.writelines(['test_log_rollover padding\n'] * 200000)
186
298
        trace_file.close()
187
299
        _rollover_trace_maybe(temp_log_name)
188
300
        # should have been rolled over