~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_errors.py

  • Committer: Aaron Bentley
  • Date: 2007-02-06 14:52:16 UTC
  • mfrom: (2266 +trunk)
  • mto: This revision was merged to the branch mainline in revision 2268.
  • Revision ID: abentley@panoramicfeedback.com-20070206145216-fcpi8o3ufvuzwbp9
Merge bzr.dev

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# Copyright (C) 2006, 2007, 2008 Canonical Ltd
 
1
# Copyright (C) 2006 Canonical Ltd
2
2
#   Authors: Robert Collins <robert.collins@canonical.com>
3
 
#            and others
4
3
#
5
4
# This program is free software; you can redistribute it and/or modify
6
5
# it under the terms of the GNU General Public License as published by
18
17
 
19
18
"""Tests for the formatting and construction of errors."""
20
19
 
21
 
import sys
22
20
from bzrlib import (
23
21
    bzrdir,
24
22
    errors,
25
 
    osutils,
26
 
    symbol_versioning,
27
 
    urlutils,
28
23
    )
29
24
from bzrlib.tests import TestCase, TestCaseWithTransport
30
25
 
31
26
 
 
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
 
32
31
class TestErrors(TestCaseWithTransport):
33
32
 
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_disabled_method(self):
49
 
        error = errors.DisabledMethod("class name")
50
 
        self.assertEqualDiff(
51
 
            "The smart server method 'class name' is disabled.", str(error))
52
 
 
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))
57
 
 
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.',
61
 
            str(error))
62
 
 
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}",
67
 
                             str(error))
68
 
 
69
 
    def test_incompatibleAPI(self):
70
 
        error = errors.IncompatibleAPI("module", (1, 2, 3), (4, 5, 6), (7, 8, 9))
71
 
        self.assertEqualDiff(
72
 
            'The API for "module" is not compatible with "(1, 2, 3)". '
73
 
            'It supports versions "(4, 5, 6)" to "(7, 8, 9)".',
74
 
            str(error))
75
 
 
76
 
    def test_inconsistent_delta(self):
77
 
        error = errors.InconsistentDelta('path', 'file-id', 'reason for foo')
78
 
        self.assertEqualDiff(
79
 
            "An inconsistent delta was supplied involving 'path', 'file-id'\n"
80
 
            "reason: reason for foo",
81
 
            str(error))
82
 
 
83
 
    def test_in_process_transport(self):
84
 
        error = errors.InProcessTransport('fpp')
85
 
        self.assertEqualDiff(
86
 
            "The transport 'fpp' is only accessible within this process.",
87
 
            str(error))
88
 
 
89
 
    def test_invalid_http_range(self):
90
 
        error = errors.InvalidHttpRange('path',
91
 
                                        'Content-Range: potatoes 0-00/o0oo0',
92
 
                                        'bad range')
93
 
        self.assertEquals("Invalid http range"
94
 
                          " 'Content-Range: potatoes 0-00/o0oo0'"
95
 
                          " for path: bad range",
96
 
                          str(error))
97
 
 
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",
101
 
                          str(error))
102
 
 
103
33
    def test_inventory_modified(self):
104
34
        error = errors.InventoryModified("a tree to be repred")
105
35
        self.assertEqualDiff("The current inventory for the tree 'a tree to "
116
46
        error = errors.InstallFailed([None])
117
47
        self.assertEqual("Could not install revisions:\nNone", str(error))
118
48
 
119
 
    def test_lock_active(self):
120
 
        error = errors.LockActive("lock description")
121
 
        self.assertEqualDiff("The lock for 'lock description' is in use and "
122
 
            "cannot be broken.",
123
 
            str(error))
124
 
 
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))
131
 
 
132
 
    def test_knit_data_stream_unknown(self):
133
 
        error = errors.KnitDataStreamUnknown(
134
 
            'stream format')
135
 
        self.assertEqual('Cannot parse knit data stream of format '
136
 
                         '"stream format".', str(error))
