/breezy/unstable

To get this branch, use:
bzr branch https://code.breezy-vcs.org/breezy/unstable

« back to all changes in this revision

Viewing changes to breezy/tests/test_trace.py

  • Committer: Jelmer Vernooij
  • Date: 2017-05-24 01:39:33 UTC
  • mfrom: (3815.3776.6)
  • Revision ID: jelmer@jelmer.uk-20170524013933-ir4y4tqtrsiz2ka2
New upstream snapshot.

Show diffs side-by-side

added added

removed removed

Lines of Context:
18
18
 
19
19
"""Tests for trace library"""
20
20
 
21
 
from cStringIO import StringIO
22
21
import errno
23
22
import logging
24
23
import os
26
25
import sys
27
26
import tempfile
28
27
 
29
 
from bzrlib import (
 
28
from .. import (
30
29
    debug,
31
30
    errors,
32
31
    trace,
33
32
    )
34
 
from bzrlib.tests import features, TestCaseInTempDir, TestCase
35
 
from bzrlib.trace import (
 
33
from ..sixish import (
 
34
    BytesIO,
 
35
    )
 
36
from . import features, TestCaseInTempDir, TestCase
 
37
from ..trace import (
36
38
    mutter, mutter_callsite, report_exception,
37
39
    set_verbosity_level, get_verbosity_level, is_quiet, is_verbose, be_quiet,
38
40
    pop_log_file,
44
46
 
45
47
def _format_exception():
46
48
    """Format an exception as it would normally be displayed to the user"""
47
 
    buf = StringIO()
 
49
    buf = BytesIO()
48
50
    report_exception(sys.exc_info(), buf)
49
51
    return buf.getvalue()
50
52
 
53
55
 
54
56
    def test_format_sys_exception(self):
55
57
        # Test handling of an internal/unexpected error that probably
56
 
        # indicates a bug in bzr.  The details of the message may vary
 
58
        # indicates a bug in brz.  The details of the message may vary
57
59
        # depending on whether apport is available or not.  See test_crash for
58
60
        # more.
59
61
        try:
60
 
            raise NotImplementedError, "time travel"
 
62
            raise NotImplementedError("time travel")
61
63
        except NotImplementedError:
62
64
            pass
63
65
        err = _format_exception()
64
66
        self.assertEqualDiff(err.splitlines()[0],
65
 
                'bzr: ERROR: exceptions.NotImplementedError: time travel')
 
67
                'brz: ERROR: exceptions.NotImplementedError: time travel')
66
68
        self.assertContainsRe(err,
67
69
            'Bazaar has encountered an internal error.')
68
70
 
74
76
            pass
75
77
        msg = _format_exception()
76
78
        self.assertTrue(len(msg) > 0)
77
 
        self.assertEqualDiff(msg, 'bzr: interrupted\n')
 
79
        self.assertEqualDiff(msg, 'brz: interrupted\n')
78
80
 
79
81
    def test_format_memory_error(self):
80
82
        try:
83
85
            pass
84
86
        msg = _format_exception()
85
87
        self.assertEqual(msg,
86
 
            "bzr: out of memory\nUse -Dmem_dump to dump memory to a file.\n")
 
88
            "brz: out of memory\nUse -Dmem_dump to dump memory to a file.\n")
87
89
 
88
90
    def test_format_mem_dump(self):
89
91
        self.requireFeature(features.meliae)
94
96
            pass
95
97
        msg = _format_exception()
96
98
        self.assertStartsWith(msg,
97
 
            "bzr: out of memory\nMemory dumped to ")
 
99
            "brz: out of memory\nMemory dumped to ")
98
100
 
99
101
    def test_format_os_error(self):
100
102
        try:
101
103
            os.rmdir('nosuchfile22222')
102
 
        except OSError, e:
 
104
        except OSError as e:
103
105
            e_str = str(e)
104
106
        msg = _format_exception()
105
107
        # Linux seems to give "No such file" but Windows gives "The system
106
108
        # cannot find the file specified".
107
 
        self.assertEqual('bzr: ERROR: %s\n' % (e_str,), msg)
 
109
        self.assertEqual('brz: ERROR: %s\n' % (e_str,), msg)
108
110
 
109
111
    def test_format_io_error(self):
110
112
        try:
116
118
        # 'No such file' for open()
117
119
        # However it now gets translated so we can not test for a specific message
118
120
        self.assertContainsRe(msg,
119
 
            r'^bzr: ERROR: \[Errno .*\] .*nosuchfile')
 
