~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_trace.py

  • Committer: Aaron Bentley
  • Date: 2007-12-20 20:44:45 UTC
  • mto: This revision was merged to the branch mainline in revision 3235.
  • Revision ID: abentley@panoramicfeedback.com-20071220204445-9o2f10gvvd8e4rks
Implement hard-link support for branch and checkout

Show diffs side-by-side

added added

removed removed

Lines of Context:
 
1
# Copyright (C) 2005, 2006, 2007 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 sys
 
25
 
 
26
from bzrlib import (
 
27
    errors,
 
28
    )
 
29
from bzrlib.tests import TestCaseInTempDir, TestCase
 
30
from bzrlib.trace import (
 
31
    mutter, mutter_callsite, report_exception,
 
32
    set_verbosity_level, get_verbosity_level, is_quiet, is_verbose, be_quiet,
 
33
    _rollover_trace_maybe,
 
34
    )
 
35
 
 
36
 
 
37
def _format_exception():
 
38
    """Format an exception as it would normally be displayed to the user"""
 
39
    buf = StringIO()
 
40
    report_exception(sys.exc_info(), buf)
 
41
    return buf.getvalue()
 
42
 
 
43
 
 
44
class TestTrace(TestCase):
 
45
 
 
46
    def test_format_sys_exception(self):
 
47
        try:
 
48
            raise NotImplementedError, "time travel"
 
49
        except NotImplementedError:
 
50
            pass
 
51
        err = _format_exception()
 
52
        self.assertEqualDiff(err.splitlines()[0],
 
53
                'bzr: ERROR: exceptions.NotImplementedError: time travel')
 
54
        self.assertContainsRe(err,
 
55
                r'File.*test_trace.py')
 
56
 
 
57
    def test_format_interrupt_exception(self):
 
58
        try:
 
59
            raise KeyboardInterrupt()
 
60
        except KeyboardInterrupt:
 
61
            # XXX: Some risk that a *real* keyboard interrupt won't be seen
 
62
            pass
 
63
        msg = _format_exception()
 
64
        self.assertTrue(len(msg) > 0)
 
65
        self.assertEqualDiff(msg, 'bzr: interrupted\n')
 
66
 
 
67
    def test_format_os_error(self):
 
68
        try:
 
69
            file('nosuchfile22222')
 
70
        except (OSError, IOError):
 
71
            pass
 
72
        msg = _format_exception()
 
73
        self.assertContainsRe(msg, r'^bzr: ERROR: \[Errno .*\] No such file.*nosuchfile')
 
74
 
 
75
    def test_format_unicode_error(self):
 
76
        try:
 
77
            raise errors.BzrCommandError(u'argument foo\xb5 does not exist')
 
78
        except errors.BzrCommandError:
 
79
            pass
 
80
        msg = _format_exception()
 
81
 
 
82
    def test_format_exception(self):
 
83
        """Short formatting of bzr exceptions"""
 
84
        try:
 
85
            raise errors.NotBranchError('wibble')
 
86
        except errors.NotBranchError:
 
87
            pass
 
88
        msg = _format_exception()
 
89
        self.assertTrue(len(msg) > 0)
 
90
        self.assertEqualDiff(msg, 'bzr: ERROR: Not a branch: \"wibble\".\n')
 
91
 
 
92
    def test_trace_unicode(self):
 
93
        """Write Unicode to trace log"""
 
94
        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
    
 
98
    def test_trace_argument_unicode(self):
 
99
        """Write a Unicode argument to the trace log"""
 
100
        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')
 
103
 
 
104
    def test_trace_argument_utf8(self):
 
105
        """Write a Unicode argument to the trace log"""
 
106
        mutter(u'the unicode character for benzene is %s',
 
107
               u'\N{BENZENE RING}'.encode('utf-8'))
 
108
        self.assertContainsRe(self._get_log(keep_log_file=True),
 
109
                              'the unicode character')
 
110
 
 
111
    def test_report_broken_pipe(self):
 
