← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_errors.py

  • Committer: Jelmer Vernooij
  • Date: 2009-01-28 18:42:55 UTC
  • mto: This revision was merged to the branch mainline in revision 3968.
  • Revision ID: jelmer@samba.org-20090128184255-bdmklkvm83ltk191
https://launchpad.net/bugs/321183
Update NEWS

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_errors.py
1
 
# Copyright (C) 2006 Canonical Ltd
 
1
# Copyright (C) 2006, 2007, 2008 Canonical Ltd
2
2
#   Authors: Robert Collins <robert.collins@canonical.com>
 
3
#            and others
3
4
#
4
5
# This program is free software; you can redistribute it and/or modify
5
6
# it under the terms of the GNU General Public License as published by
17
18
 
18
19
"""Tests for the formatting and construction of errors."""
19
20
 
 
21
import sys
20
22
from bzrlib import (
21
23
    bzrdir,
22
24
    errors,
 
25
    osutils,
 
26
    symbol_versioning,
 
27
    urlutils,
23
28
    )
24
29
from bzrlib.tests import TestCase, TestCaseWithTransport
25
30
 
26
31
 
27
 
# TODO: Make sure builtin exception class formats are consistent - e.g. should
28
 
# or shouldn't end with a full stop, etc.
29
 
 
30
 
 
31
32
class TestErrors(TestCaseWithTransport):
32
33
 
 
34
    def test_bad_filename_encoding(self):
 
35
        error = errors.BadFilenameEncoding('bad/filen\xe5me', 'UTF-8')
 
36
        self.assertEqualDiff(
 
37
            "Filename 'bad/filen\\xe5me' is not valid in your current"
 
38
            " filesystem encoding UTF-8",
 
39
            str(error))
 
40
 
 
41
    def test_corrupt_dirstate(self):
 
42
        error = errors.CorruptDirstate('path/to/dirstate', 'the reason why')
 
43
        self.assertEqualDiff(
 
44
            "Inconsistency in dirstate file path/to/dirstate.\n"
 
45
            "Error: the reason why",
 
46
            str(error))
 
47
 
 
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\"",
 
53
            str(error))
 
54
 
 
55
    def test_disabled_method(self):
 
56
        error = errors.DisabledMethod("class name")
 
57
        self.assertEqualDiff(
 
58
            "The smart server method 'class name' is disabled.", str(error))
 
59
 
33
60
    def test_duplicate_file_id(self):
34
61
        error = errors.DuplicateFileId('a_file_id', 'foo')
35
62
        self.assertEqualDiff('File id {a_file_id} already exists in inventory'
36
63
                             ' as foo', str(error))
37
64
 
 
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.',
 
68
            str(error))
 
69
 
 
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}",
 
74
                             str(error))
 
75
 
 
76
    def test_incompatibleAPI(self):
 
77
        error = errors.IncompatibleAPI("module", (1, 2, 3), (4, 5, 6), (7, 8, 9))
 
78
        self.assertEqualDiff(
 
79
            'The API for "module" is not compatible with "(1, 2, 3)". '
 
80
            'It supports versions "(4, 5, 6)" to "(7, 8, 9)".',
 
81
            str(error))
 
82
 
 
83
    def test_inconsistent_delta(self):
 
84
        error = errors.InconsistentDelta('path', 'file-id', 'reason for foo')
 
85
        self.assertEqualDiff(
 
86
            "An inconsistent delta was supplied involving 'path', 'file-id'\n"
 
87
            "reason: reason for foo",
 
88
            str(error))
 
89
 
 
90
    def test_in_process_transport(self):
 
91
        error = errors.InProcessTransport('fpp')
 
92
        self.assertEqualDiff(
 
93
            "The transport 'fpp' is only accessible within this process.",
 
94
            str(error))
 
95
 
 
96
    def test_invalid_http_range(self):
 
97
        error = errors.InvalidHttpRange('path',
 
98
                                        'Content-Range: potatoes 0-00/o0oo0',
 
99
                                        'bad range')
 
100
        self.assertEquals("Invalid http range"
 
101
                          " 'Content-Range: potatoes 0-00/o0oo0'"
 
102
                          " for path: bad range",
 
103
                          str(error))
 
104
 
 
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",
 
108
                          str(error))
 
109
 
38
110
    def test_inventory_modified(self):
39
111
        error = errors.InventoryModified("a tree to be repred")
40
112
        self.assertEqualDiff("The current inventory for the tree 'a tree to "
57
129
            "cannot be broken.",
58
130
            str(error))
