/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 breezy/tests/test_trace.py

  • Committer: Jelmer Vernooij
  • Date: 2017-05-22 00:56:52 UTC
  • mfrom: (6621.2.26 py3_pokes)
  • Revision ID: jelmer@jelmer.uk-20170522005652-yjahcr9hwmjkno7n
Merge Python3 porting work ('py3 pokes')

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/tests/test_trace.py
1
 
# Copyright (C) 2005-2010 Canonical Ltd
 
1
# Copyright (C) 2005-2011, 2016 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
 
22
import logging
23
23
import os
24
24
import re
25
25
import sys
26
26
import tempfile
27
27
 
28
 
from bzrlib import (
 
28
from .. import (
 
29
    debug,
29
30
    errors,
30
31
    trace,
31
32
    )
32
 
from bzrlib.tests import TestCaseInTempDir, TestCase
33
 
from bzrlib.trace import (
 
33
from ..sixish import (
 
34
    BytesIO,
 
35
    )
 
36
from . import features, TestCaseInTempDir, TestCase
 
37
from ..trace import (
34
38
    mutter, mutter_callsite, report_exception,
35
39
    set_verbosity_level, get_verbosity_level, is_quiet, is_verbose, be_quiet,
36
40
    pop_log_file,
42
46
 
43
47
def _format_exception():
44
48
    """Format an exception as it would normally be displayed to the user"""
45
 
    buf = StringIO()
 
49
    buf = BytesIO()
46
50
    report_exception(sys.exc_info(), buf)
47
51
    return buf.getvalue()
48
52
 
51
55
 
52
56
    def test_format_sys_exception(self):
53
57
        # Test handling of an internal/unexpected error that probably
54
 
        # 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
55
59
        # depending on whether apport is available or not.  See test_crash for
56
60
        # more.
57
61
        try:
58
 
            raise NotImplementedError, "time travel"
 
62
            raise NotImplementedError("time travel")
59
63
        except NotImplementedError:
60
64
            pass
61
65
        err = _format_exception()
62
66
        self.assertEqualDiff(err.splitlines()[0],
63
 
                'bzr: ERROR: exceptions.NotImplementedError: time travel')
 
67
                'brz: ERROR: exceptions.NotImplementedError: time travel')
64
68
        self.assertContainsRe(err,
65
69
            'Bazaar has encountered an internal error.')
66
70
 
72
76
            pass
73
77
        msg = _format_exception()
74
78
        self.assertTrue(len(msg) > 0)
75
 
        self.assertEqualDiff(msg, 'bzr: interrupted\n')
 
79
        self.assertEqualDiff(msg, 'brz: interrupted\n')
76
80
 
77
81
    def test_format_memory_error(self):
78
82
        try:
80
84
        except MemoryError:
81
85
            pass
82
86
        msg = _format_exception()
83
 
        self.assertEquals(msg,
84
 
            "bzr: out of memory\n")
 
87
        self.assertEqual(msg,
 
88
            "brz: out of memory\nUse -Dmem_dump to dump memory to a file.\n")
 
89
 
 
90
    def test_format_mem_dump(self):
 
91
        self.requireFeature(features.meliae)
 
92
        debug.debug_flags.add('mem_dump')
 
93
        try:
 
94
            raise MemoryError()
 
95
        except MemoryError:
 
96
            pass
 
97
        msg = _format_exception()
 
98
        self.assertStartsWith(msg,
 
99
            "brz: out of memory\nMemory dumped to ")
85
100
 
86
101
    def test_format_os_error(self):
87
102
        try:
88
103
            os.rmdir('nosuchfile22222')
89
 
        except OSError, e:
 
104
        except OSError as e:
90
105
            e_str = str(e)
91
106
        msg = _format_exception()
92
107
        # Linux seems to give "No such file" but Windows gives "The system
93
108
        # cannot find the file specified".
94
 
        self.assertEqual('bzr: ERROR: %s\n' % (e_str,), msg)
 
109
        self.assertEqual('brz: ERROR: %s\n' % (e_str,), msg)
95
110
 
96
111
    def test_format_io_error(self):
97
112
        try:
101
116
        msg = _format_exception()
102
117
        # Even though Windows and Linux differ for 'os.rmdir', they both give
103
118
        # 'No such file' for open()
104
 
        self.assertContainsRe(msg,
105
 
            r'^bzr: ERROR: \[Errno .*\] No such file.*nosuchfile')
 
119
        # However it now gets translated so we can not test for a specific message
 
120
        self.assertContainsRe(msg,
 
121
            r'^brz: ERROR: \[Errno .*\] .*nosuchfile')
 
122
 
 
123
    def test_format_pywintypes_error(self):
 
124
        self.requireFeature(features.pywintypes)
 
125
        import pywintypes, win32file
 
126
        try:
 
127
            win32file.RemoveDirectory('nosuchfile22222')
 
128
        except pywintypes.error:
 
129
            pass
 
130
        msg = _format_exception()
 
131
        # GZ 2010-05-03: Formatting for pywintypes.error is basic, a 3-tuple
 
132
        #                with errno, function name, and locale error message
 
133
        self.assertContainsRe(msg,
 
134
            r"^brz: ERROR: \(2, 'RemoveDirectory[AW]?', .*\)")
 
135
            
 
136
    def test_format_sockets_error(self):
 
137
        try:
 
138
            import socket
 
139
            sock = socket.socket()
 
140
            sock.send("This should fail.")
 
141
        except socket.error:
 
142
            pass
 
143
        msg = _format_exception()
 
144
        
 
145
        self.assertNotContainsRe(msg,
 
146
            r"Traceback (most recent call last):")
106
147
 
107
148
    def test_format_unicode_error(self):
108
149
        try:
112
153
        msg = _format_exception()
113
154
 
114
155
    def test_format_exception(self):
115
 
        """Short formatting of bzr exceptions"""
 
156
        """Short formatting of brz exceptions"""
116
157
        try:
117
158
            raise errors.NotBranchError('wibble')
118
159
        except errors.NotBranchError:
119
160
            pass
120
161
        msg = _format_exception()
121
162
        self.assertTrue(len(msg) > 0)
122
 
        self.assertEqualDiff(msg, 'bzr: ERROR: Not a branch: \"wibble\".\n')
 
163
        self.assertEqualDiff(msg, 'brz: ERROR: Not a branch: \"wibble\".\n')
123
164
 
124
165
    def test_report_external_import_error(self):
125
166
        """Short friendly message for missing system modules."""
126
167
        try:
127
168
            import ImaginaryModule
128
 
        except ImportError, e:
 
169
        except ImportError as e:
129
170
            pass
130
171
        else:
131
172
            self.fail("somehow succeeded in importing %r" % ImaginaryModule)
132
173
        msg = _format_exception()
133
174
        self.assertEqual(msg,
134
 
            'bzr: ERROR: No module named ImaginaryModule\n'
 
175
            'brz: ERROR: No module named ImaginaryModule\n'
135
176
            'You may need to install this Python library separately.\n')
136
177
 
137
178
    def test_report_import_syntax_error(self):
138
179
        try:
139
180
            raise ImportError("syntax error")
140
 
        except ImportError, e:
 
181
        except ImportError as e:
141
182
            pass
142
183
        msg = _format_exception()
143
184
        self.assertContainsRe(msg,
165
206
    def test_report_broken_pipe(self):
166
207
        try:
167
208
            raise IOError(errno.EPIPE, 'broken pipe foofofo')
168
 
        except IOError, e:
 
209
        except IOError as e:
169
210
            msg = _format_exception()
170
 
            self.assertEquals(msg, "bzr: broken pipe\n")
 
211
            self.assertEqual(msg, "brz: broken pipe\n")
171
212
        else:
172
213
            self.fail("expected error not raised")
173
214
 
216
257
        # have to do a replaceent here as well.
217
258
        self.assertContainsRe(log, "ascii argument: \xb5".decode('utf8',
218
259
            'replace'))
219
 
        
 
260
 
220
261
    def test_show_error(self):
221
262
        show_error('error1')
222
263
        show_error(u'error2 \xb5 blah')
270
311
            tmp1.close()
271
312
            tmp2.close()
272
313
 
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
 
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
275
316
        # warning to stderr. Since this is normally happening before logging is
276
317
        # set up.
277
 
        self.overrideAttr(sys, 'stderr', StringIO())
 
318
        self.overrideAttr(sys, 'stderr', BytesIO())
278
319
        # 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()
 
320
        self.overrideEnv('BRZ_LOG', '/no-such-dir/brz.log')
 
321
        self.overrideAttr(trace, '_brz_log_filename')
 
322
        logf = trace._open_brz_log()
284
323
        self.assertIs(None, logf)
285
 
        self.assertContainsRe(sys.stderr.getvalue(),
286
 
                              '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'$")
287
327
 
288
328
 
289
329
class TestVerbosityLevel(TestCase):
310
350
        self.assertEqual(0, get_verbosity_level())
311
351
 
312
352
 
 
353
class TestLogging(TestCase):
 
354
    """Check logging functionality robustly records information"""
 
355
 
 
356
    def test_note(self):
 
357
        trace.note("Noted")
 
358
        self.assertEqual("    INFO  Noted\n", self.get_log())
 
359
 
 
360
    def test_warning(self):
 
361
        trace.warning("Warned")
 
362
        self.assertEqual(" WARNING  Warned\n", self.get_log())
 
363
 
 
364
    def test_log(self):
 
365
        logging.getLogger("brz").error("Errored")
 
366
        self.assertEqual("   ERROR  Errored\n", self.get_log())
 
367
 
 
368
    def test_log_sub(self):
 
369
        logging.getLogger("brz.test_log_sub").debug("Whispered")
 
370
        self.assertEqual("   DEBUG  Whispered\n", self.get_log())
 
371
 
 
372
    def test_log_unicode_msg(self):
 
373
        logging.getLogger("brz").debug(u"\xa7")
 
374
        self.assertEqual(u"   DEBUG  \xa7\n", self.get_log())
 
375
 
 
376
    def test_log_unicode_arg(self):
 
377
        logging.getLogger("brz").debug("%s", u"\xa7")
 
378
        self.assertEqual(u"   DEBUG  \xa7\n", self.get_log())
 
379
 
 
380
    def test_log_utf8_msg(self):
 
381
        logging.getLogger("brz").debug("\xc2\xa7")
 
382
        self.assertEqual(u"   DEBUG  \xa7\n", self.get_log())
 
383
 
 
384
    def test_log_utf8_arg(self):
 
385
        logging.getLogger("brz").debug("%s", "\xc2\xa7")
 
386
        self.assertEqual(u"   DEBUG  \xa7\n", self.get_log())
 
387
 
 
388
    def test_log_bytes_msg(self):
 
389
        logging.getLogger("brz").debug("\xa7")
 
390
        log = self.get_log()
 
391
        self.assertContainsString(log, "UnicodeDecodeError: ")
 
392
        self.assertContainsString(log,
 
393
            "Logging record unformattable: '\\xa7' % ()\n")
 
394
 
 
395
    def test_log_bytes_arg(self):
 
396
        logging.getLogger("brz").debug("%s", "\xa7")
 
397
        log = self.get_log()
 
398
        self.assertContainsString(log, "UnicodeDecodeError: ")
 
399
        self.assertContainsString(log,
 
400
            "Logging record unformattable: '%s' % ('\\xa7',)\n")
 
401
 
 
402
    def test_log_mixed_strings(self):
 
403
        logging.getLogger("brz").debug(u"%s", "\xa7")
 
404
        log = self.get_log()
 
405
        self.assertContainsString(log, "UnicodeDecodeError: ")
 
406
        self.assertContainsString(log,
 
407
            "Logging record unformattable: u'%s' % ('\\xa7',)\n")
 
408
 
 
409
    def test_log_repr_broken(self):
 
410
        class BadRepr(object):
 
411
            def __repr__(self):
 
412
                raise ValueError("Broken object")
 
413
        logging.getLogger("brz").debug("%s", BadRepr())
 
414
        log = self.get_log()
 
415
        self.assertContainsRe(log, "ValueError: Broken object\n")
 
416
        self.assertContainsRe(log, "Logging record unformattable: '%s' % .*\n")
 
417
 
 
418
 
313
419
class TestBzrLog(TestCaseInTempDir):
314
420
 
315
421
    def test_log_rollover(self):
320
426
        _rollover_trace_maybe(temp_log_name)
321
427
        # should have been rolled over
322
428
        self.assertFalse(os.access(temp_log_name, os.R_OK))
 
429
 
 
430
 
 
431
class TestTraceConfiguration(TestCaseInTempDir):
 
432
 
 
433
    def test_default_config(self):
 
434
        config = trace.DefaultConfig()
 
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)
 
439
        config.__enter__()
 
440
        try:
 
441
            # Should have entered and setup a default filename.
 
442
            self.assertEqual(expected_filename, trace._brz_log_filename)
 
443
        finally:
 
444
            config.__exit__(None, None, None)
 
445
            # Should have exited and cleaned up.
 
446
            self.assertEqual(None, trace._brz_log_filename)