19
18
"""Tests for the formatting and construction of errors."""
29
from bzrlib.tests import TestCase, TestCaseWithTransport
20
import bzrlib.bzrdir as bzrdir
21
import bzrlib.errors as errors
22
from bzrlib.tests import TestCaseWithTransport
32
25
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_dirstate_corrupt(self):
49
error = errors.DirstateCorrupt('.bzr/checkout/dirstate',
50
'trailing garbage: "x"')
51
self.assertEqualDiff("The dirstate file (.bzr/checkout/dirstate)"
52
" appears to be corrupt: trailing garbage: \"x\"",
55
def test_disabled_method(self):
56
error = errors.DisabledMethod("class name")
58
"The smart server method 'class name' is disabled.", str(error))
60
def test_duplicate_file_id(self):
61
error = errors.DuplicateFileId('a_file_id', 'foo')
62
self.assertEqualDiff('File id {a_file_id} already exists in inventory'
63
' as foo', str(error))
65
def test_duplicate_help_prefix(self):
66
error = errors.DuplicateHelpPrefix('foo')
67
self.assertEqualDiff('The prefix foo is in the help search path twice.',
70
def test_ghost_revisions_have_no_revno(self):
71
error = errors.GhostRevisionsHaveNoRevno('target', 'ghost_rev')
72
self.assertEqualDiff("Could not determine revno for {target} because"
73
" its ancestry shows a ghost at {ghost_rev}",
76
def test_incompatibleAPI(self):
77
error = errors.IncompatibleAPI("module", (1, 2, 3), (4, 5, 6), (7, 8, 9))
79
'The API for "module" is not compatible with "(1, 2, 3)". '
80
'It supports versions "(4, 5, 6)" to "(7, 8, 9)".',
83
def test_inconsistent_delta(self):
84
error = errors.InconsistentDelta('path', 'file-id', 'reason for foo')
86
"An inconsistent delta was supplied involving 'path', 'file-id'\n"
87
"reason: reason for foo",
90
def test_in_process_transport(self):
91
error = errors.InProcessTransport('fpp')
93
"The transport 'fpp' is only accessible within this process.",
96
def test_invalid_http_range(self):
97
error = errors.InvalidHttpRange('path',
98
'Content-Range: potatoes 0-00/o0oo0',
100
self.assertEquals("Invalid http range"
101
" 'Content-Range: potatoes 0-00/o0oo0'"
102
" for path: bad range",
105
def test_invalid_range(self):
106
error = errors.InvalidRange('path', 12, 'bad range')
107
self.assertEquals("Invalid range access in path at 12: bad range",
110
def test_inventory_modified(self):
111
error = errors.InventoryModified("a tree to be repred")
112
self.assertEqualDiff("The current inventory for the tree 'a tree to "
113
"be repred' has been modified, so a clean inventory cannot be "
114
"read without data loss.",
117
def test_install_failed(self):
118
error = errors.InstallFailed(['rev-one'])
119
self.assertEqual("Could not install revisions:\nrev-one", str(error))
120
error = errors.InstallFailed(['rev-one', 'rev-two'])
121
self.assertEqual("Could not install revisions:\nrev-one, rev-two",
123
error = errors.InstallFailed([None])
124
self.assertEqual("Could not install revisions:\nNone", str(error))
126
def test_lock_active(self):
127
error = errors.LockActive("lock description")
128
self.assertEqualDiff("The lock for 'lock description' is in use and "
132
def test_knit_data_stream_incompatible(self):
133
error = errors.KnitDataStreamIncompatible(
134
'stream format', 'target format')
135
self.assertEqual('Cannot insert knit data stream of format '
136
'"stream format" into knit of format '
137
'"target format".', str(error))
139
def test_knit_data_stream_unknown(self):
140
error = errors.KnitDataStreamUnknown(
142
self.assertEqual('Cannot parse knit data stream of format '
143
'"stream format".', str(error))
145
def test_knit_header_error(self):
146
error = errors.KnitHeaderError('line foo\n', 'path/to/file')
147
self.assertEqual("Knit header error: 'line foo\\n' unexpected"
148
" for file \"path/to/file\".", str(error))
150
def test_knit_index_unknown_method(self):
151
error = errors.KnitIndexUnknownMethod('http://host/foo.kndx',
153
self.assertEqual("Knit index http://host/foo.kndx does not have a"
154
" known method in options: ['bad', 'no-eol']",
157
def test_medium_not_connected(self):
158
error = errors.MediumNotConnected("a medium")
159
self.assertEqualDiff(
160
"The medium 'a medium' is not connected.", str(error))
162
def test_no_public_branch(self):
163
b = self.make_branch('.')
164
error = errors.NoPublicBranch(b)
165
url = urlutils.unescape_for_display(b.base, 'ascii')
166
self.assertEqualDiff(
167
'There is no public branch set for "%s".' % url, str(error))
169
27
def test_no_repo(self):
170
28
dir = bzrdir.BzrDir.create(self.get_url())
171
29
error = errors.NoRepositoryPresent(dir)
172
self.assertNotEqual(-1, str(error).find((dir.transport.clone('..').base)))
173
self.assertEqual(-1, str(error).find((dir.transport.base)))
175
def test_no_smart_medium(self):
176
error = errors.NoSmartMedium("a transport")
177
self.assertEqualDiff("The transport 'a transport' cannot tunnel the "
181
def test_no_help_topic(self):
182
error = errors.NoHelpTopic("topic")
183
self.assertEqualDiff("No help could be found for 'topic'. "
184
"Please use 'bzr help topics' to obtain a list of topics.",
187
def test_no_such_id(self):
188
error = errors.NoSuchId("atree", "anid")
189
self.assertEqualDiff("The file id \"anid\" is not present in the tree "
193
def test_no_such_revision_in_tree(self):
194
error = errors.NoSuchRevisionInTree("atree", "anid")
195
self.assertEqualDiff("The revision id {anid} is not present in the"
196
" tree atree.", str(error))
197
self.assertIsInstance(error, errors.NoSuchRevision)
199
def test_not_stacked(self):
200
error = errors.NotStacked('a branch')
201
self.assertEqualDiff("The branch 'a branch' is not stacked.",
204
def test_not_write_locked(self):
205
error = errors.NotWriteLocked('a thing to repr')
206
self.assertEqualDiff("'a thing to repr' is not write locked but needs "
210
def test_lock_failed(self):
211
error = errors.LockFailed('http://canonical.com/', 'readonly transport')
212
self.assertEqualDiff("Cannot lock http://canonical.com/: readonly transport",
214
self.assertFalse(error.internal_error)
216
def test_too_many_concurrent_requests(self):
217
error = errors.TooManyConcurrentRequests("a medium")
218
self.assertEqualDiff("The medium 'a medium' has reached its concurrent "
219
"request limit. Be sure to finish_writing and finish_reading on "
220
"the currently open request.",
223
def test_unavailable_representation(self):
224
error = errors.UnavailableRepresentation(('key',), "mpdiff", "fulltext")
225
self.assertEqualDiff("The encoding 'mpdiff' is not available for key "
226
"('key',) which is encoded as 'fulltext'.",
229
def test_unknown_hook(self):
230
error = errors.UnknownHook("branch", "foo")
231
self.assertEqualDiff("The branch hook 'foo' is unknown in this version"
234
error = errors.UnknownHook("tree", "bar")
235
self.assertEqualDiff("The tree hook 'bar' is unknown in this version"
239
def test_unstackable_branch_format(self):
242
error = errors.UnstackableBranchFormat(format, url)
243
self.assertEqualDiff(
244
"The branch '/foo'(foo) is not a stackable format. "
245
"You will need to upgrade the branch to permit branch stacking.",
248
def test_unstackable_repository_format(self):
251
error = errors.UnstackableRepositoryFormat(format, url)
252
self.assertEqualDiff(
253
"The repository '/foo'(foo) is not a stackable format. "
254
"You will need to upgrade the repository to permit branch stacking.",
30
self.assertNotEqual(-1, str(error).find(repr(dir.transport.clone('..').base)))
31
self.assertEqual(-1, str(error).find(repr(dir.transport.base)))
257
33
def test_up_to_date(self):
258
34
error = errors.UpToDateFormat(bzrdir.BzrDirFormat4())
268
44
"Please run bzr reconcile on this repository." %
269
45
repo.bzrdir.root_transport.base,
272
def test_read_error(self):
273
# a unicode path to check that %r is being used.
275
error = errors.ReadError(path)
276
self.assertEqualDiff("Error reading from u'a path'.", str(error))
278
def test_bad_index_format_signature(self):
279
error = errors.BadIndexFormatSignature("foo", "bar")
280
self.assertEqual("foo is not an index of type bar.",
283
def test_bad_index_data(self):
284
error = errors.BadIndexData("foo")
285
self.assertEqual("Error in data for index foo.",
288
def test_bad_index_duplicate_key(self):
289
error = errors.BadIndexDuplicateKey("foo", "bar")
290
self.assertEqual("The key 'foo' is already in index 'bar'.",
293
def test_bad_index_key(self):
294
error = errors.BadIndexKey("foo")
295
self.assertEqual("The key 'foo' is not a valid key.",
298
def test_bad_index_options(self):
299
error = errors.BadIndexOptions("foo")
300
self.assertEqual("Could not parse options for index foo.",
303
def test_bad_index_value(self):
304
error = errors.BadIndexValue("foo")
305
self.assertEqual("The value 'foo' is not a valid value.",
308
def test_bzrnewerror_is_deprecated(self):
309
class DeprecatedError(errors.BzrNewError):
311
self.callDeprecated(['BzrNewError was deprecated in bzr 0.13; '
312
'please convert DeprecatedError to use BzrError instead'],
315
def test_bzrerror_from_literal_string(self):
316
# Some code constructs BzrError from a literal string, in which case
317
# no further formatting is done. (I'm not sure raising the base class
318
# is a great idea, but if the exception is not intended to be caught
319
# perhaps no more is needed.)
321
raise errors.BzrError('this is my errors; %d is not expanded')
322
except errors.BzrError, e:
323
self.assertEqual('this is my errors; %d is not expanded', str(e))
325
def test_reading_completed(self):
326
error = errors.ReadingCompleted("a request")
327
self.assertEqualDiff("The MediumRequest 'a request' has already had "
328
"finish_reading called upon it - the request has been completed and"
329
" no more data may be read.",
332
def test_writing_completed(self):
333
error = errors.WritingCompleted("a request")
334
self.assertEqualDiff("The MediumRequest 'a request' has already had "
335
"finish_writing called upon it - accept bytes may not be called "
339
def test_writing_not_completed(self):
340
error = errors.WritingNotComplete("a request")
341
self.assertEqualDiff("The MediumRequest 'a request' has not has "
342
"finish_writing called upon it - until the write phase is complete"
343
" no data may be read.",
346
def test_transport_not_possible(self):
347
error = errors.TransportNotPossible('readonly', 'original error')
348
self.assertEqualDiff('Transport operation not possible:'
349
' readonly original error', str(error))
351
def assertSocketConnectionError(self, expected, *args, **kwargs):
352
"""Check the formatting of a SocketConnectionError exception"""
353
e = errors.SocketConnectionError(*args, **kwargs)
354
self.assertEqual(expected, str(e))
356
def test_socket_connection_error(self):
357
"""Test the formatting of SocketConnectionError"""
359
# There should be a default msg about failing to connect
360
# we only require a host name.
361
self.assertSocketConnectionError(
362
'Failed to connect to ahost',
365
# If port is None, we don't put :None
366
self.assertSocketConnectionError(
367
'Failed to connect to ahost',
369
# But if port is supplied we include it
370
self.assertSocketConnectionError(
371
'Failed to connect to ahost:22',
374
# We can also supply extra information about the error
375
# with or without a port
376
self.assertSocketConnectionError(
377
'Failed to connect to ahost:22; bogus error',
378
'ahost', port=22, orig_error='bogus error')
379
self.assertSocketConnectionError(
380
'Failed to connect to ahost; bogus error',
381
'ahost', orig_error='bogus error')
382
# An exception object can be passed rather than a string
383
orig_error = ValueError('bad value')
384
self.assertSocketConnectionError(
385
'Failed to connect to ahost; %s' % (str(orig_error),),
386
host='ahost', orig_error=orig_error)
388
# And we can supply a custom failure message
389
self.assertSocketConnectionError(
390
'Unable to connect to ssh host ahost:444; my_error',
391
host='ahost', port=444, msg='Unable to connect to ssh host',
392
orig_error='my_error')
394
def test_target_not_branch(self):
395
"""Test the formatting of TargetNotBranch."""
396
error = errors.TargetNotBranch('foo')
398
"Your branch does not have all of the revisions required in "
399
"order to merge this merge directive and the target "
400
"location specified in the merge directive is not a branch: "
403
def test_malformed_bug_identifier(self):
404
"""Test the formatting of MalformedBugIdentifier."""
405
error = errors.MalformedBugIdentifier('bogus', 'reason for bogosity')
407
"Did not understand bug identifier bogus: reason for bogosity",
410
def test_unknown_bug_tracker_abbreviation(self):
411
"""Test the formatting of UnknownBugTrackerAbbreviation."""
412
branch = self.make_branch('some_branch')
413
error = errors.UnknownBugTrackerAbbreviation('xxx', branch)
415
"Cannot find registered bug tracker called xxx on %s" % branch,
418
def test_unexpected_smart_server_response(self):
419
e = errors.UnexpectedSmartServerResponse(('not yes',))
421
"Could not understand response from smart server: ('not yes',)",
424
def test_unknown_container_format(self):
425
"""Test the formatting of UnknownContainerFormatError."""
426
e = errors.UnknownContainerFormatError('bad format string')
428
"Unrecognised container format: 'bad format string'",
431
def test_unexpected_end_of_container(self):
432
"""Test the formatting of UnexpectedEndOfContainerError."""
433
e = errors.UnexpectedEndOfContainerError()
435
"Unexpected end of container stream", str(e))
437
def test_unknown_record_type(self):
438
"""Test the formatting of UnknownRecordTypeError."""
439
e = errors.UnknownRecordTypeError("X")
441
"Unknown record type: 'X'",
444
def test_invalid_record(self):
445
"""Test the formatting of InvalidRecordError."""
446
e = errors.InvalidRecordError("xxx")
448
"Invalid record: xxx",
451
def test_container_has_excess_data(self):
452
"""Test the formatting of ContainerHasExcessDataError."""
453
e = errors.ContainerHasExcessDataError("excess bytes")
455
"Container has data after end marker: 'excess bytes'",
458
def test_duplicate_record_name_error(self):
459
"""Test the formatting of DuplicateRecordNameError."""
460
e = errors.DuplicateRecordNameError(u"n\xe5me".encode('utf-8'))
462
"Container has multiple records with the same name: n\xc3\xa5me",
465
def test_check_error(self):
466
# This has a member called 'message', which is problematic in
467
# python2.5 because that is a slot on the base Exception class
468
e = errors.BzrCheckError('example check failure')
470
"Internal check failed: example check failure",
472
self.assertTrue(e.internal_error)
474
def test_repository_data_stream_error(self):
475
"""Test the formatting of RepositoryDataStreamError."""
476
e = errors.RepositoryDataStreamError(u"my reason")
478
"Corrupt or incompatible data stream: my reason", str(e))
480
def test_immortal_pending_deletion_message(self):
481
err = errors.ImmortalPendingDeletion('foo')
483
"Unable to delete transform temporary directory foo. "
484
"Please examine foo to see if it contains any files "
485
"you wish to keep, and delete it when you are done.",
488
def test_unable_create_symlink(self):
489
err = errors.UnableCreateSymlink()
491
"Unable to create symlink on this platform",
493
err = errors.UnableCreateSymlink(path=u'foo')
495
"Unable to create symlink 'foo' on this platform",
497
err = errors.UnableCreateSymlink(path=u'\xb5')
499
"Unable to create symlink u'\\xb5' on this platform",
502
def test_invalid_url_join(self):
503
"""Test the formatting of InvalidURLJoin."""
504
e = errors.InvalidURLJoin('Reason', 'base path', ('args',))
506
"Invalid URL join request: Reason: 'base path' + ('args',)",
509
def test_incorrect_url(self):
510
err = errors.InvalidBugTrackerURL('foo', 'http://bug.com/')
512
("The URL for bug tracker \"foo\" doesn't contain {id}: "
516
def test_unable_encode_path(self):
517
err = errors.UnableEncodePath('foo', 'executable')
518
self.assertEquals("Unable to encode executable path 'foo' in "
519
"user encoding " + osutils.get_user_encoding(),
522
def test_unknown_format(self):
523
err = errors.UnknownFormatError('bar', kind='foo')
524
self.assertEquals("Unknown foo format: 'bar'", str(err))
526
def test_unknown_rules(self):
527
err = errors.UnknownRules(['foo', 'bar'])
528
self.assertEquals("Unknown rules detected: foo, bar.", str(err))
530
def test_hook_failed(self):
531
# Create an exc_info tuple by raising and catching an exception.
534
except ZeroDivisionError:
535
exc_info = sys.exc_info()
536
err = errors.HookFailed('hook stage', 'hook name', exc_info)
537
self.assertStartsWith(
538
str(err), 'Hook \'hook name\' during hook stage failed:\n')
540
str(err), 'integer division or modulo by zero')
542
def test_tip_change_rejected(self):
543
err = errors.TipChangeRejected(u'Unicode message\N{INTERROBANG}')
545
u'Tip change rejected: Unicode message\N{INTERROBANG}',
548
'Tip change rejected: Unicode message\xe2\x80\xbd',
551
def test_error_from_smart_server(self):
552
error_tuple = ('error', 'tuple')
553
err = errors.ErrorFromSmartServer(error_tuple)
555
"Error received from smart server: ('error', 'tuple')", str(err))
557
def test_untranslateable_error_from_smart_server(self):
558
error_tuple = ('error', 'tuple')
559
orig_err = errors.ErrorFromSmartServer(error_tuple)
560
err = errors.UnknownErrorFromSmartServer(orig_err)
562
"Server sent an unexpected error: ('error', 'tuple')", str(err))
565
class PassThroughError(errors.BzrError):
567
_fmt = """Pass through %(foo)s and %(bar)s"""
569
def __init__(self, foo, bar):
570
errors.BzrError.__init__(self, foo=foo, bar=bar)
573
class ErrorWithBadFormat(errors.BzrError):
575
_fmt = """One format specifier: %(thing)s"""
578
class ErrorWithNoFormat(errors.BzrError):
579
"""This class has a docstring but no format string."""
582
class TestErrorFormatting(TestCase):
584
def test_always_str(self):
585
e = PassThroughError(u'\xb5', 'bar')
586
self.assertIsInstance(e.__str__(), str)
587
# In Python str(foo) *must* return a real byte string
588
# not a Unicode string. The following line would raise a
589
# Unicode error, because it tries to call str() on the string
590
# returned from e.__str__(), and it has non ascii characters
592
self.assertEqual('Pass through \xc2\xb5 and bar', s)
594
def test_missing_format_string(self):
595
e = ErrorWithNoFormat(param='randomvalue')
596
s = self.callDeprecated(
597
['ErrorWithNoFormat uses its docstring as a format, it should use _fmt instead'],
601
"This class has a docstring but no format string.")
603
def test_mismatched_format_args(self):
604
# Even though ErrorWithBadFormat's format string does not match the
605
# arguments we constructing it with, we can still stringify an instance
606
# of this exception. The resulting string will say its unprintable.
607
e = ErrorWithBadFormat(not_thing='x')
608
self.assertStartsWith(
609
str(e), 'Unprintable exception ErrorWithBadFormat')
added
removed
bzrlib/tests/test_errors.py
