~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_trace.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2006-08-17 07:52:09 UTC
  • mfrom: (1910.3.4 trivial)
  • Revision ID: pqm@pqm.ubuntu.com-20060817075209-e85a1f9e05ff8b87
(andrew) Trivial fixes to NotImplemented errors.

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# Copyright (C) 2005, 2006, 2007 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
18
18
 
19
19
"""Tests for trace library"""
20
20
 
21
 
from cStringIO import StringIO
22
21
import errno
23
22
import os
24
23
import sys
 
24
from StringIO import StringIO
25
25
 
26
 
from bzrlib import (
27
 
    errors,
28
 
    )
29
26
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
 
    )
 
27
from bzrlib.trace import mutter, report_exception
 
28
from bzrlib.errors import NotBranchError
35
29
 
36
30
 
37
31
def _format_exception():
72
66
        msg = _format_exception()
73
67
        self.assertContainsRe(msg, r'^bzr: ERROR: \[Errno .*\] No such file.*nosuchfile')
74
68
 
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
69
 
82
70
    def test_format_exception(self):
83
71
        """Short formatting of bzr exceptions"""
84
72
        try:
85
 
            raise errors.NotBranchError('wibble')
86
 
        except errors.NotBranchError:
 
73
            raise NotBranchError, 'wibble'
 
74
        except NotBranchError:
87
75
            pass
88
76
        msg = _format_exception()
89
77
        self.assertTrue(len(msg) > 0)
90
 
        self.assertEqualDiff(msg, 'bzr: ERROR: Not a branch: \"wibble\".\n')
 
78
        self.assertEqualDiff(msg, 'bzr: ERROR: Not a branch: wibble\n')
91
79
 
92
80
    def test_trace_unicode(self):
93
81
        """Write Unicode to trace log"""
94
82
        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')
 
83
        self.assertContainsRe('the unicode character',
 
84
                self._get_log())
110
85
 
111
86
    def test_report_broken_pipe(self):
112
87
        try:
117
92
        else:
118
93
            self.fail("expected error not raised")
119
94
 
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
95
    def test_mutter_never_fails(self):
145
96
        # Even if the decode/encode stage fails, mutter should not
146
97
        # raise an exception
147
98
        mutter(u'Writing a greek mu (\xb5) works in a unicode string')
148
99
        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)
 
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()
151
106
        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))
 
107
        self.assertContainsRe(log, 'UnicodeError')
 
108
        self.assertContainsRe(log, "'But fails in an ascii string")