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
28
from bzrlib.tests import TestCase, TestCaseWithTransport
25
31
class TestErrors(TestCaseWithTransport):
33
def test_corrupt_dirstate(self):
34
error = errors.CorruptDirstate('path/to/dirstate', 'the reason why')
36
"Inconsistency in dirstate file path/to/dirstate.\n"
37
"Error: the reason why",
40
def test_disabled_method(self):
41
error = errors.DisabledMethod("class name")
43
"The smart server method 'class name' is disabled.", str(error))
45
def test_duplicate_file_id(self):
46
error = errors.DuplicateFileId('a_file_id', 'foo')
47
self.assertEqualDiff('File id {a_file_id} already exists in inventory'
48
' as foo', str(error))
50
def test_duplicate_help_prefix(self):
51
error = errors.DuplicateHelpPrefix('foo')
52
self.assertEqualDiff('The prefix foo is in the help search path twice.',
55
def test_ghost_revisions_have_no_revno(self):
56
error = errors.GhostRevisionsHaveNoRevno('target', 'ghost_rev')
57
self.assertEqualDiff("Could not determine revno for {target} because"
58
" its ancestry shows a ghost at {ghost_rev}",
61
def test_incompatibleAPI(self):
62
error = errors.IncompatibleAPI("module", (1, 2, 3), (4, 5, 6), (7, 8, 9))
64
'The API for "module" is not compatible with "(1, 2, 3)". '
65
'It supports versions "(4, 5, 6)" to "(7, 8, 9)".',
68
def test_inconsistent_delta(self):
69
error = errors.InconsistentDelta('path', 'file-id', 'reason for foo')
71
"An inconsistent delta was supplied involving 'path', 'file-id'\n"
72
"reason: reason for foo",
75
def test_in_process_transport(self):
76
error = errors.InProcessTransport('fpp')
78
"The transport 'fpp' is only accessible within this process.",
81
def test_invalid_http_range(self):
82
error = errors.InvalidHttpRange('path',
83
'Content-Range: potatoes 0-00/o0oo0',
85
self.assertEquals("Invalid http range"
86
" 'Content-Range: potatoes 0-00/o0oo0'"
87
" for path: bad range",
90
def test_invalid_range(self):
91
error = errors.InvalidRange('path', 12, 'bad range')
92
self.assertEquals("Invalid range access in path at 12: bad range",
95
def test_inventory_modified(self):
96
error = errors.InventoryModified("a tree to be repred")
97
self.assertEqualDiff("The current inventory for the tree 'a tree to "
98
"be repred' has been modified, so a clean inventory cannot be "
99
"read without data loss.",
102
def test_install_failed(self):
103
error = errors.InstallFailed(['rev-one'])
104
self.assertEqual("Could not install revisions:\nrev-one", str(error))
105
error = errors.InstallFailed(['rev-one', 'rev-two'])
106
self.assertEqual("Could not install revisions:\nrev-one, rev-two",
108
error = errors.InstallFailed([None])
109
self.assertEqual("Could not install revisions:\nNone", str(error))
111
def test_lock_active(self):
112
error = errors.LockActive("lock description")
113
self.assertEqualDiff("The lock for 'lock description' is in use and "
117
def test_knit_data_stream_incompatible(self):
118
error = errors.KnitDataStreamIncompatible(
119
'stream format', 'target format')
120
self.assertEqual('Cannot insert knit data stream of format '
121
'"stream format" into knit of format '
122
'"target format".', str(error))
124
def test_knit_data_stream_unknown(self):
125
error = errors.KnitDataStreamUnknown(
127
self.assertEqual('Cannot parse knit data stream of format '
128
'"stream format".', str(error))
130
def test_knit_header_error(self):
131
error = errors.KnitHeaderError('line foo\n', 'path/to/file')
132
self.assertEqual("Knit header error: 'line foo\\n' unexpected"
133
" for file \"path/to/file\".", str(error))
135
def test_knit_index_unknown_method(self):
136
error = errors.KnitIndexUnknownMethod('http://host/foo.kndx',
138
self.assertEqual("Knit index http://host/foo.kndx does not have a"
139
" known method in options: ['bad', 'no-eol']",
142
def test_medium_not_connected(self):
143
error = errors.MediumNotConnected("a medium")
144
self.assertEqualDiff(
145
"The medium 'a medium' is not connected.", str(error))
147
def test_no_public_branch(self):
148
b = self.make_branch('.')
149
error = errors.NoPublicBranch(b)
150
url = urlutils.unescape_for_display(b.base, 'ascii')
151
self.assertEqualDiff(
152
'There is no public branch set for "%s".' % url, str(error))
27
154
def test_no_repo(self):
28
155
dir = bzrdir.BzrDir.create(self.get_url())
29
156
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)))
157
self.assertNotEqual(-1, str(error).find((dir.transport.clone('..').base)))
158
self.assertEqual(-1, str(error).find((dir.transport.base)))
160
def test_no_smart_medium(self):
161
error = errors.NoSmartMedium("a transport")
162
self.assertEqualDiff("The transport 'a transport' cannot tunnel the "
166
def test_no_help_topic(self):
167
error = errors.NoHelpTopic("topic")
168
self.assertEqualDiff("No help could be found for 'topic'. "
169
"Please use 'bzr help topics' to obtain a list of topics.",
172
def test_no_such_id(self):
173
error = errors.NoSuchId("atree", "anid")
174
self.assertEqualDiff("The file id \"anid\" is not present in the tree "
178
def test_no_such_revision_in_tree(self):
179
error = errors.NoSuchRevisionInTree("atree", "anid")
180
self.assertEqualDiff("The revision id {anid} is not present in the"
181
" tree atree.", str(error))
182
self.assertIsInstance(error, errors.NoSuchRevision)
184
def test_not_stacked(self):
185
error = errors.NotStacked('a branch')
186
self.assertEqualDiff("The branch 'a branch' is not stacked.",
189
def test_not_write_locked(self):
190
error = errors.NotWriteLocked('a thing to repr')
191
self.assertEqualDiff("'a thing to repr' is not write locked but needs "
195
def test_lock_failed(self):
196
error = errors.LockFailed('http://canonical.com/', 'readonly transport')
197
self.assertEqualDiff("Cannot lock http://canonical.com/: readonly transport",
199
self.assertFalse(error.internal_error)
201
def test_too_many_concurrent_requests(self):
202
error = errors.TooManyConcurrentRequests("a medium")
203
self.assertEqualDiff("The medium 'a medium' has reached its concurrent "
204
"request limit. Be sure to finish_writing and finish_reading on "
205
"the currently open request.",
208
def test_unavailable_representation(self):
209
error = errors.UnavailableRepresentation(('key',), "mpdiff", "fulltext")
210
self.assertEqualDiff("The encoding 'mpdiff' is not available for key "
211
"('key',) which is encoded as 'fulltext'.",
214
def test_unknown_hook(self):
215
error = errors.UnknownHook("branch", "foo")
216
self.assertEqualDiff("The branch hook 'foo' is unknown in this version"
219
error = errors.UnknownHook("tree", "bar")
220
self.assertEqualDiff("The tree hook 'bar' is unknown in this version"
224
def test_unstackable_branch_format(self):
227
error = errors.UnstackableBranchFormat(format, url)
228
self.assertEqualDiff(
229
"The branch '/foo'(foo) is not a stackable format. "
230
"You will need to upgrade the branch to permit branch stacking.",
233
def test_unstackable_repository_format(self):
236
error = errors.UnstackableRepositoryFormat(format, url)
237
self.assertEqualDiff(
238
"The repository '/foo'(foo) is not a stackable format. "
239
"You will need to upgrade the repository to permit branch stacking.",
33
242
def test_up_to_date(self):
34
243
error = errors.UpToDateFormat(bzrdir.BzrDirFormat4())
44
253
"Please run bzr reconcile on this repository." %
45
254
repo.bzrdir.root_transport.base,
257
def test_read_error(self):
258
# a unicode path to check that %r is being used.
260
error = errors.ReadError(path)
261
self.assertEqualDiff("Error reading from u'a path'.", str(error))
263
def test_bad_index_format_signature(self):
264
error = errors.BadIndexFormatSignature("foo", "bar")
265
self.assertEqual("foo is not an index of type bar.",
268
def test_bad_index_data(self):
269
error = errors.BadIndexData("foo")
270
self.assertEqual("Error in data for index foo.",
273
def test_bad_index_duplicate_key(self):
274
error = errors.BadIndexDuplicateKey("foo", "bar")
275
self.assertEqual("The key 'foo' is already in index 'bar'.",
278
def test_bad_index_key(self):
279
error = errors.BadIndexKey("foo")
280
self.assertEqual("The key 'foo' is not a valid key.",
283
def test_bad_index_options(self):
284
error = errors.BadIndexOptions("foo")
285
self.assertEqual("Could not parse options for index foo.",
288
def test_bad_index_value(self):
289
error = errors.BadIndexValue("foo")
290
self.assertEqual("The value 'foo' is not a valid value.",
293
def test_bzrnewerror_is_deprecated(self):
294
class DeprecatedError(errors.BzrNewError):
296
self.callDeprecated(['BzrNewError was deprecated in bzr 0.13; '
297
'please convert DeprecatedError to use BzrError instead'],
300
def test_bzrerror_from_literal_string(self):
301
# Some code constructs BzrError from a literal string, in which case
302
# no further formatting is done. (I'm not sure raising the base class
303
# is a great idea, but if the exception is not intended to be caught
304
# perhaps no more is needed.)
306
raise errors.BzrError('this is my errors; %d is not expanded')
307
except errors.BzrError, e:
308
self.assertEqual('this is my errors; %d is not expanded', str(e))
310
def test_reading_completed(self):
311
error = errors.ReadingCompleted("a request")
312
self.assertEqualDiff("The MediumRequest 'a request' has already had "
313
"finish_reading called upon it - the request has been completed and"
314
" no more data may be read.",
317
def test_writing_completed(self):
318
error = errors.WritingCompleted("a request")
319
self.assertEqualDiff("The MediumRequest 'a request' has already had "
320
"finish_writing called upon it - accept bytes may not be called "
324
def test_writing_not_completed(self):
325
error = errors.WritingNotComplete("a request")
326
self.assertEqualDiff("The MediumRequest 'a request' has not has "
327
"finish_writing called upon it - until the write phase is complete"
328
" no data may be read.",
331
def test_transport_not_possible(self):
332
error = errors.TransportNotPossible('readonly', 'original error')
333
self.assertEqualDiff('Transport operation not possible:'
334
' readonly original error', str(error))
336
def assertSocketConnectionError(self, expected, *args, **kwargs):
337
"""Check the formatting of a SocketConnectionError exception"""
338
e = errors.SocketConnectionError(*args, **kwargs)
339
self.assertEqual(expected, str(e))
341
def test_socket_connection_error(self):
342
"""Test the formatting of SocketConnectionError"""
344
# There should be a default msg about failing to connect
345
# we only require a host name.
346
self.assertSocketConnectionError(
347
'Failed to connect to ahost',
350
# If port is None, we don't put :None
351
self.assertSocketConnectionError(
352
'Failed to connect to ahost',
354
# But if port is supplied we include it
355
self.assertSocketConnectionError(
356
'Failed to connect to ahost:22',
359
# We can also supply extra information about the error
360
# with or without a port
361
self.assertSocketConnectionError(
362
'Failed to connect to ahost:22; bogus error',
363
'ahost', port=22, orig_error='bogus error')
364
self.assertSocketConnectionError(
365
'Failed to connect to ahost; bogus error',
366
'ahost', orig_error='bogus error')
367
# An exception object can be passed rather than a string
368
orig_error = ValueError('bad value')
369
self.assertSocketConnectionError(
370
'Failed to connect to ahost; %s' % (str(orig_error),),
371
host='ahost', orig_error=orig_error)
373
# And we can supply a custom failure message
374
self.assertSocketConnectionError(
375
'Unable to connect to ssh host ahost:444; my_error',
376
host='ahost', port=444, msg='Unable to connect to ssh host',
377
orig_error='my_error')
379
def test_malformed_bug_identifier(self):
380
"""Test the formatting of MalformedBugIdentifier."""
381
error = errors.MalformedBugIdentifier('bogus', 'reason for bogosity')
383
"Did not understand bug identifier bogus: reason for bogosity",
386
def test_unknown_bug_tracker_abbreviation(self):
387
"""Test the formatting of UnknownBugTrackerAbbreviation."""
388
branch = self.make_branch('some_branch')
389
error = errors.UnknownBugTrackerAbbreviation('xxx', branch)
391
"Cannot find registered bug tracker called xxx on %s" % branch,
394
def test_unexpected_smart_server_response(self):
395
e = errors.UnexpectedSmartServerResponse(('not yes',))
397
"Could not understand response from smart server: ('not yes',)",
400
def test_unknown_container_format(self):
401
"""Test the formatting of UnknownContainerFormatError."""
402
e = errors.UnknownContainerFormatError('bad format string')
404
"Unrecognised container format: 'bad format string'",
407
def test_unexpected_end_of_container(self):
408
"""Test the formatting of UnexpectedEndOfContainerError."""
409
e = errors.UnexpectedEndOfContainerError()
411
"Unexpected end of container stream", str(e))
413
def test_unknown_record_type(self):
414
"""Test the formatting of UnknownRecordTypeError."""
415
e = errors.UnknownRecordTypeError("X")
417
"Unknown record type: 'X'",
420
def test_invalid_record(self):
421
"""Test the formatting of InvalidRecordError."""
422
e = errors.InvalidRecordError("xxx")
424
"Invalid record: xxx",
427
def test_container_has_excess_data(self):
428
"""Test the formatting of ContainerHasExcessDataError."""
429
e = errors.ContainerHasExcessDataError("excess bytes")
431
"Container has data after end marker: 'excess bytes'",
434
def test_duplicate_record_name_error(self):
435
"""Test the formatting of DuplicateRecordNameError."""
436
e = errors.DuplicateRecordNameError(u"n\xe5me".encode('utf-8'))
438
"Container has multiple records with the same name: n\xc3\xa5me",
441
def test_check_error(self):
442
# This has a member called 'message', which is problematic in
443
# python2.5 because that is a slot on the base Exception class
444
e = errors.BzrCheckError('example check failure')
446
"Internal check failed: example check failure",
448
self.assertTrue(e.internal_error)
450
def test_repository_data_stream_error(self):
451
"""Test the formatting of RepositoryDataStreamError."""
452
e = errors.RepositoryDataStreamError(u"my reason")
454
"Corrupt or incompatible data stream: my reason", str(e))
456
def test_immortal_pending_deletion_message(self):
457
err = errors.ImmortalPendingDeletion('foo')
459
"Unable to delete transform temporary directory foo. "
460
"Please examine foo to see if it contains any files "
461
"you wish to keep, and delete it when you are done.",
464
def test_unable_create_symlink(self):
465
err = errors.UnableCreateSymlink()
467
"Unable to create symlink on this platform",
469
err = errors.UnableCreateSymlink(path=u'foo')
471
"Unable to create symlink 'foo' on this platform",
473
err = errors.UnableCreateSymlink(path=u'\xb5')
475
"Unable to create symlink u'\\xb5' on this platform",
478
def test_invalid_url_join(self):
479
"""Test the formatting of InvalidURLJoin."""
480
e = errors.InvalidURLJoin('Reason', 'base path', ('args',))
482
"Invalid URL join request: Reason: 'base path' + ('args',)",
485
def test_incorrect_url(self):
486
err = errors.InvalidBugTrackerURL('foo', 'http://bug.com/')
488
("The URL for bug tracker \"foo\" doesn't contain {id}: "
492
def test_unable_encode_path(self):
493
err = errors.UnableEncodePath('foo', 'executable')
494
self.assertEquals("Unable to encode executable path 'foo' in "
495
"user encoding " + osutils.get_user_encoding(),
498
def test_unknown_format(self):
499
err = errors.UnknownFormatError('bar', kind='foo')
500
self.assertEquals("Unknown foo format: 'bar'", str(err))
503
class PassThroughError(errors.BzrError):
505
_fmt = """Pass through %(foo)s and %(bar)s"""
507
def __init__(self, foo, bar):
508
errors.BzrError.__init__(self, foo=foo, bar=bar)
511
class ErrorWithBadFormat(errors.BzrError):
513
_fmt = """One format specifier: %(thing)s"""
516
class ErrorWithNoFormat(errors.BzrError):
517
"""This class has a docstring but no format string."""
520
class TestErrorFormatting(TestCase):
522
def test_always_str(self):
523
e = PassThroughError(u'\xb5', 'bar')
524
self.assertIsInstance(e.__str__(), str)
525
# In Python str(foo) *must* return a real byte string
526
# not a Unicode string. The following line would raise a
527
# Unicode error, because it tries to call str() on the string
528
# returned from e.__str__(), and it has non ascii characters
530
self.assertEqual('Pass through \xc2\xb5 and bar', s)
532
def test_missing_format_string(self):
533
e = ErrorWithNoFormat(param='randomvalue')
534
s = self.callDeprecated(
535
['ErrorWithNoFormat uses its docstring as a format, it should use _fmt instead'],
539
"This class has a docstring but no format string.")
541
def test_mismatched_format_args(self):
542
# Even though ErrorWithBadFormat's format string does not match the
543
# arguments we constructing it with, we can still stringify an instance
544
# of this exception. The resulting string will say its unprintable.
545
e = ErrorWithBadFormat(not_thing='x')
546
self.assertStartsWith(
547
str(e), 'Unprintable exception ErrorWithBadFormat')
added
removed
bzrlib/tests/test_errors.py