59
131
 
 
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))
 
138
 
 
139
    def test_knit_data_stream_unknown(self):
 
140
        error = errors.KnitDataStreamUnknown(
 
141
            'stream format')
 
142
        self.assertEqual('Cannot parse knit data stream of format '
 
143
                         '"stream format".', str(error))
 
144
 
60
145
    def test_knit_header_error(self):
61
146
        error = errors.KnitHeaderError('line foo\n', 'path/to/file')
62
147
        self.assertEqual("Knit header error: 'line foo\\n' unexpected"
63
 
                         " for file path/to/file", str(error))
 
148
                         " for file \"path/to/file\".", str(error))
64
149
 
65
150
    def test_knit_index_unknown_method(self):
66
151
        error = errors.KnitIndexUnknownMethod('http://host/foo.kndx',
73
158
        error = errors.MediumNotConnected("a medium")
74
159
        self.assertEqualDiff(
75
160
            "The medium 'a medium' is not connected.", str(error))
76
 
        
 
161
 
 
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))
 
168
 
77
169
    def test_no_repo(self):
78
170
        dir = bzrdir.BzrDir.create(self.get_url())
79
171
        error = errors.NoRepositoryPresent(dir)
86
178
            "smart protocol.",
87
179
            str(error))
88
180
 
 
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.",
 
185
            str(error))
 
186
 
89
187
    def test_no_such_id(self):
90
188
        error = errors.NoSuchId("atree", "anid")
91
 
        self.assertEqualDiff("The file id anid is not present in the tree "
 
189
        self.assertEqualDiff("The file id \"anid\" is not present in the tree "
92
190
            "atree.",
93
191
            str(error))
94
192
 
95
193
    def test_no_such_revision_in_tree(self):
96
194
        error = errors.NoSuchRevisionInTree("atree", "anid")
97
 
        self.assertEqualDiff("The revision id anid is not present in the tree "
98
 
            "atree.",
99
 
            str(error))
 
195
        self.assertEqualDiff("The revision id {anid} is not present in the"
 
196
                             " tree atree.", str(error))
100
197
        self.assertIsInstance(error, errors.NoSuchRevision)
101
198
 
 
199
    def test_not_stacked(self):
 
200
        error = errors.NotStacked('a branch')
 
201
        self.assertEqualDiff("The branch 'a branch' is not stacked.",
 
202
            str(error))
 
203
 
102
204
    def test_not_write_locked(self):
103
205
        error = errors.NotWriteLocked('a thing to repr')
104
206
        self.assertEqualDiff("'a thing to repr' is not write locked but needs "
105
207
            "to be.",
106
208
            str(error))
107
209
 
 
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",
 
213
            str(error))
 
214
        self.assertFalse(error.internal_error)
 
215
 
108
216
    def test_too_many_concurrent_requests(self):
109
217
        error = errors.TooManyConcurrentRequests("a medium")
110
218
        self.assertEqualDiff("The medium 'a medium' has reached its concurrent "
111
219
            "request limit. Be sure to finish_writing and finish_reading on "
112
 
            "the current request that is open.",
 
220
            "the currently open request.",
 
221
            str(error))
 
222
 
 
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'.",
113
227
            str(error))
114
228
 
115
229
    def test_unknown_hook(self):
122
236
            " of bzrlib.",
123
237
            str(error))
124
238
 
 
239
    def test_unstackable_branch_format(self):
 
240
        format = u'foo'
 
241
        url = "/foo"
 
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.",
 
246
            str(error))
 
247
 
 
248
    def test_unstackable_repository_format(self):
 
249
        format = u'foo'
 
250
        url = "/foo"
 
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.",
 
255
            str(error))
 
256
 
125
257
    def test_up_to_date(self):
126
258
        error = errors.UpToDateFormat(bzrdir.BzrDirFormat4())
127
259
        self.assertEqualDiff("The branch format Bazaar-NG branch, "
137
269
                             repo.bzrdir.root_transport.base,
138
270
                             str(error))
139
271
 
 
272
    def test_read_error(self):
 
273
        # a unicode path to check that %r is being used.
 
274
        path = u'a path'
 
275
        error = errors.ReadError(path)
 
276
        self.assertEqualDiff("Error reading from u'a path'.", str(error))
 
277
 
 
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.",
 
281
            str(error))
 
282
 
 
283
    def test_bad_index_data(self):
 
284
        error = errors.BadIndexData("foo")
 
285
        self.assertEqual("Error in data for index foo.",
 
286
            str(error))
 
287
 
 
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'.",
 
