~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_errors.py

  • Committer: Martin Pool
  • Date: 2005-05-05 06:38:18 UTC
  • Revision ID: mbp@sourcefrog.net-20050505063818-3eb3260343878325
- do upload CHANGELOG to web server, even though it's autogenerated

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# Copyright (C) 2006, 2007 Canonical Ltd
2
 
#   Authors: Robert Collins <robert.collins@canonical.com>
3
 
#            and others
4
 
#
5
 
# This program is free software; you can redistribute it and/or modify
6
 
# it under the terms of the GNU General Public License as published by
7
 
# the Free Software Foundation; either version 2 of the License, or
8
 
# (at your option) any later version.
9
 
#
10
 
# This program is distributed in the hope that it will be useful,
11
 
# but WITHOUT ANY WARRANTY; without even the implied warranty of
12
 
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13
 
# GNU General Public License for more details.
14
 
#
15
 
# You should have received a copy of the GNU General Public License
16
 
# along with this program; if not, write to the Free Software
17
 
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
18
 
 
19
 
"""Tests for the formatting and construction of errors."""
20
 
 
21
 
from bzrlib import (
22
 
    bzrdir,
23
 
    errors,
24
 
    )
25
 
from bzrlib.tests import TestCase, TestCaseWithTransport
26
 
 
27
 
 
28
 
# TODO: Make sure builtin exception class formats are consistent - e.g. should
29
 
# or shouldn't end with a full stop, etc.
30
 
 
31
 
 
32
 
class TestErrors(TestCaseWithTransport):
33
 
 
34
 
    def test_disabled_method(self):
35
 
        error = errors.DisabledMethod("class name")
36
 
        self.assertEqualDiff(
37
 
            "The smart server method 'class name' is disabled.", str(error))
38
 
 
39
 
    def test_duplicate_file_id(self):
40
 
        error = errors.DuplicateFileId('a_file_id', 'foo')
41
 
        self.assertEqualDiff('File id {a_file_id} already exists in inventory'
42
 
                             ' as foo', str(error))
43
 
 
44
 
    def test_duplicate_help_prefix(self):
45
 
        error = errors.DuplicateHelpPrefix('foo')
46
 
        self.assertEqualDiff('The prefix foo is in the help search path twice.',
47
 
            str(error))
48
 
 
49
 
    def test_inventory_modified(self):
50
 
        error = errors.InventoryModified("a tree to be repred")
51
 
        self.assertEqualDiff("The current inventory for the tree 'a tree to "
52
 
            "be repred' has been modified, so a clean inventory cannot be "
53
 
            "read without data loss.",
54
 
            str(error))
55
 
 
56
 
    def test_install_failed(self):
57
 
        error = errors.InstallFailed(['rev-one'])
58
 
        self.assertEqual("Could not install revisions:\nrev-one", str(error))
59
 
        error = errors.InstallFailed(['rev-one', 'rev-two'])
60
 
        self.assertEqual("Could not install revisions:\nrev-one, rev-two",
61
 
                         str(error))
62
 
        error = errors.InstallFailed([None])
63
 
        self.assertEqual("Could not install revisions:\nNone", str(error))
64
 
 
65
 
    def test_lock_active(self):
66
 
        error = errors.LockActive("lock description")
67
 
        self.assertEqualDiff("The lock for 'lock description' is in use and "
68
 
            "cannot be broken.",
69
 
            str(error))
70
 
 
71
 
    def test_knit_header_error(self):
72
 
        error = errors.KnitHeaderError('line foo\n', 'path/to/file')
73
 
        self.assertEqual("Knit header error: 'line foo\\n' unexpected"
74
 
                         " for file path/to/file", str(error))
75
 
 
76
 
    def test_knit_index_unknown_method(self):
77
 
        error = errors.KnitIndexUnknownMethod('http://host/foo.kndx',
78
 
                                              ['bad', 'no-eol'])
79
 
        self.assertEqual("Knit index http://host/foo.kndx does not have a"
80
 
                         " known method in options: ['bad', 'no-eol']",
81
 
                         str(error))
82
 
 
83
 
    def test_medium_not_connected(self):
84
 
        error = errors.MediumNotConnected("a medium")
85
 
        self.assertEqualDiff(
86
 
            "The medium 'a medium' is not connected.", str(error))
87
 
        
88
 
    def test_no_repo(self):
89
 
        dir = bzrdir.BzrDir.create(self.get_url())
90
 
        error = errors.NoRepositoryPresent(dir)
91
 
        self.assertNotEqual(-1, str(error).find((dir.transport.clone('..').base)))
92
 
        self.assertEqual(-1, str(error).find((dir.transport.base)))
93
 
        
94
 
    def test_no_smart_medium(self):
95
 
        error = errors.NoSmartMedium("a transport")
96
 
        self.assertEqualDiff("The transport 'a transport' cannot tunnel the "
97
 
            "smart protocol.",
98
 
            str(error))
99
 
 
100
 
    def test_no_help_topic(self):
101
 
        error = errors.NoHelpTopic("topic")