137
 
 
138
49
    def test_knit_header_error(self):
139
50
        error = errors.KnitHeaderError('line foo\n', 'path/to/file')
140
51
        self.assertEqual("Knit header error: 'line foo\\n' unexpected"
141
 
                         " for file \"path/to/file\".", str(error))
 
52
                         " for file path/to/file", str(error))
142
53
 
143
54
    def test_knit_index_unknown_method(self):
144
55
        error = errors.KnitIndexUnknownMethod('http://host/foo.kndx',
151
62
        error = errors.MediumNotConnected("a medium")
152
63
        self.assertEqualDiff(
153
64
            "The medium 'a medium' is not connected.", str(error))
154
 
 
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))
161
 
 
 
65
        
162
66
    def test_no_repo(self):
163
67
        dir = bzrdir.BzrDir.create(self.get_url())
164
68
        error = errors.NoRepositoryPresent(dir)
171
75
            "smart protocol.",
172
76
            str(error))
173
77
 
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.",
178
 
            str(error))
179
 
 
180
78
    def test_no_such_id(self):
181
79
        error = errors.NoSuchId("atree", "anid")
182
 
        self.assertEqualDiff("The file id \"anid\" is not present in the tree "
 
80
        self.assertEqualDiff("The file id anid is not present in the tree "
183
81
            "atree.",
184
82
            str(error))
185
83
 
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)
191
 
 
192
 
    def test_not_stacked(self):
193
 
        error = errors.NotStacked('a branch')
194
 
        self.assertEqualDiff("The branch 'a branch' is not stacked.",
195
 
            str(error))
196
 
 
197
84
    def test_not_write_locked(self):
198
85
        error = errors.NotWriteLocked('a thing to repr')
199
86
        self.assertEqualDiff("'a thing to repr' is not write locked but needs "
200
87
            "to be.",
201
88
            str(error))
202
89
 
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",
206
 
            str(error))
207
 
        self.assertFalse(error.internal_error)
208
 
 
209
90
    def test_too_many_concurrent_requests(self):
210
91
        error = errors.TooManyConcurrentRequests("a medium")
211
92
        self.assertEqualDiff("The medium 'a medium' has reached its concurrent "
212
93
            "request limit. Be sure to finish_writing and finish_reading on "
213
 
            "the currently open request.",
214
 
            str(error))
215
 
 
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'.",
 
94
            "the current request that is open.",
220
95
            str(error))
221
96
 
222
97
    def test_unknown_hook(self):
229
104
            " of bzrlib.",
230
105
            str(error))
231
106
 
232
 
    def test_unstackable_branch_format(self):
233
 
        format = u'foo'
234
 
        url = "/foo"
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.",
239
 
            str(error))
240
 
 
241
 
    def test_unstackable_repository_format(self):
242
 
        format = u'foo'
243
 
        url = "/foo"
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.",
248
 
            str(error))
249
 
 
250
107
    def test_up_to_date(self):
251
108
        error = errors.UpToDateFormat(bzrdir.BzrDirFormat4())
252
109
        self.assertEqualDiff("The branch format Bazaar-NG branch, "
262
119
                             repo.bzrdir.root_transport.base,
263
120
                             str(error))
264
121
 
265
 
    def test_read_error(self):
266
 
        # a unicode path to check that %r is being used.
267
 
        path = u'a path'
268
 
        error = errors.ReadError(path)
269
 
        self.assertEqualDiff("Error reading from u'a path'.", str(error))
270
 
 
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.",
274
 
            str(error))
275
 
 
276
 
    def test_bad_index_data(self):
277
 
        error = errors.BadIndexData("foo")
278
 
        self.assertEqual("Error in data for index foo.",
279
 
            str(error))
280
 
 
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'.",
284
 
            str(error))
285
 
 
286
 
    def test_bad_index_key(self):