291
            str(error))
 
292
 
 
293
    def test_bad_index_key(self):
 
294
        error = errors.BadIndexKey("foo")
 
295
        self.assertEqual("The key 'foo' is not a valid key.",
 
296
            str(error))
 
297
 
 
298
    def test_bad_index_options(self):
 
299
        error = errors.BadIndexOptions("foo")
 
300
        self.assertEqual("Could not parse options for index foo.",
 
301
            str(error))
 
302
 
 
303
    def test_bad_index_value(self):
 
304
        error = errors.BadIndexValue("foo")
 
305
        self.assertEqual("The value 'foo' is not a valid value.",
 
306
            str(error))
 
307
 
140
308
    def test_bzrnewerror_is_deprecated(self):
141
309
        class DeprecatedError(errors.BzrNewError):
142
310
            pass
176
344
            str(error))
177
345
 
178
346
    def test_transport_not_possible(self):
179
 
        e = errors.TransportNotPossible('readonly', 'original error')
180
 
        self.assertEqual('Transport operation not possible:'
181
 
                         ' readonly original error', str(e))
 
347
        error = errors.TransportNotPossible('readonly', 'original error')
 
348
        self.assertEqualDiff('Transport operation not possible:'
 
349
                         ' readonly original error', str(error))
182
350
 
183
351
    def assertSocketConnectionError(self, expected, *args, **kwargs):
184
352
        """Check the formatting of a SocketConnectionError exception"""
223
391
            host='ahost', port=444, msg='Unable to connect to ssh host',
224
392
            orig_error='my_error')
225
393
 
 
394
    def test_target_not_branch(self):
 
395
        """Test the formatting of TargetNotBranch."""
 
396
        error = errors.TargetNotBranch('foo')
 
397
        self.assertEqual(
 
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: "
 
401
            "foo.", str(error))
 
402
 
 
403
    def test_malformed_bug_identifier(self):
 
404
        """Test the formatting of MalformedBugIdentifier."""
 
405
        error = errors.MalformedBugIdentifier('bogus', 'reason for bogosity')
 
406
        self.assertEqual(
 
407
            "Did not understand bug identifier bogus: reason for bogosity",
 
408
            str(error))
 
409
 
 
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)
 
414
        self.assertEqual(
 
415
            "Cannot find registered bug tracker called xxx on %s" % branch,
 
416
            str(error))
 
417
 
 
418
    def test_unexpected_smart_server_response(self):
 
419
        e = errors.UnexpectedSmartServerResponse(('not yes',))
 
420
        self.assertEqual(
 
421
            "Could not understand response from smart server: ('not yes',)",
 
422
            str(e))
 
423
 
 
424
    def test_unknown_container_format(self):
 
425
        """Test the formatting of UnknownContainerFormatError."""
 
426
        e = errors.UnknownContainerFormatError('bad format string')
 
427
        self.assertEqual(
 
428
            "Unrecognised container format: 'bad format string'",
 
429
            str(e))
 
430
 
 
431
    def test_unexpected_end_of_container(self):
 
432
        """Test the formatting of UnexpectedEndOfContainerError."""
 
433
        e = errors.UnexpectedEndOfContainerError()
 
434
        self.assertEqual(
 
435
            "Unexpected end of container stream", str(e))
 
436
 
 
437
    def test_unknown_record_type(self):
 
438
        """Test the formatting of UnknownRecordTypeError."""
 
439
        e = errors.UnknownRecordTypeError("X")
 
440
        self.assertEqual(
 
441
            "Unknown record type: 'X'",
 
442
            str(e))
 
443
 
 
444
    def test_invalid_record(self):
 
445
        """Test the formatting of InvalidRecordError."""
 
446
        e = errors.InvalidRecordError("xxx")
 
447
        self.assertEqual(
 
448
            "Invalid record: xxx",
 
449
            str(e))
 
450
 
 
451
    def test_container_has_excess_data(self):
 
452
        """Test the formatting of ContainerHasExcessDataError."""
 
453
        e = errors.ContainerHasExcessDataError("excess bytes")
 
454
        self.assertEqual(
 
455
            "Container has data after end marker: 'excess bytes'",
 
456
            str(e))
 
457
 
 
458
    def test_duplicate_record_name_error(self):
 
459
        """Test the formatting of DuplicateRecordNameError."""
 
460
        e = errors.DuplicateRecordNameError(u"n\xe5me".encode('utf-8'))
 
461
        self.assertEqual(
 
462
            "Container has multiple records with the same name: n\xc3\xa5me",
 
463
            str(e))
 
