/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_trace.py

  • Committer: John Arbash Meinel
  • Date: 2009-07-31 17:42:29 UTC
  • mto: This revision was merged to the branch mainline in revision 4611.
  • Revision ID: john@arbash-meinel.com-20090731174229-w2zdsdlfpeddk8gl
Now we got to the per-workingtree tests, etc.

The main causes seem to break down into:
  bzrdir.clone() is known to be broken wrt locking, this effects
  everything that tries to 'push'

  shelf code is not compatible with strict locking

  merge code seems to have an issue. This might actually be the
  root cause of the clone() problems.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_trace.py
1
 
# Copyright (C) 2005-2010 Canonical Ltd
 
1
# Copyright (C) 2005, 2006, 2007, 2008 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
27
27
 
28
28
from bzrlib import (
29
29
    errors,
30
 
    trace,
31
30
    )
32
31
from bzrlib.tests import TestCaseInTempDir, TestCase
33
32
from bzrlib.trace import (
36
35
    pop_log_file,
37
36
    push_log_file,
38
37
    _rollover_trace_maybe,
39
 
    show_error,
40
38
    )
41
39
 
42
40
 
50
48
class TestTrace(TestCase):
51
49
 
52
50
    def test_format_sys_exception(self):
53
 
        # Test handling of an internal/unexpected error that probably
54
 
        # indicates a bug in bzr.  The details of the message may vary
55
 
        # depending on whether apport is available or not.  See test_crash for
56
 
        # more.
57
51
        try:
58
52
            raise NotImplementedError, "time travel"
59
53
        except NotImplementedError:
62
56
        self.assertEqualDiff(err.splitlines()[0],
63
57
                'bzr: ERROR: exceptions.NotImplementedError: time travel')
64
58
        self.assertContainsRe(err,
65
 
            'Bazaar has encountered an internal error.')
 
59
                r'File.*test_trace.py')
66
60
 
67
61
    def test_format_interrupt_exception(self):
68
62
        try:
74
68
        self.assertTrue(len(msg) > 0)
75
69
        self.assertEqualDiff(msg, 'bzr: interrupted\n')
76
70
 
77
 
    def test_format_memory_error(self):
78
 
        try:
79
 
            raise MemoryError()
80
 
        except MemoryError:
81
 
            pass
82
 
        msg = _format_exception()
83
 
        self.assertEquals(msg,
84
 
            "bzr: out of memory\n")
85
 
 
86
71
    def test_format_os_error(self):
87
72
        try:
88
73
            os.rmdir('nosuchfile22222')
89
 
        except OSError, e:
90
 
            e_str = str(e)
 
74
        except OSError:
 
75
            pass
91
76
        msg = _format_exception()
92
 
        # Linux seems to give "No such file" but Windows gives "The system
93
 
        # cannot find the file specified".
94
 
        self.assertEqual('bzr: ERROR: %s\n' % (e_str,), msg)
 
77
        self.assertContainsRe(msg,
 
78
            r'^bzr: ERROR: \[Errno .*\] No such file.*nosuchfile22222')
95
79
 
96
80
    def test_format_io_error(self):
97
81
        try:
99
83
        except IOError:
100
84
            pass
101
85
        msg = _format_exception()
102
 
        # Even though Windows and Linux differ for 'os.rmdir', they both give
103
 
        # 'No such file' for open()
104
 
        self.assertContainsRe(msg,
105
 
            r'^bzr: ERROR: \[Errno .*\] No such file.*nosuchfile')
 
86
        self.assertContainsRe(msg, r'^bzr: ERROR: \[Errno .*\] No such file.*nosuchfile')
106
87
 
107
88
    def test_format_unicode_error(self):
108
89
        try:
141
122
            pass
142
123
        msg = _format_exception()
143
124
        self.assertContainsRe(msg,
144
 
            r'Bazaar has encountered an internal error')
 
125
            r"Traceback \(most recent call last\)")
145
126
 
146
127
    def test_trace_unicode(self):
147
128
        """Write Unicode to trace log"""
148
129
        self.log(u'the unicode character for benzene is \N{BENZENE RING}')
149
 
        log = self.get_log()
150
 
        self.assertContainsRe(log, "the unicode character for benzene is")
 
130
        self.assertContainsRe(self._get_log(keep_log_file=True),
 
131
                              "the unicode character for benzene is")
151
132
 
152
133
    def test_trace_argument_unicode(self):
153
134
        """Write a Unicode argument to the trace log"""
154
135
        mutter(u'the unicode character for benzene is %s', u'\N{BENZENE RING}')
155
 
        log = self.get_log()
156
 
        self.assertContainsRe(log, 'the unicode character')
 
136
        self.assertContainsRe(self._get_log(keep_log_file=True),
 
137
                              'the unicode character')
157
138
 
158
139
    def test_trace_argument_utf8(self):
159
140
        """Write a Unicode argument to the trace log"""
160
141
        mutter(u'the unicode character for benzene is %s',
161
142
               u'\N{BENZENE RING}'.encode('utf-8'))
162
 
        log = self.get_log()
