~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_trace.py

  • Committer: Wouter van Heyst
  • Date: 2006-07-11 01:14:17 UTC
  • mto: This revision was merged to the branch mainline in revision 1852.
  • Revision ID: larstiq@larstiq.dyndns.org-20060711011417-67a3cc31542a448f
test mv more rigorously

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# Copyright (C) 2005, 2006, 2007, 2008, 2009 Canonical Ltd
 
1
# Copyright (C) 2005, 2006 by 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
17
17
# "weren't nothing promised to you.  do i look like i got a promise face?"
18
18
 
19
19
"""Tests for trace library"""
20
20
 
21
 
from cStringIO import StringIO
22
21
import errno
23
22
import os
24
 
import re
25
23
import sys
26
 
import tempfile
 
24
from StringIO import StringIO
27
25
 
28
 
from bzrlib import (
29
 
    errors,
30
 
    )
31
26
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
 
    )
 
27
from bzrlib.trace import mutter, report_exception
 
28
from bzrlib.errors import NotBranchError
39
29
 
40
30
 
41
31
def _format_exception():
48
38
class TestTrace(TestCase):
49
39
 
50
40
    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
41
        try:
56
42
            raise NotImplementedError, "time travel"
57
43
        except NotImplementedError:
60
46
        self.assertEqualDiff(err.splitlines()[0],
61
47
                'bzr: ERROR: exceptions.NotImplementedError: time travel')
62
48
        self.assertContainsRe(err,
63
 
            'Bazaar has encountered an internal error.')
 
49
                r'File.*test_trace.py')
64
50
 
65
51
    def test_format_interrupt_exception(self):
66
52
        try:
72
58
        self.assertTrue(len(msg) > 0)
73
59
        self.assertEqualDiff(msg, 'bzr: interrupted\n')
74
60
 
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
61
    def test_format_os_error(self):
85
62
        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
63
            file('nosuchfile22222')
96
 
        except IOError:
 
64
        except (OSError, IOError):
97
65
            pass
98
66
        msg = _format_exception()
99
67
        self.assertContainsRe(msg, r'^bzr: ERROR: \[Errno .*\] No such file.*nosuchfile')
100
68
 
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
69
 
108
70
    def test_format_exception(self):
109
71
        """Short formatting of bzr exceptions"""
110
72
        try:
111
 
            raise errors.NotBranchError('wibble')
112
 
        except errors.NotBranchError:
 
73
            raise NotBranchError, 'wibble'
 
74
        except NotBranchError:
113
75
            pass
114
76
        msg = _format_exception()
115
77
        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')
 
78
        self.assertEqualDiff(msg, 'bzr: ERROR: Not a branch: wibble\n')
139
79
 
140
80
    def test_trace_unicode(self):
141
81
        """Write Unicode to trace log"""
142
82
        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')
 
83
        self.assertContainsRe('the unicode character',
 
84
                self._get_log())
158
85
 
159
86
    def test_report_broken_pipe(self):
160
87
        try:
165
92
        else:
166
93
            self.fail("expected error not raised")
167
94
 
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
95
    def test_mutter_never_fails(self):
198
96
        # Even if the decode/encode stage fails, mutter should not
199
97
        # raise an exception
200
98
        mutter(u'Writing a greek mu (\xb5) works in a unicode string')
201
99
        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)
 
100
        # TODO: jam 20051227 mutter() doesn't flush the log file, and
 
101
        #       self._get_log() opens the file directly and reads it.
 
102
        #       So we need to manually flush the log file
 
103
        import bzrlib.trace
 
104
        bzrlib.trace._trace_file.flush()
 
105
        log = self._get_log()
204
106
        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))
 
107
        self.assertContainsRe(log, 'UnicodeError')
 
108
        self.assertContainsRe(log, "'But fails in an ascii string")