287
 
        error = errors.BadIndexKey("foo")
288
 
        self.assertEqual("The key 'foo' is not a valid key.",
289
 
            str(error))
290
 
 
291
 
    def test_bad_index_options(self):
292
 
        error = errors.BadIndexOptions("foo")
293
 
        self.assertEqual("Could not parse options for index foo.",
294
 
            str(error))
295
 
 
296
 
    def test_bad_index_value(self):
297
 
        error = errors.BadIndexValue("foo")
298
 
        self.assertEqual("The value 'foo' is not a valid value.",
299
 
            str(error))
300
 
 
301
122
    def test_bzrnewerror_is_deprecated(self):
302
123
        class DeprecatedError(errors.BzrNewError):
303
124
            pass
337
158
            str(error))
338
159
 
339
160
    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))
 
161
        e = errors.TransportNotPossible('readonly', 'original error')
 
162
        self.assertEqual('Transport operation not possible:'
 
163
                         ' readonly original error', str(e))
343
164
 
344
165
    def assertSocketConnectionError(self, expected, *args, **kwargs):
345
166
        """Check the formatting of a SocketConnectionError exception"""
384
205
            host='ahost', port=444, msg='Unable to connect to ssh host',
385
206
            orig_error='my_error')
386
207
 
387
 
    def test_target_not_branch(self):
388
 
        """Test the formatting of TargetNotBranch."""
389
 
        error = errors.TargetNotBranch('foo')
390
 
        self.assertEqual(
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: "
394
 
            "foo.", str(error))
395
 
 
396
 
    def test_malformed_bug_identifier(self):
397
 
        """Test the formatting of MalformedBugIdentifier."""
398
 
        error = errors.MalformedBugIdentifier('bogus', 'reason for bogosity')
399
 
        self.assertEqual(
400
 
            "Did not understand bug identifier bogus: reason for bogosity",
401
 
            str(error))
402
 
 
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)
407
 
        self.assertEqual(
408
 
            "Cannot find registered bug tracker called xxx on %s" % branch,
409
 
            str(error))
410
 
 
411
 
    def test_unexpected_smart_server_response(self):
412
 
        e = errors.UnexpectedSmartServerResponse(('not yes',))
413
 
        self.assertEqual(
414
 
            "Could not understand response from smart server: ('not yes',)",
415
 
            str(e))
416
 
 
417
 
    def test_unknown_container_format(self):
418
 
        """Test the formatting of UnknownContainerFormatError."""
419
 
        e = errors.UnknownContainerFormatError('bad format string')
420
 
        self.assertEqual(
421
 
            "Unrecognised container format: 'bad format string'",
422
 
            str(e))
423
 
 
424
 
    def test_unexpected_end_of_container(self):
425
 
        """Test the formatting of UnexpectedEndOfContainerError."""
426
 
        e = errors.UnexpectedEndOfContainerError()
427
 
        self.assertEqual(
428
 
            "Unexpected end of container stream", str(e))
429
 
 
430
 
    def test_unknown_record_type(self):
431
 
        """Test the formatting of UnknownRecordTypeError."""
432
 
        e = errors.UnknownRecordTypeError("X")
433
 
        self.assertEqual(
434
 
            "Unknown record type: 'X'",
435
 
            str(e))
436
 
 
437
 
    def test_invalid_record(self):
438
 
        """Test the formatting of InvalidRecordError."""
439
 
        e = errors.InvalidRecordError("xxx")
440
 
        self.assertEqual(
441
 
            "Invalid record: xxx",
442
 
            str(e))
443
 
 
444
 
    def test_container_has_excess_data(self):
445
 
        """Test the formatting of ContainerHasExcessDataError."""
446
 
        e = errors.ContainerHasExcessDataError("excess bytes")
447
 
        self.assertEqual(
448
 
            "Container has data after end marker: 'excess bytes'",
449
 
            str(e))