121
            r'^brz: ERROR: \[Errno .*\] .*nosuchfile')
120
122
 
121
123
    def test_format_pywintypes_error(self):
122
124
        self.requireFeature(features.pywintypes)
129
131
        # GZ 2010-05-03: Formatting for pywintypes.error is basic, a 3-tuple
130
132
        #                with errno, function name, and locale error message
131
133
        self.assertContainsRe(msg,
132
 
            r"^bzr: ERROR: \(2, 'RemoveDirectory[AW]?', .*\)")
 
134
            r"^brz: ERROR: \(2, 'RemoveDirectory[AW]?', .*\)")
133
135
            
134
136
    def test_format_sockets_error(self):
135
137
        try:
151
153
        msg = _format_exception()
152
154
 
153
155
    def test_format_exception(self):
154
 
        """Short formatting of bzr exceptions"""
 
156
        """Short formatting of brz exceptions"""
155
157
        try:
156
158
            raise errors.NotBranchError('wibble')
157
159
        except errors.NotBranchError:
158
160
            pass
159
161
        msg = _format_exception()
160
162
        self.assertTrue(len(msg) > 0)
161
 
        self.assertEqualDiff(msg, 'bzr: ERROR: Not a branch: \"wibble\".\n')
 
163
        self.assertEqualDiff(msg, 'brz: ERROR: Not a branch: \"wibble\".\n')
162
164
 
163
165
    def test_report_external_import_error(self):
164
166
        """Short friendly message for missing system modules."""
165
167
        try:
166
168
            import ImaginaryModule
167
 
        except ImportError, e:
 
169
        except ImportError as e:
168
170
            pass
169
171
        else:
170
172
            self.fail("somehow succeeded in importing %r" % ImaginaryModule)
171
173
        msg = _format_exception()
172
174
        self.assertEqual(msg,
173
 
            'bzr: ERROR: No module named ImaginaryModule\n'
 
175
            'brz: ERROR: No module named ImaginaryModule\n'
174
176
            'You may need to install this Python library separately.\n')
175
177
 
176
178
    def test_report_import_syntax_error(self):
177
179
        try:
178
180
            raise ImportError("syntax error")
179
 
        except ImportError, e:
 
181
        except ImportError as e:
180
182
            pass
181
183
        msg = _format_exception()