112
        try:
 
113
            raise IOError(errno.EPIPE, 'broken pipe foofofo')
 
114
        except IOError, e:
 
115
            msg = _format_exception()
 
116
            self.assertEquals(msg, "bzr: broken pipe\n")
 
117
        else:
 
118
            self.fail("expected error not raised")
 
119
 
 
120
    def test_mutter_callsite_1(self):
 
121
        """mutter_callsite can capture 1 level of stack frame."""
 
122
        mutter_callsite(1, "foo %s", "a string")
 
123
        log = self._get_log(keep_log_file=True)
 
124
        # begin with the message
 
125
        self.assertStartsWith(log, 'foo a string\nCalled from:\n')
 
126
        # should show two frame: this frame and the one above
 
127
        self.assertContainsRe(log,
 
128
            'test_trace\.py", line \d+, in test_mutter_callsite_1\n')
 
129
        # this frame should be the final one
 
130
        self.assertEndsWith(log, ' "a string")\n')
 
131
 
 
132
    def test_mutter_callsite_2(self):
 
133
        """mutter_callsite can capture 2 levels of stack frame."""
 
134
        mutter_callsite(2, "foo %s", "a string")
 
135
        log = self._get_log(keep_log_file=True)
 
136
        # begin with the message
 
137
        self.assertStartsWith(log, 'foo a string\nCalled from:\n')
 
138
        # should show two frame: this frame and the one above
 
139
        self.assertContainsRe(log,
 
140
            'test_trace.py", line \d+, in test_mutter_callsite_2\n')
 
141
        # this frame should be the final one
 
142
        self.assertEndsWith(log, ' "a string")\n')
 
143
 
 
144
    def test_mutter_never_fails(self):
 
145
        # Even if the decode/encode stage fails, mutter should not
 
146
        # raise an exception
 
147
        mutter(u'Writing a greek mu (\xb5) works in a unicode string')
 
148
        mutter('But fails in an ascii string \xb5')
 
149
        mutter('and in an ascii argument: %s', '\xb5')
 
150
        log = self._get_log(keep_log_file=True)
 
151
        self.assertContainsRe(log, 'Writing a greek mu')
 
152
        self.assertContainsRe(log, "But fails in an ascii string")
 
153
        self.assertContainsRe(log, u"ascii argument: \xb5")
 
154
 
 
155
 
 
156
class TestVerbosityLevel(TestCase):
 
157
 
 
158
    def test_verbosity_level(self):
 
159
        set_verbosity_level(1)
 
160
        self.assertEqual(1, get_verbosity_level())
 
161
        self.assertTrue(is_verbose())
 
162
        self.assertFalse(is_quiet())
 
163
        set_verbosity_level(-1)
 
164
        self.assertEqual(-1, get_verbosity_level())
 
165
        self.assertFalse(is_verbose())
 
166
        self.assertTrue(is_quiet())
 
167
        set_verbosity_level(0)
 
168
        self.assertEqual(0, get_verbosity_level())
 
169
        self.assertFalse(is_verbose())
 
170
        self.assertFalse(is_quiet())
 
171
 
 
172
    def test_be_quiet(self):
 
173
        # Confirm the old API still works
 
174
        be_quiet(True)
 
175
        self.assertEqual(-1, get_verbosity_level())
 
176
        be_quiet(False)
 
177
        self.assertEqual(0, get_verbosity_level())
 
178
 
 
179
 
 
180
class TestBzrLog(TestCaseInTempDir):
 
181
 
 
182
    def test_log_rollover(self):
 
183
        temp_log_name = 'test-log'
 
184
        trace_file = open(temp_log_name, 'at')
 
185
        trace_file.write('test_log_rollover padding\n' * 1000000)
 
186
        trace_file.close()
 
187
        _rollover_trace_maybe(temp_log_name)
 
188
        # should have been rolled over
 
189
        self.assertFalse(os.access(temp_log_name, os.R_OK))