18
19
"""Tests for the formatting and construction of errors."""
20
import bzrlib.bzrdir as bzrdir
21
import bzrlib.errors as errors
22
from bzrlib.tests import TestCaseWithTransport
26
from bzrlib.tests import TestCase, TestCaseWithTransport
25
29
class TestErrors(TestCaseWithTransport):
31
def test_disabled_method(self):
32
error = errors.DisabledMethod("class name")
34
"The smart server method 'class name' is disabled.", str(error))
36
def test_duplicate_file_id(self):
37
error = errors.DuplicateFileId('a_file_id', 'foo')
38
self.assertEqualDiff('File id {a_file_id} already exists in inventory'
39
' as foo', str(error))
41
def test_duplicate_help_prefix(self):
42
error = errors.DuplicateHelpPrefix('foo')
43
self.assertEqualDiff('The prefix foo is in the help search path twice.',
46
def test_incompatibleAPI(self):
47
error = errors.IncompatibleAPI("module", (1, 2, 3), (4, 5, 6), (7, 8, 9))
49
'The API for "module" is not compatible with "(1, 2, 3)". '
50
'It supports versions "(4, 5, 6)" to "(7, 8, 9)".',
53
def test_in_process_transport(self):
54
error = errors.InProcessTransport('fpp')
56
"The transport 'fpp' is only accessible within this process.",
59
def test_invalid_http_range(self):
60
error = errors.InvalidHttpRange('path',
61
'Content-Range: potatoes 0-00/o0oo0',
63
self.assertEquals("Invalid http range"
64
" 'Content-Range: potatoes 0-00/o0oo0'"
65
" for path: bad range",
68
def test_invalid_range(self):
69
error = errors.InvalidRange('path', 12, 'bad range')
70
self.assertEquals("Invalid range access in path at 12: bad range",
73
def test_inventory_modified(self):
74
error = errors.InventoryModified("a tree to be repred")
75
self.assertEqualDiff("The current inventory for the tree 'a tree to "
76
"be repred' has been modified, so a clean inventory cannot be "
77
"read without data loss.",
80
def test_install_failed(self):
81
error = errors.InstallFailed(['rev-one'])
82
self.assertEqual("Could not install revisions:\nrev-one", str(error))
83
error = errors.InstallFailed(['rev-one', 'rev-two'])
84
self.assertEqual("Could not install revisions:\nrev-one, rev-two",
86
error = errors.InstallFailed([None])
87
self.assertEqual("Could not install revisions:\nNone", str(error))
89
def test_lock_active(self):
90
error = errors.LockActive("lock description")
91
self.assertEqualDiff("The lock for 'lock description' is in use and "
95
def test_knit_data_stream_incompatible(self):
96
error = errors.KnitDataStreamIncompatible(
97
'stream format', 'target format')
98
self.assertEqual('Cannot insert knit data stream of format '
99
'"stream format" into knit of format '
100
'"target format".', str(error))
102
def test_knit_data_stream_unknown(self):
103
error = errors.KnitDataStreamUnknown(
105
self.assertEqual('Cannot parse knit data stream of format '
106
'"stream format".', str(error))
108
def test_knit_header_error(self):
109
error = errors.KnitHeaderError('line foo\n', 'path/to/file')
110
self.assertEqual("Knit header error: 'line foo\\n' unexpected"
111
" for file \"path/to/file\".", str(error))
113
def test_knit_index_unknown_method(self):
114
error = errors.KnitIndexUnknownMethod('http://host/foo.kndx',
116
self.assertEqual("Knit index http://host/foo.kndx does not have a"
117
" known method in options: ['bad', 'no-eol']",
120
def test_medium_not_connected(self):
121
error = errors.MediumNotConnected("a medium")
122
self.assertEqualDiff(
123
"The medium 'a medium' is not connected.", str(error))
27
125
def test_no_repo(self):
28
126
dir = bzrdir.BzrDir.create(self.get_url())
29
127
error = errors.NoRepositoryPresent(dir)
30
self.assertNotEqual(-1, str(error).find(repr(dir.transport.clone('..').base)))
31
self.assertEqual(-1, str(error).find(repr(dir.transport.base)))
128
self.assertNotEqual(-1, str(error).find((dir.transport.clone('..').base)))
129
self.assertEqual(-1, str(error).find((dir.transport.base)))
131
def test_no_smart_medium(self):
132
error = errors.NoSmartMedium("a transport")
133
self.assertEqualDiff("The transport 'a transport' cannot tunnel the "
137
def test_no_help_topic(self):
138
error = errors.NoHelpTopic("topic")
139
self.assertEqualDiff("No help could be found for 'topic'. "
140
"Please use 'bzr help topics' to obtain a list of topics.",
143
def test_no_such_id(self):
144
error = errors.NoSuchId("atree", "anid")
145
self.assertEqualDiff("The file id \"anid\" is not present in the tree "
149
def test_no_such_revision_in_tree(self):
150
error = errors.NoSuchRevisionInTree("atree", "anid")
151
self.assertEqualDiff("The revision id {anid} is not present in the"
152
" tree atree.", str(error))
153
self.assertIsInstance(error, errors.NoSuchRevision)
155
def test_not_write_locked(self):
156
error = errors.NotWriteLocked('a thing to repr')
157
self.assertEqualDiff("'a thing to repr' is not write locked but needs "
161
def test_read_only_lock_error(self):
162
error = self.applyDeprecated(symbol_versioning.zero_ninetytwo,
163
errors.ReadOnlyLockError, 'filename', 'error message')
164
self.assertEqualDiff("Cannot acquire write lock on filename."
165
" error message", str(error))
167
def test_lock_failed(self):
168
error = errors.LockFailed('http://canonical.com/', 'readonly transport')
169
self.assertEqualDiff("Cannot lock http://canonical.com/: readonly transport",
171
self.assertFalse(error.internal_error)
173
def test_too_many_concurrent_requests(self):
174
error = errors.TooManyConcurrentRequests("a medium")
175
self.assertEqualDiff("The medium 'a medium' has reached its concurrent "
176
"request limit. Be sure to finish_writing and finish_reading on "
177
"the currently open request.",
180
def test_unknown_hook(self):
181
error = errors.UnknownHook("branch", "foo")
182
self.assertEqualDiff("The branch hook 'foo' is unknown in this version"
185
error = errors.UnknownHook("tree", "bar")
186
self.assertEqualDiff("The tree hook 'bar' is unknown in this version"
33
190
def test_up_to_date(self):
34
191
error = errors.UpToDateFormat(bzrdir.BzrDirFormat4())
44
201
"Please run bzr reconcile on this repository." %
45
202
repo.bzrdir.root_transport.base,
205
def test_read_error(self):
206
# a unicode path to check that %r is being used.
208
error = errors.ReadError(path)
209
self.assertEqualDiff("Error reading from u'a path'.", str(error))
211
def test_bad_index_format_signature(self):
212
error = errors.BadIndexFormatSignature("foo", "bar")
213
self.assertEqual("foo is not an index of type bar.",
216
def test_bad_index_data(self):
217
error = errors.BadIndexData("foo")
218
self.assertEqual("Error in data for index foo.",
221
def test_bad_index_duplicate_key(self):
222
error = errors.BadIndexDuplicateKey("foo", "bar")
223
self.assertEqual("The key 'foo' is already in index 'bar'.",
226
def test_bad_index_key(self):
227
error = errors.BadIndexKey("foo")
228
self.assertEqual("The key 'foo' is not a valid key.",
231
def test_bad_index_options(self):
232
error = errors.BadIndexOptions("foo")
233
self.assertEqual("Could not parse options for index foo.",
236
def test_bad_index_value(self):
237
error = errors.BadIndexValue("foo")
238
self.assertEqual("The value 'foo' is not a valid value.",
241
def test_bzrnewerror_is_deprecated(self):
242
class DeprecatedError(errors.BzrNewError):
244
self.callDeprecated(['BzrNewError was deprecated in bzr 0.13; '
245
'please convert DeprecatedError to use BzrError instead'],
248
def test_bzrerror_from_literal_string(self):
249
# Some code constructs BzrError from a literal string, in which case
250
# no further formatting is done. (I'm not sure raising the base class
251
# is a great idea, but if the exception is not intended to be caught
252
# perhaps no more is needed.)
254
raise errors.BzrError('this is my errors; %d is not expanded')
255
except errors.BzrError, e:
256
self.assertEqual('this is my errors; %d is not expanded', str(e))
258
def test_reading_completed(self):
259
error = errors.ReadingCompleted("a request")
260
self.assertEqualDiff("The MediumRequest 'a request' has already had "
261
"finish_reading called upon it - the request has been completed and"
262
" no more data may be read.",
265
def test_writing_completed(self):
266
error = errors.WritingCompleted("a request")
267
self.assertEqualDiff("The MediumRequest 'a request' has already had "
268
"finish_writing called upon it - accept bytes may not be called "
272
def test_writing_not_completed(self):
273
error = errors.WritingNotComplete("a request")
274
self.assertEqualDiff("The MediumRequest 'a request' has not has "
275
"finish_writing called upon it - until the write phase is complete"
276
" no data may be read.",
279
def test_transport_not_possible(self):
280
error = errors.TransportNotPossible('readonly', 'original error')
281
self.assertEqualDiff('Transport operation not possible:'
282
' readonly original error', str(error))
284
def assertSocketConnectionError(self, expected, *args, **kwargs):
285
"""Check the formatting of a SocketConnectionError exception"""
286
e = errors.SocketConnectionError(*args, **kwargs)
287
self.assertEqual(expected, str(e))
289
def test_socket_connection_error(self):
290
"""Test the formatting of SocketConnectionError"""
292
# There should be a default msg about failing to connect
293
# we only require a host name.
294
self.assertSocketConnectionError(
295
'Failed to connect to ahost',
298
# If port is None, we don't put :None
299
self.assertSocketConnectionError(
300
'Failed to connect to ahost',
302
# But if port is supplied we include it
303
self.assertSocketConnectionError(
304
'Failed to connect to ahost:22',
307
# We can also supply extra information about the error
308
# with or without a port
309
self.assertSocketConnectionError(
310
'Failed to connect to ahost:22; bogus error',
311
'ahost', port=22, orig_error='bogus error')
312
self.assertSocketConnectionError(
313
'Failed to connect to ahost; bogus error',
314
'ahost', orig_error='bogus error')
315
# An exception object can be passed rather than a string
316
orig_error = ValueError('bad value')
317
self.assertSocketConnectionError(
318
'Failed to connect to ahost; %s' % (str(orig_error),),
319
host='ahost', orig_error=orig_error)
321
# And we can supply a custom failure message
322
self.assertSocketConnectionError(
323
'Unable to connect to ssh host ahost:444; my_error',
324
host='ahost', port=444, msg='Unable to connect to ssh host',
325
orig_error='my_error')
327
def test_malformed_bug_identifier(self):
328
"""Test the formatting of MalformedBugIdentifier."""
329
error = errors.MalformedBugIdentifier('bogus', 'reason for bogosity')
331
"Did not understand bug identifier bogus: reason for bogosity",
334
def test_unknown_bug_tracker_abbreviation(self):
335
"""Test the formatting of UnknownBugTrackerAbbreviation."""
336
branch = self.make_branch('some_branch')
337
error = errors.UnknownBugTrackerAbbreviation('xxx', branch)
339
"Cannot find registered bug tracker called xxx on %s" % branch,
342
def test_unexpected_smart_server_response(self):
343
e = errors.UnexpectedSmartServerResponse(('not yes',))
345
"Could not understand response from smart server: ('not yes',)",
348
def test_unknown_container_format(self):
349
"""Test the formatting of UnknownContainerFormatError."""
350
e = errors.UnknownContainerFormatError('bad format string')
352
"Unrecognised container format: 'bad format string'",
355
def test_unexpected_end_of_container(self):
356
"""Test the formatting of UnexpectedEndOfContainerError."""
357
e = errors.UnexpectedEndOfContainerError()
359
"Unexpected end of container stream", str(e))
361
def test_unknown_record_type(self):
362
"""Test the formatting of UnknownRecordTypeError."""
363
e = errors.UnknownRecordTypeError("X")
365
"Unknown record type: 'X'",
368
def test_invalid_record(self):
369
"""Test the formatting of InvalidRecordError."""
370
e = errors.InvalidRecordError("xxx")
372
"Invalid record: xxx",
375
def test_container_has_excess_data(self):
376
"""Test the formatting of ContainerHasExcessDataError."""
377
e = errors.ContainerHasExcessDataError("excess bytes")
379
"Container has data after end marker: 'excess bytes'",
382
def test_duplicate_record_name_error(self):
383
"""Test the formatting of DuplicateRecordNameError."""
384
e = errors.DuplicateRecordNameError(u"n\xe5me".encode('utf-8'))
386
"Container has multiple records with the same name: n\xc3\xa5me",
389
def test_check_error(self):
390
# This has a member called 'message', which is problematic in
391
# python2.5 because that is a slot on the base Exception class
392
e = errors.BzrCheckError('example check failure')
394
"Internal check failed: example check failure",
396
self.assertTrue(e.internal_error)
398
def test_repository_data_stream_error(self):
399
"""Test the formatting of RepositoryDataStreamError."""
400
e = errors.RepositoryDataStreamError(u"my reason")
402
"Corrupt or incompatible data stream: my reason", str(e))
404
def test_immortal_pending_deletion_message(self):
405
err = errors.ImmortalPendingDeletion('foo')
407
"Unable to delete transform temporary directory foo. "
408
"Please examine foo to see if it contains any files "
409
"you wish to keep, and delete it when you are done.",
412
def test_unable_create_symlink(self):
413
err = errors.UnableCreateSymlink()
415
"Unable to create symlink on this platform",
417
err = errors.UnableCreateSymlink(path=u'foo')
419
"Unable to create symlink 'foo' on this platform",
421
err = errors.UnableCreateSymlink(path=u'\xb5')
423
"Unable to create symlink u'\\xb5' on this platform",
426
def test_incorrect_url(self):
427
err = errors.InvalidBugTrackerURL('foo', 'http://bug.com/')
429
("The URL for bug tracker \"foo\" doesn't contain {id}: "
434
class PassThroughError(errors.BzrError):
436
_fmt = """Pass through %(foo)s and %(bar)s"""
438
def __init__(self, foo, bar):
439
errors.BzrError.__init__(self, foo=foo, bar=bar)
442
class ErrorWithBadFormat(errors.BzrError):
444
_fmt = """One format specifier: %(thing)s"""
447
class ErrorWithNoFormat(errors.BzrError):
448
"""This class has a docstring but no format string."""
451
class TestErrorFormatting(TestCase):
453
def test_always_str(self):
454
e = PassThroughError(u'\xb5', 'bar')
455
self.assertIsInstance(e.__str__(), str)
456
# In Python str(foo) *must* return a real byte string
457
# not a Unicode string. The following line would raise a
458
# Unicode error, because it tries to call str() on the string
459
# returned from e.__str__(), and it has non ascii characters
461
self.assertEqual('Pass through \xc2\xb5 and bar', s)
463
def test_missing_format_string(self):
464
e = ErrorWithNoFormat(param='randomvalue')
465
s = self.callDeprecated(
466
['ErrorWithNoFormat uses its docstring as a format, it should use _fmt instead'],
470
"This class has a docstring but no format string.")
472
def test_mismatched_format_args(self):
473
# Even though ErrorWithBadFormat's format string does not match the
474
# arguments we constructing it with, we can still stringify an instance
475
# of this exception. The resulting string will say its unprintable.
476
e = ErrorWithBadFormat(not_thing='x')
477
self.assertStartsWith(
478
str(e), 'Unprintable exception ErrorWithBadFormat')
added
removed
bzrlib/tests/test_errors.py