102
 
        self.assertEqualDiff("No help could be found for 'topic'. "
103
 
            "Please use 'bzr help topics' to obtain a list of topics.",
104
 
            str(error))
105
 
 
106
 
    def test_no_such_id(self):
107
 
        error = errors.NoSuchId("atree", "anid")
108
 
        self.assertEqualDiff("The file id anid is not present in the tree "
109
 
            "atree.",
110
 
            str(error))
111
 
 
112
 
    def test_no_such_revision_in_tree(self):
113
 
        error = errors.NoSuchRevisionInTree("atree", "anid")
114
 
        self.assertEqualDiff("The revision id anid is not present in the tree "
115
 
            "atree.",
116
 
            str(error))
117
 
        self.assertIsInstance(error, errors.NoSuchRevision)
118
 
 
119
 
    def test_not_write_locked(self):
120
 
        error = errors.NotWriteLocked('a thing to repr')
121
 
        self.assertEqualDiff("'a thing to repr' is not write locked but needs "
122
 
            "to be.",
123
 
            str(error))
124
 
 
125
 
    def test_read_only_lock_error(self):
126
 
        error = errors.ReadOnlyLockError('filename', 'error message')
127
 
        self.assertEqualDiff("Cannot acquire write lock on filename."
128
 
                             " error message", str(error))
129
 
 
130
 
    def test_too_many_concurrent_requests(self):
131
 
        error = errors.TooManyConcurrentRequests("a medium")
132
 
        self.assertEqualDiff("The medium 'a medium' has reached its concurrent "
133
 
            "request limit. Be sure to finish_writing and finish_reading on "
134
 
            "the currently open request.",
135
 
            str(error))
136
 
 
137
 
    def test_unknown_hook(self):
138
 
        error = errors.UnknownHook("branch", "foo")
139
 
        self.assertEqualDiff("The branch hook 'foo' is unknown in this version"
140
 
            " of bzrlib.",
141
 
            str(error))
142
 
        error = errors.UnknownHook("tree", "bar")
143
 
        self.assertEqualDiff("The tree hook 'bar' is unknown in this version"
144
 
            " of bzrlib.",
145
 
            str(error))
146
 
 
147
 
    def test_up_to_date(self):
148
 
        error = errors.UpToDateFormat(bzrdir.BzrDirFormat4())
149
 
        self.assertEqualDiff("The branch format Bazaar-NG branch, "
150
 
                             "format 0.0.4 is already at the most "
151
 
                             "recent format.",
152
 
                             str(error))
153
 
 
154
 
    def test_corrupt_repository(self):
155
 
        repo = self.make_repository('.')
156
 
        error = errors.CorruptRepository(repo)
157
 
        self.assertEqualDiff("An error has been detected in the repository %s.\n"
158
 
                             "Please run bzr reconcile on this repository." %
159
 
                             repo.bzrdir.root_transport.base,
160
 
                             str(error))
161
 
 
162
 
    def test_bzrnewerror_is_deprecated(self):
163
 
        class DeprecatedError(errors.BzrNewError):
164
 
            pass
165
 
        self.callDeprecated(['BzrNewError was deprecated in bzr 0.13; '
166
 
             'please convert DeprecatedError to use BzrError instead'],
167
 
            DeprecatedError)
168
 
 
169
 
    def test_bzrerror_from_literal_string(self):
170
 
        # Some code constructs BzrError from a literal string, in which case
171
 
        # no further formatting is done.  (I'm not sure raising the base class
172
 
        # is a great idea, but if the exception is not intended to be caught
173
 
        # perhaps no more is needed.)
174
 
        try:
175
 
            raise errors.BzrError('this is my errors; %d is not expanded')
176
 
        except errors.BzrError, e:
177
 
            self.assertEqual('this is my errors; %d is not expanded', str(e))
178
 
 
179
 
    def test_reading_completed(self):
180
 
        error = errors.ReadingCompleted("a request")
181
 
        self.assertEqualDiff("The MediumRequest 'a request' has already had "
182
 
            "finish_reading called upon it - the request has been completed and"
183
 
            " no more data may be read.",
184
 
            str(error))
185
 
 
186
 
    def test_writing_completed(self):
187
 
        error = errors.WritingCompleted("a request")
188
 
        self.assertEqualDiff("The MediumRequest 'a request' has already had "
189
 
            "finish_writing called upon it - accept bytes may not be called "
190
 
            "anymore.",
191
 
            str(error))
192
 
 
193
 
    def test_writing_not_completed(self):
194
 
        error = errors.WritingNotComplete("a request")
195
 
        self.assertEqualDiff("The MediumRequest 'a request' has not has "
196
 
            "finish_writing called upon it - until the write phase is complete"
197
 
            " no data may be read.",
198
 
            str(error))
199
 
 
200
 
    def test_transport_not_possible(self):
201
 
        e = errors.TransportNotPossible('readonly', 'original error')
202
 
        self.assertEqual('Transport operation not possible:'
203
 
                         ' readonly original error', str(e))
204
 
 
205
 
    def assertSocketConnectionError(self, expected, *args, **kwargs):
206
 
        """Check the formatting of a SocketConnectionError exception"""