163
 
        self.assertContainsRe(log, 'the unicode character')
 
143
        self.assertContainsRe(self._get_log(keep_log_file=True),
 
144
                              'the unicode character')
164
145
 
165
146
    def test_report_broken_pipe(self):
166
147
        try:
179
160
    def test_mutter_callsite_1(self):
180
161
        """mutter_callsite can capture 1 level of stack frame."""
181
162
        mutter_callsite(1, "foo %s", "a string")
182
 
        log = self.get_log()
 
163
        log = self._get_log(keep_log_file=True)
183
164
        # begin with the message
184
165
        self.assertLogStartsWith(log, 'foo a string\nCalled from:\n')
185
166
        # should show two frame: this frame and the one above
191
172
    def test_mutter_callsite_2(self):
192
173
        """mutter_callsite can capture 2 levels of stack frame."""
193
174
        mutter_callsite(2, "foo %s", "a string")
194
 
        log = self.get_log()
 
175
        log = self._get_log(keep_log_file=True)
195
176
        # begin with the message
196
177
        self.assertLogStartsWith(log, 'foo a string\nCalled from:\n')
197
178
        # should show two frame: this frame and the one above
203
184
    def test_mutter_never_fails(self):
204
185
        # Even if the decode/encode stage fails, mutter should not
205
186
        # raise an exception
206
 
        # This test checks that mutter doesn't fail; the current behaviour
207
 
        # is that it doesn't fail *and writes non-utf8*.
208
187
        mutter(u'Writing a greek mu (\xb5) works in a unicode string')
209
188
        mutter('But fails in an ascii string \xb5')
210
189
        mutter('and in an ascii argument: %s', '\xb5')
211
 
        log = self.get_log()
 
190
        log = self._get_log(keep_log_file=True)
212
191
        self.assertContainsRe(log, 'Writing a greek mu')
213
192
        self.assertContainsRe(log, "But fails in an ascii string")
214
 
        # However, the log content object does unicode replacement on reading
215
 
        # to let it get unicode back where good data has been written. So we
216
 
        # have to do a replaceent here as well.
217
 
        self.assertContainsRe(log, "ascii argument: \xb5".decode('utf8',
218
 
            'replace'))
219
 
        
220
 
    def test_show_error(self):
221
 
        show_error('error1')
222
 
        show_error(u'error2 \xb5 blah')
223
 
        show_error('arg: %s', 'blah')
224
 
        show_error('arg2: %(key)s', {'key':'stuff'})
225
 
        try:
226
 
            raise Exception("oops")
227
 
        except:
228
 
            show_error('kwarg', exc_info=True)
229
 
        log = self.get_log()
230
 
        self.assertContainsRe(log, 'error1')
231
 
        self.assertContainsRe(log, u'error2 \xb5 blah')
232
 
        self.assertContainsRe(log, 'arg: blah')
233
 
        self.assertContainsRe(log, 'arg2: stuff')
234
 
        self.assertContainsRe(log, 'kwarg')
235
 
        self.assertContainsRe(log, 'Traceback \\(most recent call last\\):')
236
 
        self.assertContainsRe(log, 'File ".*test_trace.py", line .*, in test_show_error')
237
 
        self.assertContainsRe(log, 'raise Exception\\("oops"\\)')
238
 
        self.assertContainsRe(log, 'Exception: oops')
 
193
        self.assertContainsRe(log, u"ascii argument: \xb5")
239
194
 
240
195
    def test_push_log_file(self):
241
196
        """Can push and pop log file, and this catches mutter messages.
270
225
            tmp1.close()
271
226
            tmp2.close()
272
227
 
273
 
    def test__open_bzr_log_uses_stderr_for_failures(self):
274
 
        # If _open_bzr_log cannot open the file, then we should write the
275
 
        # warning to stderr. Since this is normally happening before logging is
276
 
        # set up.
277
 
        self.overrideAttr(sys, 'stderr', StringIO())
278
 
        # Set the log file to something that cannot exist
279
 
        # FIXME: A bit dangerous: we are not in an isolated dir here -- vilajam
280
 
        # 20100125
281
 
        os.environ['BZR_LOG'] = os.getcwd() + '/no-dir/bzr.log'
282
 
        self.overrideAttr(trace, '_bzr_log_filename')
283
 
        logf = trace._open_bzr_log()
284
 
        self.assertIs(None, logf)
285
 
        self.assertContainsRe(sys.stderr.getvalue(),
286
 
                              'failed to open trace file: .*/no-dir/bzr.log')
287
 
 
288
228
 
289
229
class TestVerbosityLevel(TestCase):
290
230
 
315
255
    def test_log_rollover(self):
316
256
        temp_log_name = 'test-log'
317
257
        trace_file = open(temp_log_name, 'at')
318
 
        trace_file.writelines(['test_log_rollover padding\n'] * 200000)
 
258
        trace_file.write('test_log_rollover padding\n' * 1000000)
319
259
        trace_file.close()
320
260
        _rollover_trace_maybe(temp_log_name)
321
261
        # should have been rolled over