450
 
 
451
 
    def test_duplicate_record_name_error(self):
452
 
        """Test the formatting of DuplicateRecordNameError."""
453
 
        e = errors.DuplicateRecordNameError(u"n\xe5me".encode('utf-8'))
454
 
        self.assertEqual(
455
 
            "Container has multiple records with the same name: n\xc3\xa5me",
456
 
            str(e))
457
 
        
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')
462
 
        self.assertEqual(
463
 
            "Internal check failed: example check failure",
464
 
            str(e))
465
 
        self.assertTrue(e.internal_error)
466
 
 
467
 
    def test_repository_data_stream_error(self):
468
 
        """Test the formatting of RepositoryDataStreamError."""
469
 
        e = errors.RepositoryDataStreamError(u"my reason")
470
 
        self.assertEqual(
471
 
            "Corrupt or incompatible data stream: my reason", str(e))
472
 
 
473
 
    def test_immortal_pending_deletion_message(self):
474
 
        err = errors.ImmortalPendingDeletion('foo')
475
 
        self.assertEquals(
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.",
479
 
            str(err))
480
 
 
481
 
    def test_unable_create_symlink(self):
482
 
        err = errors.UnableCreateSymlink()
483
 
        self.assertEquals(
484
 
            "Unable to create symlink on this platform",
485
 
            str(err))
486
 
        err = errors.UnableCreateSymlink(path=u'foo')
487
 
        self.assertEquals(
488
 
            "Unable to create symlink 'foo' on this platform",
489
 
            str(err))
490
 
        err = errors.UnableCreateSymlink(path=u'\xb5')
491
 
        self.assertEquals(
492
 
            "Unable to create symlink u'\\xb5' on this platform",
493
 
            str(err))
494
 
 
495
 
    def test_invalid_url_join(self):
496
 
        """Test the formatting of InvalidURLJoin."""
497
 
        e = errors.InvalidURLJoin('Reason', 'base path', ('args',))
498
 
        self.assertEqual(
499
 
            "Invalid URL join request: Reason: 'base path' + ('args',)",
500
 
            str(e))
501
 
 
502
 
    def test_incorrect_url(self):
503
 
        err = errors.InvalidBugTrackerURL('foo', 'http://bug.com/')
504
 
        self.assertEquals(
505
 
            ("The URL for bug tracker \"foo\" doesn't contain {id}: "
506
 
             "http://bug.com/"),
507
 
            str(err))
508
 
 
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(),
513
 
            str(err))
514
 
 
515
 
    def test_unknown_format(self):
516
 
        err = errors.UnknownFormatError('bar', kind='foo')
517
 
        self.assertEquals("Unknown foo format: 'bar'", str(err))
518
 
 
519
 
    def test_unknown_rules(self):
520
 
        err = errors.UnknownRules(['foo', 'bar'])
521
 
        self.assertEquals("Unknown rules detected: foo, bar.", str(err))
522
 
 
523
 
    def test_hook_failed(self):
524
 
        # Create an exc_info tuple by raising and catching an exception.
525
 
        try:
526
 
            1/0
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')
532
 
        self.assertEndsWith(
533
 
            str(err), 'integer division or modulo by zero')
534
 
 
535
 
    def test_tip_change_rejected(self):
536
 
        err = errors.TipChangeRejected(u'Unicode message\N{INTERROBANG}')
537
 
        self.assertEquals(
538
 
            u'Tip change rejected: Unicode message\N{INTERROBANG}',
539
 
            unicode(err))
540
 
        self.assertEquals(
541
 
            'Tip change rejected: Unicode message\xe2\x80\xbd',
542
 
            str(err))
543
208
 
544
209
 
545
210
class PassThroughError(errors.BzrError):
587
252
        e = ErrorWithBadFormat(not_thing='x')
588
253
        self.assertStartsWith(
589
254
            str(e), 'Unprintable exception ErrorWithBadFormat')
 
255