14
15
# You should have received a copy of the GNU General Public License
15
16
# along with this program; if not, write to the Free Software
16
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
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_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_jail_break(self):
118
error = errors.JailBreak("some url")
119
self.assertEqualDiff("An attempt to access a url outside the server"
120
" jail was made: 'some url'.",
123
def test_lock_active(self):
124
error = errors.LockActive("lock description")
125
self.assertEqualDiff("The lock for 'lock description' is in use and "
129
def test_knit_data_stream_incompatible(self):
130
error = errors.KnitDataStreamIncompatible(
131
'stream format', 'target format')
132
self.assertEqual('Cannot insert knit data stream of format '
133
'"stream format" into knit of format '
134
'"target format".', str(error))
136
def test_knit_data_stream_unknown(self):
137
error = errors.KnitDataStreamUnknown(
139
self.assertEqual('Cannot parse knit data stream of format '
140
'"stream format".', str(error))
142
def test_knit_header_error(self):
143
error = errors.KnitHeaderError('line foo\n', 'path/to/file')
144
self.assertEqual("Knit header error: 'line foo\\n' unexpected"
145
" for file \"path/to/file\".", str(error))
147
def test_knit_index_unknown_method(self):
148
error = errors.KnitIndexUnknownMethod('http://host/foo.kndx',
150
self.assertEqual("Knit index http://host/foo.kndx does not have a"
151
" known method in options: ['bad', 'no-eol']",
154
def test_medium_not_connected(self):
155
error = errors.MediumNotConnected("a medium")
156
self.assertEqualDiff(
157
"The medium 'a medium' is not connected.", str(error))
159
def test_no_public_branch(self):
160
b = self.make_branch('.')
161
error = errors.NoPublicBranch(b)
162
url = urlutils.unescape_for_display(b.base, 'ascii')
163
self.assertEqualDiff(
164
'There is no public branch set for "%s".' % url, str(error))
27
166
def test_no_repo(self):
28
167
dir = bzrdir.BzrDir.create(self.get_url())
29
168
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)))
169
self.assertNotEqual(-1, str(error).find((dir.transport.clone('..').base)))
170
self.assertEqual(-1, str(error).find((dir.transport.base)))
172
def test_no_smart_medium(self):
173
error = errors.NoSmartMedium("a transport")
174
self.assertEqualDiff("The transport 'a transport' cannot tunnel the "
178
def test_no_help_topic(self):
179
error = errors.NoHelpTopic("topic")
180
self.assertEqualDiff("No help could be found for 'topic'. "
181
"Please use 'bzr help topics' to obtain a list of topics.",
184
def test_no_such_id(self):
185
error = errors.NoSuchId("atree", "anid")
186
self.assertEqualDiff("The file id \"anid\" is not present in the tree "
190
def test_no_such_revision_in_tree(self):
191
error = errors.NoSuchRevisionInTree("atree", "anid")
192
self.assertEqualDiff("The revision id {anid} is not present in the"
193
" tree atree.", str(error))
194
self.assertIsInstance(error, errors.NoSuchRevision)
196
def test_not_stacked(self):
197
error = errors.NotStacked('a branch')
198
self.assertEqualDiff("The branch 'a branch' is not stacked.",
201
def test_not_write_locked(self):
202
error = errors.NotWriteLocked('a thing to repr')
203
self.assertEqualDiff("'a thing to repr' is not write locked but needs "
207
def test_lock_failed(self):
208
error = errors.LockFailed('http://canonical.com/', 'readonly transport')
209
self.assertEqualDiff("Cannot lock http://canonical.com/: readonly transport",
211
self.assertFalse(error.internal_error)
213
def test_too_many_concurrent_requests(self):
214
error = errors.TooManyConcurrentRequests("a medium")
215
self.assertEqualDiff("The medium 'a medium' has reached its concurrent "
216
"request limit. Be sure to finish_writing and finish_reading on "
217
"the currently open request.",
220
def test_unavailable_representation(self):
221
error = errors.UnavailableRepresentation(('key',), "mpdiff", "fulltext")
222
self.assertEqualDiff("The encoding 'mpdiff' is not available for key "
223
"('key',) which is encoded as 'fulltext'.",
226
def test_unknown_hook(self):
227
error = errors.UnknownHook("branch", "foo")
228
self.assertEqualDiff("The branch hook 'foo' is unknown in this version"
231
error = errors.UnknownHook("tree", "bar")
232
self.assertEqualDiff("The tree hook 'bar' is unknown in this version"
236
def test_unstackable_branch_format(self):
239
error = errors.UnstackableBranchFormat(format, url)
240
self.assertEqualDiff(
241
"The branch '/foo'(foo) is not a stackable format. "
242
"You will need to upgrade the branch to permit branch stacking.",
245
def test_unstackable_location(self):
246
error = errors.UnstackableLocationError('foo', 'bar')
247
self.assertEqualDiff("The branch 'foo' cannot be stacked on 'bar'.",
250
def test_unstackable_repository_format(self):
253
error = errors.UnstackableRepositoryFormat(format, url)
254
self.assertEqualDiff(
255
"The repository '/foo'(foo) is not a stackable format. "
256
"You will need to upgrade the repository to permit branch stacking.",
33
259
def test_up_to_date(self):
34
260
error = errors.UpToDateFormat(bzrdir.BzrDirFormat4())
35
self.assertEqualDiff("The branch format Bazaar-NG branch, "
36
"format 0.0.4 is already at the most "
261
self.assertEqualDiff("The branch format All-in-one "
262
"format 4 is already at the most "
44
270
"Please run bzr reconcile on this repository." %
45
271
repo.bzrdir.root_transport.base,
274
def test_read_error(self):
275
# a unicode path to check that %r is being used.
277
error = errors.ReadError(path)
278
self.assertEqualDiff("Error reading from u'a path'.", str(error))
280
def test_bad_index_format_signature(self):
281
error = errors.BadIndexFormatSignature("foo", "bar")
282
self.assertEqual("foo is not an index of type bar.",
285
def test_bad_index_data(self):
286
error = errors.BadIndexData("foo")
287
self.assertEqual("Error in data for index foo.",
290
def test_bad_index_duplicate_key(self):
291
error = errors.BadIndexDuplicateKey("foo", "bar")
292
self.assertEqual("The key 'foo' is already in index 'bar'.",
295
def test_bad_index_key(self):
296
error = errors.BadIndexKey("foo")
297
self.assertEqual("The key 'foo' is not a valid key.",
300
def test_bad_index_options(self):
301
error = errors.BadIndexOptions("foo")
302
self.assertEqual("Could not parse options for index foo.",
305
def test_bad_index_value(self):
306
error = errors.BadIndexValue("foo")
307
self.assertEqual("The value 'foo' is not a valid value.",
310
def test_bzrnewerror_is_deprecated(self):
311
class DeprecatedError(errors.BzrNewError):
313
self.callDeprecated(['BzrNewError was deprecated in bzr 0.13; '
314
'please convert DeprecatedError to use BzrError instead'],
317
def test_bzrerror_from_literal_string(self):
318
# Some code constructs BzrError from a literal string, in which case
319
# no further formatting is done. (I'm not sure raising the base class
320
# is a great idea, but if the exception is not intended to be caught
321
# perhaps no more is needed.)
323
raise errors.BzrError('this is my errors; %d is not expanded')
324
except errors.BzrError, e:
325
self.assertEqual('this is my errors; %d is not expanded', str(e))
327
def test_reading_completed(self):
328
error = errors.ReadingCompleted("a request")
329
self.assertEqualDiff("The MediumRequest 'a request' has already had "
330
"finish_reading called upon it - the request has been completed and"
331
" no more data may be read.",
334
def test_writing_completed(self):
335
error = errors.WritingCompleted("a request")
336
self.assertEqualDiff("The MediumRequest 'a request' has already had "
337
"finish_writing called upon it - accept bytes may not be called "
341
def test_writing_not_completed(self):
342
error = errors.WritingNotComplete("a request")
343
self.assertEqualDiff("The MediumRequest 'a request' has not has "
344
"finish_writing called upon it - until the write phase is complete"
345
" no data may be read.",
348
def test_transport_not_possible(self):
349
error = errors.TransportNotPossible('readonly', 'original error')
350
self.assertEqualDiff('Transport operation not possible:'
351
' readonly original error', str(error))
353
def assertSocketConnectionError(self, expected, *args, **kwargs):
354
"""Check the formatting of a SocketConnectionError exception"""
355
e = errors.SocketConnectionError(*args, **kwargs)
356
self.assertEqual(expected, str(e))
358
def test_socket_connection_error(self):
359
"""Test the formatting of SocketConnectionError"""
361
# There should be a default msg about failing to connect
362
# we only require a host name.
363
self.assertSocketConnectionError(
364
'Failed to connect to ahost',
367
# If port is None, we don't put :None
368
self.assertSocketConnectionError(
369
'Failed to connect to ahost',
371
# But if port is supplied we include it
372
self.assertSocketConnectionError(
373
'Failed to connect to ahost:22',
376
# We can also supply extra information about the error
377
# with or without a port
378
self.assertSocketConnectionError(
379
'Failed to connect to ahost:22; bogus error',
380
'ahost', port=22, orig_error='bogus error')
381
self.assertSocketConnectionError(
382
'Failed to connect to ahost; bogus error',
383
'ahost', orig_error='bogus error')
384
# An exception object can be passed rather than a string
385
orig_error = ValueError('bad value')
386
self.assertSocketConnectionError(
387
'Failed to connect to ahost; %s' % (str(orig_error),),
388
host='ahost', orig_error=orig_error)
390
# And we can supply a custom failure message
391
self.assertSocketConnectionError(
392
'Unable to connect to ssh host ahost:444; my_error',
393
host='ahost', port=444, msg='Unable to connect to ssh host',
394
orig_error='my_error')
396
def test_target_not_branch(self):
397
"""Test the formatting of TargetNotBranch."""
398
error = errors.TargetNotBranch('foo')
400
"Your branch does not have all of the revisions required in "
401
"order to merge this merge directive and the target "
402
"location specified in the merge directive is not a branch: "
405
def test_malformed_bug_identifier(self):
406
"""Test the formatting of MalformedBugIdentifier."""
407
error = errors.MalformedBugIdentifier('bogus', 'reason for bogosity')
409
'Did not understand bug identifier bogus: reason for bogosity. '
410
'See "bzr help bugs" for more information on this feature.',
413
def test_unknown_bug_tracker_abbreviation(self):
414
"""Test the formatting of UnknownBugTrackerAbbreviation."""
415
branch = self.make_branch('some_branch')
416
error = errors.UnknownBugTrackerAbbreviation('xxx', branch)
418
"Cannot find registered bug tracker called xxx on %s" % branch,
421
def test_unexpected_smart_server_response(self):
422
e = errors.UnexpectedSmartServerResponse(('not yes',))
424
"Could not understand response from smart server: ('not yes',)",
427
def test_unknown_container_format(self):
428
"""Test the formatting of UnknownContainerFormatError."""
429
e = errors.UnknownContainerFormatError('bad format string')
431
"Unrecognised container format: 'bad format string'",
434
def test_unexpected_end_of_container(self):
435
"""Test the formatting of UnexpectedEndOfContainerError."""
436
e = errors.UnexpectedEndOfContainerError()
438
"Unexpected end of container stream", str(e))
440
def test_unknown_record_type(self):
441
"""Test the formatting of UnknownRecordTypeError."""
442
e = errors.UnknownRecordTypeError("X")
444
"Unknown record type: 'X'",
447
def test_invalid_record(self):
448
"""Test the formatting of InvalidRecordError."""
449
e = errors.InvalidRecordError("xxx")
451
"Invalid record: xxx",
454
def test_container_has_excess_data(self):
455
"""Test the formatting of ContainerHasExcessDataError."""
456
e = errors.ContainerHasExcessDataError("excess bytes")
458
"Container has data after end marker: 'excess bytes'",
461
def test_duplicate_record_name_error(self):
462
"""Test the formatting of DuplicateRecordNameError."""
463
e = errors.DuplicateRecordNameError(u"n\xe5me".encode('utf-8'))
465
"Container has multiple records with the same name: n\xc3\xa5me",
468
def test_check_error(self):
469
# This has a member called 'message', which is problematic in
470
# python2.5 because that is a slot on the base Exception class
471
e = errors.BzrCheckError('example check failure')
473
"Internal check failed: example check failure",
475
self.assertTrue(e.internal_error)
477
def test_repository_data_stream_error(self):
478
"""Test the formatting of RepositoryDataStreamError."""
479
e = errors.RepositoryDataStreamError(u"my reason")
481
"Corrupt or incompatible data stream: my reason", str(e))
483
def test_immortal_pending_deletion_message(self):
484
err = errors.ImmortalPendingDeletion('foo')
486
"Unable to delete transform temporary directory foo. "
487
"Please examine foo to see if it contains any files "
488
"you wish to keep, and delete it when you are done.",
491
def test_unable_create_symlink(self):
492
err = errors.UnableCreateSymlink()
494
"Unable to create symlink on this platform",
496
err = errors.UnableCreateSymlink(path=u'foo')
498
"Unable to create symlink 'foo' on this platform",
500
err = errors.UnableCreateSymlink(path=u'\xb5')
502
"Unable to create symlink u'\\xb5' on this platform",
505
def test_invalid_url_join(self):
506
"""Test the formatting of InvalidURLJoin."""
507
e = errors.InvalidURLJoin('Reason', 'base path', ('args',))
509
"Invalid URL join request: Reason: 'base path' + ('args',)",
512
def test_incorrect_url(self):
513
err = errors.InvalidBugTrackerURL('foo', 'http://bug.com/')
515
("The URL for bug tracker \"foo\" doesn't contain {id}: "
519
def test_unable_encode_path(self):
520
err = errors.UnableEncodePath('foo', 'executable')
521
self.assertEquals("Unable to encode executable path 'foo' in "
522
"user encoding " + osutils.get_user_encoding(),
525
def test_unknown_format(self):
526
err = errors.UnknownFormatError('bar', kind='foo')
527
self.assertEquals("Unknown foo format: 'bar'", str(err))
529
def test_unknown_rules(self):
530
err = errors.UnknownRules(['foo', 'bar'])
531
self.assertEquals("Unknown rules detected: foo, bar.", str(err))
533
def test_hook_failed(self):
534
# Create an exc_info tuple by raising and catching an exception.
537
except ZeroDivisionError:
538
exc_info = sys.exc_info()
539
err = errors.HookFailed('hook stage', 'hook name', exc_info)
540
self.assertStartsWith(
541
str(err), 'Hook \'hook name\' during hook stage failed:\n')
543
str(err), 'integer division or modulo by zero')
545
def test_tip_change_rejected(self):
546
err = errors.TipChangeRejected(u'Unicode message\N{INTERROBANG}')
548
u'Tip change rejected: Unicode message\N{INTERROBANG}',
551
'Tip change rejected: Unicode message\xe2\x80\xbd',
554
def test_error_from_smart_server(self):
555
error_tuple = ('error', 'tuple')
556
err = errors.ErrorFromSmartServer(error_tuple)
558
"Error received from smart server: ('error', 'tuple')", str(err))
560
def test_untranslateable_error_from_smart_server(self):
561
error_tuple = ('error', 'tuple')
562
orig_err = errors.ErrorFromSmartServer(error_tuple)
563
err = errors.UnknownErrorFromSmartServer(orig_err)
565
"Server sent an unexpected error: ('error', 'tuple')", str(err))
567
def test_smart_message_handler_error(self):
568
# Make an exc_info tuple.
570
raise Exception("example error")
572
exc_info = sys.exc_info()
573
err = errors.SmartMessageHandlerError(exc_info)
574
self.assertStartsWith(
575
str(err), "The message handler raised an exception:\n")
576
self.assertEndsWith(str(err), "Exception: example error\n")
578
def test_must_have_working_tree(self):
579
err = errors.MustHaveWorkingTree('foo', 'bar')
580
self.assertEqual(str(err), "Branching 'bar'(foo) must create a"
583
def test_no_such_view(self):
584
err = errors.NoSuchView('foo')
585
self.assertEquals("No such view: foo.", str(err))
587
def test_views_not_supported(self):
588
err = errors.ViewsNotSupported('atree')
590
self.assertStartsWith(err_str, "Views are not supported by ")
591
self.assertEndsWith(err_str, "; use 'bzr upgrade' to change your "
592
"tree to a later format.")
594
def test_file_outside_view(self):
595
err = errors.FileOutsideView('baz', ['foo', 'bar'])
596
self.assertEquals('Specified file "baz" is outside the current view: '
597
'foo, bar', str(err))
599
def test_invalid_shelf_id(self):
601
err = errors.InvalidShelfId(invalid_id)
602
self.assertEqual('"foo" is not a valid shelf id, '
603
'try a number instead.', str(err))
605
def test_unresumable_write_group(self):
607
wg_tokens = ['token']
609
err = errors.UnresumableWriteGroup(repo, wg_tokens, reason)
611
"Repository dummy repo cannot resume write group "
612
"['token']: a reason", str(err))
614
def test_unsuspendable_write_group(self):
616
err = errors.UnsuspendableWriteGroup(repo)
618
'Repository dummy repo cannot suspend a write group.', str(err))
621
class PassThroughError(errors.BzrError):
623
_fmt = """Pass through %(foo)s and %(bar)s"""
625
def __init__(self, foo, bar):
626
errors.BzrError.__init__(self, foo=foo, bar=bar)
629
class ErrorWithBadFormat(errors.BzrError):
631
_fmt = """One format specifier: %(thing)s"""
634
class ErrorWithNoFormat(errors.BzrError):
635
"""This class has a docstring but no format string."""
638
class TestErrorFormatting(TestCase):
640
def test_always_str(self):
641
e = PassThroughError(u'\xb5', 'bar')
642
self.assertIsInstance(e.__str__(), str)
643
# In Python str(foo) *must* return a real byte string
644
# not a Unicode string. The following line would raise a
645
# Unicode error, because it tries to call str() on the string
646
# returned from e.__str__(), and it has non ascii characters
648
self.assertEqual('Pass through \xc2\xb5 and bar', s)
650
def test_missing_format_string(self):
651
e = ErrorWithNoFormat(param='randomvalue')
652
s = self.callDeprecated(
653
['ErrorWithNoFormat uses its docstring as a format, it should use _fmt instead'],
657
"This class has a docstring but no format string.")
659
def test_mismatched_format_args(self):
660
# Even though ErrorWithBadFormat's format string does not match the
661
# arguments we constructing it with, we can still stringify an instance
662
# of this exception. The resulting string will say its unprintable.
663
e = ErrorWithBadFormat(not_thing='x')
664
self.assertStartsWith(
665
str(e), 'Unprintable exception ErrorWithBadFormat')
added
removed
bzrlib/tests/test_errors.py