182
184
        self.assertContainsRe(msg,
206
208
            raise IOError(errno.EPIPE, 'broken pipe foofofo')
207
209
        except IOError as e:
208
210
            msg = _format_exception()
209
 
            self.assertEqual(msg, "bzr: broken pipe\n")
 
211
            self.assertEqual(msg, "brz: broken pipe\n")
210
212
        else:
211
213
            self.fail("expected error not raised")
212
214
 
309
311
            tmp1.close()
310
312
            tmp2.close()
311
313
 
312
 
    def test__open_bzr_log_uses_stderr_for_failures(self):
313
 
        # If _open_bzr_log cannot open the file, then we should write the
 
314
    def test__open_brz_log_uses_stderr_for_failures(self):
 
315
        # If _open_brz_log cannot open the file, then we should write the
314
316
        # warning to stderr. Since this is normally happening before logging is
315
317
        # set up.
316
 
        self.overrideAttr(sys, 'stderr', StringIO())
 
318
        self.overrideAttr(sys, 'stderr', BytesIO())
317
319
        # Set the log file to something that cannot exist
318
 
        self.overrideEnv('BZR_LOG', os.getcwd() + '/no-dir/bzr.log')
319
 
        self.overrideAttr(trace, '_bzr_log_filename')
320
 
        logf = trace._open_bzr_log()
 
320
        self.overrideEnv('BRZ_LOG', '/no-such-dir/brz.log')
 
321
        self.overrideAttr(trace, '_brz_log_filename')
 
322
        logf = trace._open_brz_log()
321
323
        self.assertIs(None, logf)
322
 
        self.assertContainsRe(sys.stderr.getvalue(),
323
 
                              'failed to open trace file: .*/no-dir/bzr.log')
 
324
        self.assertContainsRe(
 
325
            sys.stderr.getvalue(),
 
326
            "failed to open trace file: .* '/no-such-dir/brz.log'$")
324
327
 
325
328
 
326
329
class TestVerbosityLevel(TestCase):
359
362
        self.assertEqual(" WARNING  Warned\n", self.get_log())
360
363
 
361
364
    def test_log(self):
362
 
        logging.getLogger("bzr").error("Errored")
 
365
        logging.getLogger("brz").error("Errored")
363
366
        self.assertEqual("   ERROR  Errored\n", self.get_log())
364
367
 
365
368
    def test_log_sub(self):
366
 
        logging.getLogger("bzr.test_log_sub").debug("Whispered")
 
369
        logging.getLogger("brz.test_log_sub").debug("Whispered")
367
370
        self.assertEqual("   DEBUG  Whispered\n", self.get_log())
368
371
 
369
372
    def test_log_unicode_msg(self):
370
 
        logging.getLogger("bzr").debug(u"\xa7")
 
373
        logging.getLogger("brz").debug(u"\xa7")
371
374
        self.assertEqual(u"   DEBUG  \xa7\n", self.get_log())
372
375
 
373
376
    def test_log_unicode_arg(self):
374
 
        logging.getLogger("bzr").debug("%s", u"\xa7")
 
377
        logging.getLogger("brz").debug("%s", u"\xa7")
375
378
        self.assertEqual(u"   DEBUG  \xa7\n", self.get_log())
376
379
 
377
380
    def test_log_utf8_msg(self):
378
 
        logging.getLogger("bzr").debug("\xc2\xa7")
 
381
        logging.getLogger("brz").debug("\xc2\xa7")
379
382
        self.assertEqual(u"   DEBUG  \xa7\n", self.get_log())
380
383
 
381
384
    def test_log_utf8_arg(self):
382
 
        logging.getLogger("bzr").debug("%s", "\xc2\xa7")
 
385
        logging.getLogger("brz").debug("%s", "\xc2\xa7")
383
386
        self.assertEqual(u"   DEBUG  \xa7\n", self.get_log())
384
387
 
385
388
    def test_log_bytes_msg(self):
386
 
        logging.getLogger("bzr").debug("\xa7")
 
389
        logging.getLogger("brz").debug("\xa7")
387
390
        log = self.get_log()
388
391
        self.assertContainsString(log, "UnicodeDecodeError: ")
389
392
        self.assertContainsString(log,
390
393
            "Logging record unformattable: '\\xa7' % ()\n")
391
394
 
392
395
    def test_log_bytes_arg(self):
393
 
        logging.getLogger("bzr").debug("%s", "\xa7")
 
396
        logging.getLogger("brz").debug("%s", "\xa7")
394
397
        log = self.get_log()
395
398
        self.assertContainsString(log, "UnicodeDecodeError: ")
396
399
        self.assertContainsString(log,
397
400
            "Logging record unformattable: '%s' % ('\\xa7',)\n")
398
401
 
399
402
    def test_log_mixed_strings(self):
400
 
        logging.getLogger("bzr").debug(u"%s", "\xa7")
 
403
        logging.getLogger("brz").debug(u"%s", "\xa7")
401
404
        log = self.get_log()
402
405
        self.assertContainsString(log, "UnicodeDecodeError: ")
403
406
        self.assertContainsString(log,
407
410
        class BadRepr(object):
408
411
            def __repr__(self):
409
412
                raise ValueError("Broken object")
410
 
        logging.getLogger("bzr").debug("%s", BadRepr())
 
413
        logging.getLogger("brz").debug("%s", BadRepr())
411
414
        log = self.get_log()
412
415
        self.assertContainsRe(log, "ValueError: Broken object\n")
413
416
        self.assertContainsRe(log, "Logging record unformattable: '%s' % .*\n")
429
432
 
430
433
    def test_default_config(self):
431
434
        config = trace.DefaultConfig()
432
 
        self.overrideAttr(trace, "_bzr_log_filename", None)
433
 
        trace._bzr_log_filename = None
434
 
        expected_filename = trace._get_bzr_log_filename()
435
 
        self.assertEqual(None, trace._bzr_log_filename)
 
435
        self.overrideAttr(trace, "_brz_log_filename", None)
 
436
        trace._brz_log_filename = None
 
437
        expected_filename = trace._get_brz_log_filename()
 
438
        self.assertEqual(None, trace._brz_log_filename)
436
439
        config.__enter__()
437
440
        try:
438
441
            # Should have entered and setup a default filename.
439
 
            self.assertEqual(expected_filename, trace._bzr_log_filename)
 
442
            self.assertEqual(expected_filename, trace._brz_log_filename)
440
443
        finally:
441
444
            config.__exit__(None, None, None)
442
445
            # Should have exited and cleaned up.
443
 
            self.assertEqual(None, trace._bzr_log_filename)
 
446
            self.assertEqual(None, trace._brz_log_filename)