207
 
        e = errors.SocketConnectionError(*args, **kwargs)
208
 
        self.assertEqual(expected, str(e))
209
 
 
210
 
    def test_socket_connection_error(self):
211
 
        """Test the formatting of SocketConnectionError"""
212
 
 
213
 
        # There should be a default msg about failing to connect
214
 
        # we only require a host name.
215
 
        self.assertSocketConnectionError(
216
 
            'Failed to connect to ahost',
217
 
            'ahost')
218
 
 
219
 
        # If port is None, we don't put :None
220
 
        self.assertSocketConnectionError(
221
 
            'Failed to connect to ahost',
222
 
            'ahost', port=None)
223
 
        # But if port is supplied we include it
224
 
        self.assertSocketConnectionError(
225
 
            'Failed to connect to ahost:22',
226
 
            'ahost', port=22)
227
 
 
228
 
        # We can also supply extra information about the error
229
 
        # with or without a port
230
 
        self.assertSocketConnectionError(
231
 
            'Failed to connect to ahost:22; bogus error',
232
 
            'ahost', port=22, orig_error='bogus error')
233
 
        self.assertSocketConnectionError(
234
 
            'Failed to connect to ahost; bogus error',
235
 
            'ahost', orig_error='bogus error')
236
 
        # An exception object can be passed rather than a string
237
 
        orig_error = ValueError('bad value')
238
 
        self.assertSocketConnectionError(
239
 
            'Failed to connect to ahost; %s' % (str(orig_error),),
240
 
            host='ahost', orig_error=orig_error)
241
 
 
242
 
        # And we can supply a custom failure message
243
 
        self.assertSocketConnectionError(
244
 
            'Unable to connect to ssh host ahost:444; my_error',
245
 
            host='ahost', port=444, msg='Unable to connect to ssh host',
246
 
            orig_error='my_error')
247
 
 
248
 
    def test_malformed_bug_identifier(self):
249
 
        """Test the formatting of MalformedBugIdentifier."""
250
 
        error = errors.MalformedBugIdentifier('bogus', 'reason for bogosity')
251
 
        self.assertEqual(
252
 
            "Did not understand bug identifier bogus: reason for bogosity",
253
 
            str(error))
254
 
 
255
 
    def test_unknown_bug_tracker_abbreviation(self):
256
 
        """Test the formatting of UnknownBugTrackerAbbreviation."""
257
 
        branch = self.make_branch('some_branch')
258
 
        error = errors.UnknownBugTrackerAbbreviation('xxx', branch)
259
 
        self.assertEqual(
260
 
            "Cannot find registered bug tracker called xxx on %s" % branch,
261
 
            str(error))
262
 
 
263
 
    def test_unexpected_smart_server_response(self):
264
 
        e = errors.UnexpectedSmartServerResponse(('not yes',))
265
 
        self.assertEqual(
266
 
            "Could not understand response from smart server: ('not yes',)",
267
 
            str(e))
268
 
 
269
 
 
270
 
class PassThroughError(errors.BzrError):
271
 
    
272
 
    _fmt = """Pass through %(foo)s and %(bar)s"""
273
 
 
274
 
    def __init__(self, foo, bar):
275
 
        errors.BzrError.__init__(self, foo=foo, bar=bar)
276
 
 
277
 
 
278
 
class ErrorWithBadFormat(errors.BzrError):
279
 
 
280
 
    _fmt = """One format specifier: %(thing)s"""
281
 
 
282
 
 
283
 
class ErrorWithNoFormat(errors.BzrError):
284
 
    """This class has a docstring but no format string."""
285
 
 
286
 
 
287
 
class TestErrorFormatting(TestCase):
288
 
    
289
 
    def test_always_str(self):
290
 
        e = PassThroughError(u'\xb5', 'bar')
291
 
        self.assertIsInstance(e.__str__(), str)
292
 
        # In Python str(foo) *must* return a real byte string
293
 
        # not a Unicode string. The following line would raise a
294
 
        # Unicode error, because it tries to call str() on the string
295
 
        # returned from e.__str__(), and it has non ascii characters
296
 
        s = str(e)
297
 
        self.assertEqual('Pass through \xc2\xb5 and bar', s)
298
 
 
299
 
    def test_missing_format_string(self):
300
 
        e = ErrorWithNoFormat(param='randomvalue')
301
 
        s = self.callDeprecated(
302
 
                ['ErrorWithNoFormat uses its docstring as a format, it should use _fmt instead'],
303
 
                lambda x: str(x), e)
304
 
        ## s = str(e)
305
 
        self.assertEqual(s, 
306
 
                "This class has a docstring but no format string.")
307
 
 
308
 
    def test_mismatched_format_args(self):
309
 
        # Even though ErrorWithBadFormat's format string does not match the
310
 
        # arguments we constructing it with, we can still stringify an instance
311
 
        # of this exception. The resulting string will say its unprintable.
312
 
        e = ErrorWithBadFormat(not_thing='x')
313
 
        self.assertStartsWith(
314
 
            str(e), 'Unprintable exception ErrorWithBadFormat')
315