← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_errors.py

  • Committer: Martin Pool
  • Date: 2006-10-15 11:57:58 UTC
  • mto: This revision was merged to the branch mainline in revision 2119.
  • Revision ID: mbp@sourcefrog.net-20061015115758-041391cf08503621
Clean up BzrNewError, other exception classes and users.

This cleans up the probably-mistaken BzrNewError behaviour of using error
class docstrings as their format string.  Instead errors can define a _fmt
attribute with the same meaning.  The docstring is now reserved for its
regular purpose of documentation for programmers.  This behaviour is added to
BzrError.  BzrNewError is left in place for compatibility but no builtin
errors use it anymore and it gives a deprecation warning on construction.

BzrError now accepts either a single preformatted string, or a set of named
parameters to be substituted in to a format string for that class.  This 
behaviour is cleaned up and a couple of callers that depended on the
Python2.4-style exception args tuple are fixed.

Display of unprintable errors is slightly more robust.

errors.IncompatibleFormat was defined twice (shadowing the first
definition), so one use was disambiguated to IncompatibleBundleFormat.

UnsupportedEOLMarker called the wrong superclass constructor.

test_time_creates_benchmark_in_result was too dependent on benchmark
timing and has been loosened.

Some error representations changed slightly because of this (e.g. in use
of punctuation.)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_errors.py
24
24
from bzrlib.tests import TestCase, TestCaseWithTransport
25
25
 
26
26
 
 
27
# TODO: Make sure builtin exception class formats are consistent - e.g. should
 
28
# or shouldn't end with a full stop, etc.
 
29
 
 
30
 
27
31
class TestErrors(TestCaseWithTransport):
28
32
 
29
33
    def test_no_repo(self):
53
57
                             repo.bzrdir.root_transport.base,
54
58
                             str(error))
55
59
 
56
 
 
57
 
class PassThroughError(errors.BzrNewError):
58
 
    """Pass through %(foo)s and %(bar)s"""
 
60
    def test_bzrnewerror_is_deprecated(self):
 
61
        class DeprecatedError(errors.BzrNewError):
 
62
            pass
 
63
        self.callDeprecated(['BzrNewError was deprecated in bzr 0.12; '
 
64
             'please convert DeprecatedError to use BzrError instead'],
 
65
            DeprecatedError)
 
66
 
 
67
    def test_bzrerror_from_literal_string(self):
 
68
        # Some code constructs BzrError from a literal string, in which case
 
69
        # no further formatting is done.  (I'm not sure raising the base class
 
70
        # is a great idea, but if the exception is not intended to be caught
 
71
        # perhaps no more is needed.)
 
72
        try:
 
73
            raise errors.BzrError('this is my errors; %d is not expanded')
 
74
        except errors.BzrError, e:
 
75
            self.assertEqual('this is my errors; %d is not expanded', str(e))
 
76
 
 
77
 
 
78
class PassThroughError(errors.BzrError):
 
79
    
 
80
    _fmt = """Pass through %(foo)s and %(bar)s"""
59
81
 
60
82
    def __init__(self, foo, bar):
61
 
        errors.BzrNewError.__init__(self, foo=foo, bar=bar)
62
 
 
63
 
 
64
 
class ErrorWithBadFormat(errors.BzrNewError):
65
 
    """One format specifier: %(thing)s"""
 
83
        errors.BzrError.__init__(self, foo=foo, bar=bar)
 
84
 
 
85
 
 
86
class ErrorWithBadFormat(errors.BzrError):
 
87
 
 
88
    _fmt = """One format specifier: %(thing)s"""
 
89
 
 
90
 
 
91
class ErrorWithNoFormat(errors.BzrError):
 
92
    """This class has a docstring but no format string."""
66
93
 
67
94
 
68
95
class TestErrorFormatting(TestCase):
77
104
        s = str(e)
78
105
        self.assertEqual('Pass through \xc2\xb5 and bar', s)
79
106
 
 
107
    def test_missing_format_string(self):
 
108
        # Code naively converted from BzrNewError might still try to 
 
109
        # use the docstring as the format string
 
110
        e = ErrorWithNoFormat(param='randomvalue')
 
111
        self.assertStartsWith(
 
112
            str(e), 'Unprintable exception ErrorWithNoFormat')
 
113
 
80
114
    def test_mismatched_format_args(self):
81
115
        # Even though ErrorWithBadFormat's format string does not match the
82
116
        # arguments we constructing it with, we can still stringify an instance
83
117
        # of this exception. The resulting string will say its unprintable.
84
118
        e = ErrorWithBadFormat(not_thing='x')
85
119
        self.assertStartsWith(
86
 
            str(e), 'Unprintable exception ErrorWithBadFormat(')
 
120
            str(e), 'Unprintable exception ErrorWithBadFormat')
87
121
 
88
122
 
89
123
class TestSpecificErrors(TestCase):