← 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: Vincent Ladeuil
  • Date: 2007-06-06 13:52:02 UTC
  • mto: (2485.8.44 bzr.connection.sharing)
  • mto: This revision was merged to the branch mainline in revision 2646.
  • Revision ID: v.ladeuil+lp@free.fr-20070606135202-mqhxcv6z57uce434
Fix merge multiple connections. Test suite *not* passing (sftp
refactoring pending but unrelated to merge).

* bzrlib/builtins.py:
(cmd_merge.run): Fix the multiple connections bug by reusing the
tramsport used to check for a bundle and keep all other used
transports in possible_transports.
(_merge_helper): Add a possible_transports parameter for
reuse.

* bzrlib/transport/__init__.py:
(Transport._reuse_for): By default, Transports are not reusable.
(ConnectedTransport._reuse_for): ConnectedTransports are reusable
under certain conditions.
(_urlRE): Fix misleading group name.
(_try_transport_factories): Moved after get_transport (another use
case for moved lines). The do_catching_redirections was
incorrectly inserted between get_transport and
_try_transport_factories.

* bzrlib/tests/test_transport.py:
(TestReusedTransports.test_reuse_same_transport)
(TestReusedTransports.test_don_t_reuse_different_transport): Add
more tests.

* bzrlib/merge.py:
(_get_tree, Merger.set_other): Add a possible_transports parameter
for reuse.

* bzrlib/bzrdir.py:
(BzrDir.open_containing): Add a possible_transports parameter for
reuse.

* bzrlib/branch.py:
(Branch.open_containing): Add a possible_transports parameter for
reuse.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_errors.py
1
 
# Copyright (C) 2006, 2007, 2008 Canonical Ltd
 
1
# Copyright (C) 2006, 2007 Canonical Ltd
2
2
#   Authors: Robert Collins <robert.collins@canonical.com>
3
3
#            and others
4
4
#
18
18
 
19
19
"""Tests for the formatting and construction of errors."""
20
20
 
21
 
import sys
22
21
from bzrlib import (
23
22
    bzrdir,
24
23
    errors,
25
 
    osutils,
26
 
    symbol_versioning,
27
 
    urlutils,
28
24
    )
29
25
from bzrlib.tests import TestCase, TestCaseWithTransport
30
26
 
31
27
 
 
28
# TODO: Make sure builtin exception class formats are consistent - e.g. should
 
29
# or shouldn't end with a full stop, etc.
 
30
 
 
31
 
32
32
class TestErrors(TestCaseWithTransport):
33
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
34
    def test_disabled_method(self):
56
35
        error = errors.DisabledMethod("class name")
57
36
        self.assertEqualDiff(
67
46
        self.assertEqualDiff('The prefix foo is in the help search path twice.',
68
47
            str(error))
69
48
 
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
 
 
110
49
    def test_inventory_modified(self):
111
50
        error = errors.InventoryModified("a tree to be repred")
112
51
        self.assertEqualDiff("The current inventory for the tree 'a tree to "
129
68
            "cannot be broken.",
130
69
            str(error))
131
70
 
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
 
 
145
71
    def test_knit_header_error(self):
146
72
        error = errors.KnitHeaderError('line foo\n', 'path/to/file')
147
73
        self.assertEqual("Knit header error: 'line foo\\n' unexpected"
148
 
                         " for file \"path/to/file\".", str(error))
 
74
                         " for file path/to/file", str(error))
149
75
 
150
76
    def test_knit_index_unknown_method(self):
