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
29
from bzrlib.tests import TestCase, TestCaseWithTransport
25
32
class TestErrors(TestCaseWithTransport):
34
def test_bad_filename_encoding(self):
35
error = errors.BadFilenameEncoding('bad/filen\xe5me', 'UTF-8')
37
"Filename 'bad/filen\\xe5me' is not valid in your current"
38
" filesystem encoding UTF-8",
41
def test_corrupt_dirstate(self):
42
error = errors.CorruptDirstate('path/to/dirstate', 'the reason why')
44
"Inconsistency in dirstate file path/to/dirstate.\n"
45
"Error: the reason why",
48
def test_disabled_method(self):
49
error = errors.DisabledMethod("class name")
51
"The smart server method 'class name' is disabled.", str(error))
53
def test_duplicate_file_id(self):
54
error = errors.DuplicateFileId('a_file_id', 'foo')
55
self.assertEqualDiff('File id {a_file_id} already exists in inventory'
56
' as foo', str(error))
58
def test_duplicate_help_prefix(self):
59
error = errors.DuplicateHelpPrefix('foo')
60
self.assertEqualDiff('The prefix foo is in the help search path twice.',
63
def test_ghost_revisions_have_no_revno(self):
64
error = errors.GhostRevisionsHaveNoRevno('target', 'ghost_rev')
65
self.assertEqualDiff("Could not determine revno for {target} because"
66
" its ancestry shows a ghost at {ghost_rev}",
69
def test_incompatibleAPI(self):
70
error = errors.IncompatibleAPI("module", (1, 2, 3), (4, 5, 6), (7, 8, 9))
72
'The API for "module" is not compatible with "(1, 2, 3)". '
73
'It supports versions "(4, 5, 6)" to "(7, 8, 9)".',
76
def test_inconsistent_delta(self):
77
error = errors.InconsistentDelta('path', 'file-id', 'reason for foo')
79
"An inconsistent delta was supplied involving 'path', 'file-id'\n"
80
"reason: reason for foo",
83
def test_in_process_transport(self):
84
error = errors.InProcessTransport('fpp')
86
"The transport 'fpp' is only accessible within this process.",
89
def test_invalid_http_range(self):
90
error = errors.InvalidHttpRange('path',
91
'Content-Range: potatoes 0-00/o0oo0',
93
self.assertEquals("Invalid http range"
94
" 'Content-Range: potatoes 0-00/o0oo0'"
95
" for path: bad range",
98
def test_invalid_range(self):
99
error = errors.InvalidRange('path', 12, 'bad range')
100
self.assertEquals("Invalid range access in path at 12: bad range",
103
def test_inventory_modified(self):
104
error = errors.InventoryModified("a tree to be repred")
105
self.assertEqualDiff("The current inventory for the tree 'a tree to "
106
"be repred' has been modified, so a clean inventory cannot be "
107
"read without data loss.",
110
def test_install_failed(self):
111
error = errors.InstallFailed(['rev-one'])
112
self.assertEqual("Could not install revisions:\nrev-one", str(error))
113
error = errors.InstallFailed(['rev-one', 'rev-two'])
114
self.assertEqual("Could not install revisions:\nrev-one, rev-two",
116
error = errors.InstallFailed([None])
117
self.assertEqual("Could not install revisions:\nNone", str(error))
119
def test_lock_active(self):
120
error = errors.LockActive("lock description")
121
self.assertEqualDiff("The lock for 'lock description' is in use and "
125
def test_knit_data_stream_incompatible(self):
126
error = errors.KnitDataStreamIncompatible(
127
'stream format', 'target format')
128
self.assertEqual('Cannot insert knit data stream of format '
129
'"stream format" into knit of format '
130
'"target format".', str(error))
132
def test_knit_data_stream_unknown(self):
133
error = errors.KnitDataStreamUnknown(
135
self.assertEqual('Cannot parse knit data stream of format '
136
'"stream format".', str(error))
138
def test_knit_header_error(self):
139
error = errors.KnitHeaderError('line foo\n', 'path/to/file')
140
self.assertEqual("Knit header error: 'line foo\\n' unexpected"
141
" for file \"path/to/file\".", str(error))
143
def test_knit_index_unknown_method(self):
144
error = errors.KnitIndexUnknownMethod('http://host/foo.kndx',
146
self.assertEqual("Knit index http://host/foo.kndx does not have a"
147
" known method in options: ['bad', 'no-eol']",
150
def test_medium_not_connected(self):
151
error = errors.MediumNotConnected("a medium")
152
self.assertEqualDiff(
153
"The medium 'a medium' is not connected.", str(error))
155
def test_no_public_branch(self):
156
b = self.make_branch('.')
157
error = errors.NoPublicBranch(b)
158
url = urlutils.unescape_for_display(b.base, 'ascii')
159
self.assertEqualDiff(
160
'There is no public branch set for "%s".' % url, str(error))
27
162
def test_no_repo(self):
28
163
dir = bzrdir.BzrDir.create(self.get_url())
29
164
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)))
165
self.assertNotEqual(-1, str(error).find((dir.transport.clone('..').base)))
166
self.assertEqual(-1, str(error).find((dir.transport.base)))
168
def test_no_smart_medium(self):
169
error = errors.NoSmartMedium("a transport")
170
self.assertEqualDiff("The transport 'a transport' cannot tunnel the "
174
def test_no_help_topic(self):
175
error = errors.NoHelpTopic("topic")
176
self.assertEqualDiff("No help could be found for 'topic'. "
177
"Please use 'bzr help topics' to obtain a list of topics.",
180
def test_no_such_id(self):
181
error = errors.NoSuchId("atree", "anid")
182
self.assertEqualDiff("The file id \"anid\" is not present in the tree "
186
def test_no_such_revision_in_tree(self):
187
error = errors.NoSuchRevisionInTree("atree", "anid")
188
self.assertEqualDiff("The revision id {anid} is not present in the"
189
" tree atree.", str(error))
190
self.assertIsInstance(error, errors.NoSuchRevision)
192
def test_not_stacked(self):
193
error = errors.NotStacked('a branch')
194
self.assertEqualDiff("The branch 'a branch' is not stacked.",
197
def test_not_write_locked(self):
198
error = errors.NotWriteLocked('a thing to repr')
199
self.assertEqualDiff("'a thing to repr' is not write locked but needs "
203
def test_lock_failed(self):
204
error = errors.LockFailed('http://canonical.com/', 'readonly transport')
205
self.assertEqualDiff("Cannot lock http://canonical.com/: readonly transport",
207
self.assertFalse(error.internal_error)
209
def test_too_many_concurrent_requests(self):
210
error = errors.TooManyConcurrentRequests("a medium")
211
self.assertEqualDiff("The medium 'a medium' has reached its concurrent "
212
"request limit. Be sure to finish_writing and finish_reading on "
213
"the currently open request.",
216
def test_unavailable_representation(self):
217
error = errors.UnavailableRepresentation(('key',), "mpdiff", "fulltext")
218
self.assertEqualDiff("The encoding 'mpdiff' is not available for key "
219
"('key',) which is encoded as 'fulltext'.",
222
def test_unknown_hook(self):
223
error = errors.UnknownHook("branch", "foo")
224
self.assertEqualDiff("The branch hook 'foo' is unknown in this version"
227
error = errors.UnknownHook("tree", "bar")
228
self.assertEqualDiff("The tree hook 'bar' is unknown in this version"
232
def test_unstackable_branch_format(self):
235
error = errors.UnstackableBranchFormat(format, url)
236
self.assertEqualDiff(
237
"The branch '/foo'(foo) is not a stackable format. "
238
"You will need to upgrade the branch to permit branch stacking.",
241
def test_unstackable_repository_format(self):
244
error = errors.UnstackableRepositoryFormat(format, url)
245
self.assertEqualDiff(
246
"The repository '/foo'(foo) is not a stackable format. "
247
"You will need to upgrade the repository to permit branch stacking.",
33
250
def test_up_to_date(self):
34
251
error = errors.UpToDateFormat(bzrdir.BzrDirFormat4())
44
261
"Please run bzr reconcile on this repository." %
45
262
repo.bzrdir.root_transport.base,
265
def test_read_error(self):
266
# a unicode path to check that %r is being used.
268
error = errors.ReadError(path)
269
self.assertEqualDiff("Error reading from u'a path'.", str(error))
271
def test_bad_index_format_signature(self):
272
error = errors.BadIndexFormatSignature("foo", "bar")
273
self.assertEqual("foo is not an index of type bar.",
276
def test_bad_index_data(self):
277
error = errors.BadIndexData("foo")
278
self.assertEqual("Error in data for index foo.",
281
def test_bad_index_duplicate_key(self):
282
error = errors.BadIndexDuplicateKey("foo", "bar")
283
self.assertEqual("The key 'foo' is already in index 'bar'.",
286
def test_bad_index_key(self):
287
error = errors.BadIndexKey("foo")
288
self.assertEqual("The key 'foo' is not a valid key.",
291
def test_bad_index_options(self):
292
error = errors.BadIndexOptions("foo")
293
self.assertEqual("Could not parse options for index foo.",
296
def test_bad_index_value(self):
297
error = errors.BadIndexValue("foo")
298
self.assertEqual("The value 'foo' is not a valid value.",
301
def test_bzrnewerror_is_deprecated(self):
302
class DeprecatedError(errors.BzrNewError):
304
self.callDeprecated(['BzrNewError was deprecated in bzr 0.13; '
305
'please convert DeprecatedError to use BzrError instead'],
308
def test_bzrerror_from_literal_string(self):
309
# Some code constructs BzrError from a literal string, in which case
310
# no further formatting is done. (I'm not sure raising the base class
311
# is a great idea, but if the exception is not intended to be caught
312
# perhaps no more is needed.)
314
raise errors.BzrError('this is my errors; %d is not expanded')
315
except errors.BzrError, e:
316
self.assertEqual('this is my errors; %d is not expanded', str(e))
318
def test_reading_completed(self):
319
error = errors.ReadingCompleted("a request")
320
self.assertEqualDiff("The MediumRequest 'a request' has already had "
321
"finish_reading called upon it - the request has been completed and"
322
" no more data may be read.",
325
def test_writing_completed(self):
326
error = errors.WritingCompleted("a request")
327
self.assertEqualDiff("The MediumRequest 'a request' has already had "
328
"finish_writing called upon it - accept bytes may not be called "
332
def test_writing_not_completed(self):
333
error = errors.WritingNotComplete("a request")
334
self.assertEqualDiff("The MediumRequest 'a request' has not has "
335
"finish_writing called upon it - until the write phase is complete"
336
" no data may be read.",
339
def test_transport_not_possible(self):
340
error = errors.TransportNotPossible('readonly', 'original error')
341
self.assertEqualDiff('Transport operation not possible:'
342
' readonly original error', str(error))
344
def assertSocketConnectionError(self, expected, *args, **kwargs):
345
"""Check the formatting of a SocketConnectionError exception"""
346
e = errors.SocketConnectionError(*args, **kwargs)
347
self.assertEqual(expected, str(e))
349
def test_socket_connection_error(self):
350
"""Test the formatting of SocketConnectionError"""
352
# There should be a default msg about failing to connect
353
# we only require a host name.
354
self.assertSocketConnectionError(
355
'Failed to connect to ahost',
358
# If port is None, we don't put :None
359
self.assertSocketConnectionError(
360
'Failed to connect to ahost',
362
# But if port is supplied we include it
363
self.assertSocketConnectionError(
364
'Failed to connect to ahost:22',
367
# We can also supply extra information about the error
368
# with or without a port
369
self.assertSocketConnectionError(
370
'Failed to connect to ahost:22; bogus error',
371
'ahost', port=22, orig_error='bogus error')
372
self.assertSocketConnectionError(
373
'Failed to connect to ahost; bogus error',
374
'ahost', orig_error='bogus error')
375
# An exception object can be passed rather than a string
376
orig_error = ValueError('bad value')
377
self.assertSocketConnectionError(
378
'Failed to connect to ahost; %s' % (str(orig_error),),
379
host='ahost', orig_error=orig_error)
381
# And we can supply a custom failure message
382
self.assertSocketConnectionError(
383
'Unable to connect to ssh host ahost:444; my_error',
384
host='ahost', port=444, msg='Unable to connect to ssh host',
385
orig_error='my_error')
387
def test_target_not_branch(self):
388
"""Test the formatting of TargetNotBranch."""
389
error = errors.TargetNotBranch('foo')
391
"Your branch does not have all of the revisions required in "
392
"order to merge this merge directive and the target "
393
"location specified in the merge directive is not a branch: "
396
def test_malformed_bug_identifier(self):
397
"""Test the formatting of MalformedBugIdentifier."""
398
error = errors.MalformedBugIdentifier('bogus', 'reason for bogosity')
400
"Did not understand bug identifier bogus: reason for bogosity",
403
def test_unknown_bug_tracker_abbreviation(self):
404
"""Test the formatting of UnknownBugTrackerAbbreviation."""
405
branch = self.make_branch('some_branch')
406
error = errors.UnknownBugTrackerAbbreviation('xxx', branch)
408
"Cannot find registered bug tracker called xxx on %s" % branch,
411
def test_unexpected_smart_server_response(self):
412
e = errors.UnexpectedSmartServerResponse(('not yes',))
414
"Could not understand response from smart server: ('not yes',)",
417
def test_unknown_container_format(self):
418
"""Test the formatting of UnknownContainerFormatError."""
419
e = errors.UnknownContainerFormatError('bad format string')
421
"Unrecognised container format: 'bad format string'",
424
def test_unexpected_end_of_container(self):
425
"""Test the formatting of UnexpectedEndOfContainerError."""
426
e = errors.UnexpectedEndOfContainerError()
428
"Unexpected end of container stream", str(e))
430
def test_unknown_record_type(self):
431
"""Test the formatting of UnknownRecordTypeError."""
432
e = errors.UnknownRecordTypeError("X")
434
"Unknown record type: 'X'",
437
def test_invalid_record(self):
438
"""Test the formatting of InvalidRecordError."""
439
e = errors.InvalidRecordError("xxx")
441
"Invalid record: xxx",
444
def test_container_has_excess_data(self):
445
"""Test the formatting of ContainerHasExcessDataError."""
446
e = errors.ContainerHasExcessDataError("excess bytes")
448
"Container has data after end marker: 'excess bytes'",
451
def test_duplicate_record_name_error(self):
452
"""Test the formatting of DuplicateRecordNameError."""
453
e = errors.DuplicateRecordNameError(u"n\xe5me".encode('utf-8'))
455
"Container has multiple records with the same name: n\xc3\xa5me",
458
def test_check_error(self):
459
# This has a member called 'message', which is problematic in
460
# python2.5 because that is a slot on the base Exception class
461
e = errors.BzrCheckError('example check failure')
463
"Internal check failed: example check failure",
465
self.assertTrue(e.internal_error)
467
def test_repository_data_stream_error(self):
468
"""Test the formatting of RepositoryDataStreamError."""
469
e = errors.RepositoryDataStreamError(u"my reason")
471
"Corrupt or incompatible data stream: my reason", str(e))
473
def test_immortal_pending_deletion_message(self):
474
err = errors.ImmortalPendingDeletion('foo')
476
"Unable to delete transform temporary directory foo. "
477
"Please examine foo to see if it contains any files "
478
"you wish to keep, and delete it when you are done.",
481
def test_unable_create_symlink(self):
482
err = errors.UnableCreateSymlink()
484
"Unable to create symlink on this platform",
486
err = errors.UnableCreateSymlink(path=u'foo')
488
"Unable to create symlink 'foo' on this platform",
490
err = errors.UnableCreateSymlink(path=u'\xb5')
492
"Unable to create symlink u'\\xb5' on this platform",
495
def test_invalid_url_join(self):
496
"""Test the formatting of InvalidURLJoin."""
497
e = errors.InvalidURLJoin('Reason', 'base path', ('args',))
499
"Invalid URL join request: Reason: 'base path' + ('args',)",
502
def test_incorrect_url(self):
503
err = errors.InvalidBugTrackerURL('foo', 'http://bug.com/')
505
("The URL for bug tracker \"foo\" doesn't contain {id}: "
509
def test_unable_encode_path(self):
510
err = errors.UnableEncodePath('foo', 'executable')
511
self.assertEquals("Unable to encode executable path 'foo' in "
512
"user encoding " + osutils.get_user_encoding(),
515
def test_unknown_format(self):
516
err = errors.UnknownFormatError('bar', kind='foo')
517
self.assertEquals("Unknown foo format: 'bar'", str(err))
519
def test_unknown_rules(self):
520
err = errors.UnknownRules(['foo', 'bar'])
521
self.assertEquals("Unknown rules detected: foo, bar.", str(err))
523
def test_hook_failed(self):
524
# Create an exc_info tuple by raising and catching an exception.
527
except ZeroDivisionError:
528
exc_info = sys.exc_info()
529
err = errors.HookFailed('hook stage', 'hook name', exc_info)
530
self.assertStartsWith(
531
str(err), 'Hook \'hook name\' during hook stage failed:\n')
533
str(err), 'integer division or modulo by zero')
535
def test_tip_change_rejected(self):
536
err = errors.TipChangeRejected(u'Unicode message\N{INTERROBANG}')
538
u'Tip change rejected: Unicode message\N{INTERROBANG}',
541
'Tip change rejected: Unicode message\xe2\x80\xbd',
545
class PassThroughError(errors.BzrError):
547
_fmt = """Pass through %(foo)s and %(bar)s"""
549
def __init__(self, foo, bar):
550
errors.BzrError.__init__(self, foo=foo, bar=bar)
553
class ErrorWithBadFormat(errors.BzrError):
555
_fmt = """One format specifier: %(thing)s"""
558
class ErrorWithNoFormat(errors.BzrError):
559
"""This class has a docstring but no format string."""
562
class TestErrorFormatting(TestCase):
564
def test_always_str(self):
565
e = PassThroughError(u'\xb5', 'bar')
566
self.assertIsInstance(e.__str__(), str)
567
# In Python str(foo) *must* return a real byte string
568
# not a Unicode string. The following line would raise a
569
# Unicode error, because it tries to call str() on the string
570
# returned from e.__str__(), and it has non ascii characters
572
self.assertEqual('Pass through \xc2\xb5 and bar', s)
574
def test_missing_format_string(self):
575
e = ErrorWithNoFormat(param='randomvalue')
576
s = self.callDeprecated(
577
['ErrorWithNoFormat uses its docstring as a format, it should use _fmt instead'],
581
"This class has a docstring but no format string.")
583
def test_mismatched_format_args(self):
584
# Even though ErrorWithBadFormat's format string does not match the
585
# arguments we constructing it with, we can still stringify an instance
586
# of this exception. The resulting string will say its unprintable.
587
e = ErrorWithBadFormat(not_thing='x')
588
self.assertStartsWith(
589
str(e), 'Unprintable exception ErrorWithBadFormat')
added
removed
bzrlib/tests/test_errors.py