464
        
 
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')
 
469
        self.assertEqual(
 
470
            "Internal check failed: example check failure",
 
471
            str(e))
 
472
        self.assertTrue(e.internal_error)
 
473
 
 
474
    def test_repository_data_stream_error(self):
 
475
        """Test the formatting of RepositoryDataStreamError."""
 
476
        e = errors.RepositoryDataStreamError(u"my reason")
 
477
        self.assertEqual(
 
478
            "Corrupt or incompatible data stream: my reason", str(e))
 
479
 
 
480
    def test_immortal_pending_deletion_message(self):
 
481
        err = errors.ImmortalPendingDeletion('foo')
 
482
        self.assertEquals(
 
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.",
 
486
            str(err))
 
487
 
 
488
    def test_unable_create_symlink(self):
 
489
        err = errors.UnableCreateSymlink()
 
490
        self.assertEquals(
 
491
            "Unable to create symlink on this platform",
 
492
            str(err))
 
493
        err = errors.UnableCreateSymlink(path=u'foo')
 
494
        self.assertEquals(
 
495
            "Unable to create symlink 'foo' on this platform",
 
496
            str(err))
 
497
        err = errors.UnableCreateSymlink(path=u'\xb5')
 
498
        self.assertEquals(
 
499
            "Unable to create symlink u'\\xb5' on this platform",
 
500
            str(err))
 
501
 
 
502
    def test_invalid_url_join(self):
 
503
        """Test the formatting of InvalidURLJoin."""
 
504
        e = errors.InvalidURLJoin('Reason', 'base path', ('args',))
 
505
        self.assertEqual(
 
506
            "Invalid URL join request: Reason: 'base path' + ('args',)",
 
507
            str(e))
 
508
 
 
509
    def test_incorrect_url(self):
 
510
        err = errors.InvalidBugTrackerURL('foo', 'http://bug.com/')
 
511
        self.assertEquals(
 
512
            ("The URL for bug tracker \"foo\" doesn't contain {id}: "
 
513
             "http://bug.com/"),
 
514
            str(err))
 
515
 
 
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(),
 
520
            str(err))
 
521
 
 
522
    def test_unknown_format(self):
 
523
        err = errors.UnknownFormatError('bar', kind='foo')
 
524
        self.assertEquals("Unknown foo format: 'bar'", str(err))
 
525
 
 
526
    def test_unknown_rules(self):
 
527
        err = errors.UnknownRules(['foo', 'bar'])
 
528
        self.assertEquals("Unknown rules detected: foo, bar.", str(err))
 
529
 
 
530
    def test_hook_failed(self):
 
531
        # Create an exc_info tuple by raising and catching an exception.
 
532
        try:
 
533
            1/0
 
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')
 
539
        self.assertEndsWith(
 
540
            str(err), 'integer division or modulo by zero')
 
541
 
 
542
    def test_tip_change_rejected(self):
 
543
        err = errors.TipChangeRejected(u'Unicode message\N{INTERROBANG}')
 
544
        self.assertEquals(
 
545
            u'Tip change rejected: Unicode message\N{INTERROBANG}',
 
546
            unicode(err))
 
547
        self.assertEquals(
 
548
            'Tip change rejected: Unicode message\xe2\x80\xbd',
 
549
            str(err))
 
550
 
 
551
    def test_error_from_smart_server(self):
 
552
        error_tuple = ('error', 'tuple')
 
553
        err = errors.ErrorFromSmartServer(error_tuple)
 
554
        self.assertEquals(
 
555
            "Error received from smart server: ('error', 'tuple')", str(err))
 
556
 
 
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)
 
561
        self.assertEquals(
 
562
            "Server sent an unexpected error: ('error', 'tuple')", str(err))
 
563
    
 
564
    def test_smart_message_handler_error(self):
 
565
        # Make an exc_info tuple.
 
566
        try:
 
567
            raise Exception("example error")
 
568
        except Exception:
 
569
            exc_info = sys.exc_info()
 
570
        err = errors.SmartMessageHandlerError(exc_info)
 
571
        self.assertStartsWith(
 
572
            str(err), "The message handler raised an exception:\n")
 
573
        self.assertEndsWith(str(err), "Exception: example error\n")
226
574
 
227
575
 
228
576
class PassThroughError(errors.BzrError):
270
618
        e = ErrorWithBadFormat(not_thing='x')
271
619
        self.assertStartsWith(
272
620
            str(e), 'Unprintable exception ErrorWithBadFormat')
273