151
77
        error = errors.KnitIndexUnknownMethod('http://host/foo.kndx',
158
84
        error = errors.MediumNotConnected("a medium")
159
85
        self.assertEqualDiff(
160
86
            "The medium 'a medium' is not connected.", str(error))
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
 
 
 
87
        
169
88
    def test_no_repo(self):
170
89
        dir = bzrdir.BzrDir.create(self.get_url())
171
90
        error = errors.NoRepositoryPresent(dir)
186
105
 
187
106
    def test_no_such_id(self):
188
107
        error = errors.NoSuchId("atree", "anid")
189
 
        self.assertEqualDiff("The file id \"anid\" is not present in the tree "
 
108
        self.assertEqualDiff("The file id anid is not present in the tree "
190
109
            "atree.",
191
110
            str(error))
192
111
 
193
112
    def test_no_such_revision_in_tree(self):
194
113
        error = errors.NoSuchRevisionInTree("atree", "anid")
195
 
        self.assertEqualDiff("The revision id {anid} is not present in the"
196
 
                             " tree atree.", str(error))
 
114
        self.assertEqualDiff("The revision id anid is not present in the tree "
 
115
            "atree.",
 
116
            str(error))
197
117
        self.assertIsInstance(error, errors.NoSuchRevision)
198
118
 
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
 
 
204
119
    def test_not_write_locked(self):
205
120
        error = errors.NotWriteLocked('a thing to repr')
206
121
        self.assertEqualDiff("'a thing to repr' is not write locked but needs "
207
122
            "to be.",
208
123
            str(error))
209
124
 
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)
 
125
    def test_read_only_lock_error(self):
 
126
        error = errors.ReadOnlyLockError('filename', 'error message')
 
127
        self.assertEqualDiff("Cannot acquire write lock on filename."
 
128
                             " error message", str(error))
215
129
 
216
130
    def test_too_many_concurrent_requests(self):
217
131
        error = errors.TooManyConcurrentRequests("a medium")
220
134
            "the currently open request.",
221
135
            str(error))
222
136
 
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'.",
227
 
            str(error))
228
 
 
229
137
    def test_unknown_hook(self):
230
138
        error = errors.UnknownHook("branch", "foo")
231
139
        self.assertEqualDiff("The branch hook 'foo' is unknown in this version"
236
144
            " of bzrlib.",
237
145
            str(error))
238
146
 
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
 
 
257
147
    def test_up_to_date(self):
258
148
        error = errors.UpToDateFormat(bzrdir.BzrDirFormat4())
259
149
        self.assertEqualDiff("The branch format Bazaar-NG branch, "
269
159
                             repo.bzrdir.root_transport.base,
270
160
                             str(error))
271
161
 
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
 
 
308
162
    def test_bzrnewerror_is_deprecated(self):
309
163
        class DeprecatedError(errors.BzrNewError):
310
164
            pass
344
198
            str(error))
345
199
 
346
200
    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))
 
201
        e = errors.TransportNotPossible('readonly', 'original error')
 
202
        self.assertEqual('Transport operation not possible:'
 
203
                         ' readonly original error', str(e))
350
204
 
351
205
    def assertSocketConnectionError(self, expected, *args, **kwargs):
352
206
        """Check the formatting of a SocketConnectionError exception"""
391
245
            host='ahost', port=444, msg='Unable to connect to ssh host',
392
246
            orig_error='my_error')
393
247
 
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
248
    def test_malformed_bug_identifier(self):
404
249
        """Test the formatting of MalformedBugIdentifier."""
405
250
        error = errors.MalformedBugIdentifier('bogus', 'reason for bogosity')
421
266
            "Could not understand response from smart server: ('not yes',)",
422
267
            str(e))
423
268
 
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")
574
 
 
575
 
    def test_must_have_working_tree(self):
576
 
        err = errors.MustHaveWorkingTree('foo', 'bar')
577
 
        self.assertEqual(str(err), "Branching 'bar'(foo) must create a"
578
 
                                   " working tree.")
579
 
 
580
 
    def test_invalid_shelf_id(self):
581
 
        invalid_id = "foo"
582
 
        err = errors.InvalidShelfId(invalid_id)
583
 
        self.assertEqual('"foo" is not a valid shelf id, '
584
 
            'try a number instead.', str(err))
585
 
 
586
269
 
587
270
class PassThroughError(errors.BzrError):
588
271
    
629
312
        e = ErrorWithBadFormat(not_thing='x')
630
313
        self.assertStartsWith(
631
314
            str(e), 'Unprintable exception ErrorWithBadFormat')
 
315