/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to breezy/tests/test_errors.py

  • Committer: Jelmer Vernooij
  • Date: 2017-07-30 21:23:44 UTC
  • mto: This revision was merged to the branch mainline in revision 6743.
  • Revision ID: jelmer@jelmer.uk-20170730212344-mumrkz1c4jbm9yzc
review comments.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/tests/test_errors.py
1
 
# Copyright (C) 2006-2010 Canonical Ltd
 
1
# Copyright (C) 2006-2012, 2016 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
16
16
 
17
17
"""Tests for the formatting and construction of errors."""
18
18
 
 
19
import inspect
 
20
import re
19
21
import socket
20
22
import sys
21
23
 
22
 
from bzrlib import (
23
 
    bzrdir,
 
24
from .. import (
 
25
    controldir,
24
26
    errors,
25
27
    osutils,
26
 
    symbol_versioning,
 
28
    tests,
27
29
    urlutils,
28
30
    )
29
 
from bzrlib.tests import TestCase, TestCaseWithTransport
30
 
 
31
 
 
32
 
class TestErrors(TestCaseWithTransport):
 
31
from ..sixish import (
 
32
    text_type,
 
33
    )
 
34
 
 
35
 
 
36
class TestErrors(tests.TestCase):
 
37
 
 
38
    def test_no_arg_named_message(self):
 
39
        """Ensure the __init__ and _fmt in errors do not have "message" arg.
 
40
 
 
41
        This test fails if __init__ or _fmt in errors has an argument
 
42
        named "message" as this can cause errors in some Python versions.
 
43
        Python 2.5 uses a slot for StandardError.message.
 
44
        See bug #603461
 
45
        """
 
46
        fmt_pattern = re.compile("%\(message\)[sir]")
 
47
        for c in errors.BzrError.__subclasses__():
 
48
            init = getattr(c, '__init__', None)
 
49
            fmt = getattr(c, '_fmt', None)
 
50
            if init:
 
51
                args = inspect.getargspec(init)[0]
 
52
                self.assertFalse('message' in args,
 
53
                    ('Argument name "message" not allowed for '
 
54
                    '"errors.%s.__init__"' % c.__name__))
 
55
            if fmt and fmt_pattern.search(fmt):
 
56
                self.assertFalse(True, ('"message" not allowed in '
 
57
                    '"errors.%s._fmt"' % c.__name__))
33
58
 
34
59
    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))
 
60
        error = errors.BadFilenameEncoding(b'bad/filen\xe5me', 'UTF-8')
 
61
        self.assertContainsRe(
 
62
            str(error),
 
63
            "^Filename b?'bad/filen\\\\xe5me' is not valid in your current"
 
64
            " filesystem encoding UTF-8$")
59
65
 
60
66
    def test_duplicate_file_id(self):
61
67
        error = errors.DuplicateFileId('a_file_id', 'foo')
73
79
                             " its ancestry shows a ghost at {ghost_rev}",
74
80
                             str(error))
75
81
 
76
 
    def test_incompatibleAPI(self):
77
 
        error = errors.IncompatibleAPI("module", (1, 2, 3), (4, 5, 6), (7, 8, 9))
 
82
    def test_incompatibleVersion(self):
 
83
        error = errors.IncompatibleVersion("module", [(4, 5, 6), (7, 8, 9)],
 
84
                (1, 2, 3))
78
85
        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)".',
 
86
            'API module is not compatible; one of versions '
 
87
            '[(4, 5, 6), (7, 8, 9)] is required, but current version is '
 
88
            '(1, 2, 3).',
81
89
            str(error))
82
90
 
83
91
    def test_inconsistent_delta(self):
103
111
        error = errors.InvalidHttpRange('path',
104
112
                                        'Content-Range: potatoes 0-00/o0oo0',
105
113
                                        'bad range')
106
 
        self.assertEquals("Invalid http range"
107
 
                          " 'Content-Range: potatoes 0-00/o0oo0'"
108
 
                          " for path: bad range",
109
 
                          str(error))
 
114
        self.assertEqual("Invalid http range"
 
115
                         " 'Content-Range: potatoes 0-00/o0oo0'"
 
116
                         " for path: bad range",
 
117
                         str(error))
110
118
 
111
119
    def test_invalid_range(self):
112
120
        error = errors.InvalidRange('path', 12, 'bad range')
113
 
        self.assertEquals("Invalid range access in path at 12: bad range",
114
 
                          str(error))
 
121
        self.assertEqual("Invalid range access in path at 12: bad range",
 
122
                         str(error))
115
123
 
116
124
    def test_inventory_modified(self):
117
125
        error = errors.InventoryModified("a tree to be repred")
132
140
            "cannot be broken.",
133
141
            str(error))
134
142
 
 
143
    def test_lock_corrupt(self):
 
144
        error = errors.LockCorrupt("corruption info")
 
145
        self.assertEqualDiff("Lock is apparently held, but corrupted: "
 
146
            "corruption info\n"
 
147
            "Use 'brz break-lock' to clear it",
 
148
            str(error))
 
149
 
135
150
    def test_knit_data_stream_incompatible(self):
136
151
        error = errors.KnitDataStreamIncompatible(
137
152
            'stream format', 'target format')
162
177
        self.assertEqualDiff(
163
178
            "The medium 'a medium' is not connected.", str(error))
164
179
 
165
 
    def test_no_public_branch(self):
166
 
        b = self.make_branch('.')
167
 
        error = errors.NoPublicBranch(b)
168
 
        url = urlutils.unescape_for_display(b.base, 'ascii')
169
 
        self.assertEqualDiff(
170
 
            'There is no public branch set for "%s".' % url, str(error))
171
 
 
172
 
    def test_no_repo(self):
173
 
        dir = bzrdir.BzrDir.create(self.get_url())
174
 
        error = errors.NoRepositoryPresent(dir)
175
 
        self.assertNotEqual(-1, str(error).find((dir.transport.clone('..').base)))
176
 
        self.assertEqual(-1, str(error).find((dir.transport.base)))
177
 
 
178
180
    def test_no_smart_medium(self):
179
181
        error = errors.NoSmartMedium("a transport")
180
182
        self.assertEqualDiff("The transport 'a transport' cannot tunnel the "
181
183
            "smart protocol.",
182
184
            str(error))
183
185
 
184
 
    def test_no_help_topic(self):
185
 
        error = errors.NoHelpTopic("topic")
186
 
        self.assertEqualDiff("No help could be found for 'topic'. "
187
 
            "Please use 'bzr help topics' to obtain a list of topics.",
188
 
            str(error))
189
 
 
190
186
    def test_no_such_id(self):
191
187
        error = errors.NoSuchId("atree", "anid")
192
188
        self.assertEqualDiff("The file id \"anid\" is not present in the tree "
229
225
            "('key',) which is encoded as 'fulltext'.",
230
226
            str(error))
231
227
 
232
 
    def test_unknown_hook(self):
233
 
        error = errors.UnknownHook("branch", "foo")
234
 
        self.assertEqualDiff("The branch hook 'foo' is unknown in this version"
235
 
            " of bzrlib.",
236
 
            str(error))
237
 
        error = errors.UnknownHook("tree", "bar")
238
 
        self.assertEqualDiff("The tree hook 'bar' is unknown in this version"
239
 
            " of bzrlib.",
240
 
            str(error))
241
 
 
242
 
    def test_unstackable_branch_format(self):
243
 
        format = u'foo'
244
 
        url = "/foo"
245
 
        error = errors.UnstackableBranchFormat(format, url)
246
 
        self.assertEqualDiff(
247
 
            "The branch '/foo'(foo) is not a stackable format. "
248
 
            "You will need to upgrade the branch to permit branch stacking.",
249
 
            str(error))
250
 
 
251
228
    def test_unstackable_location(self):
252
229
        error = errors.UnstackableLocationError('foo', 'bar')
253
230
        self.assertEqualDiff("The branch 'foo' cannot be stacked on 'bar'.",
263
240
            str(error))
264
241
 
265
242
    def test_up_to_date(self):
266
 
        error = errors.UpToDateFormat(bzrdir.BzrDirFormat4())
267
 
        self.assertEqualDiff("The branch format All-in-one "
268
 
                             "format 4 is already at the most "
269
 
                             "recent format.",
270
 
                             str(error))
271
 
 
272
 
    def test_corrupt_repository(self):
273
 
        repo = self.make_repository('.')
274
 
        error = errors.CorruptRepository(repo)
275
 
        self.assertEqualDiff("An error has been detected in the repository %s.\n"
276
 
                             "Please run bzr reconcile on this repository." %
277
 
                             repo.bzrdir.root_transport.base,
278
 
                             str(error))
 
243
        error = errors.UpToDateFormat("someformat")
 
244
        self.assertEqualDiff(
 
245
            "The branch format someformat is already at the most "
 
246
            "recent format.", str(error))
279
247
 
280
248
    def test_read_error(self):
281
249
        # a unicode path to check that %r is being used.
282
250
        path = u'a path'
283
251
        error = errors.ReadError(path)
284
 
        self.assertEqualDiff("Error reading from u'a path'.", str(error))
 
252
        self.assertContainsRe(str(error), "^Error reading from u?'a path'.$")
285
253
 
286
254
    def test_bad_index_format_signature(self):
287
255
        error = errors.BadIndexFormatSignature("foo", "bar")
313
281
        self.assertEqual("The value 'foo' is not a valid value.",
314
282
            str(error))
315
283
 
316
 
    def test_bzrnewerror_is_deprecated(self):
317
 
        class DeprecatedError(errors.BzrNewError):
318
 
            pass
319
 
        self.callDeprecated(['BzrNewError was deprecated in bzr 0.13; '
320
 
             'please convert DeprecatedError to use BzrError instead'],
321
 
            DeprecatedError)
322
 
 
323
284
    def test_bzrerror_from_literal_string(self):
324
285
        # Some code constructs BzrError from a literal string, in which case
325
286
        # no further formatting is done.  (I'm not sure raising the base class
327
288
        # perhaps no more is needed.)
328
289
        try:
329
290
            raise errors.BzrError('this is my errors; %d is not expanded')
330
 
        except errors.BzrError, e:
 
291
        except errors.BzrError as e:
331
292
            self.assertEqual('this is my errors; %d is not expanded', str(e))
332
293
 
333
294
    def test_reading_completed(self):
408
369
            "location specified in the merge directive is not a branch: "
409
370
            "foo.", str(error))
410
371
 
411
 
    def test_malformed_bug_identifier(self):
412
 
        """Test the formatting of MalformedBugIdentifier."""
413
 
        error = errors.MalformedBugIdentifier('bogus', 'reason for bogosity')
414
 
        self.assertEqual(
415
 
            'Did not understand bug identifier bogus: reason for bogosity. '
416
 
            'See "bzr help bugs" for more information on this feature.',
417
 
            str(error))
418
 
 
419
 
    def test_unknown_bug_tracker_abbreviation(self):
420
 
        """Test the formatting of UnknownBugTrackerAbbreviation."""
421
 
        branch = self.make_branch('some_branch')
422
 
        error = errors.UnknownBugTrackerAbbreviation('xxx', branch)
423
 
        self.assertEqual(
424
 
            "Cannot find registered bug tracker called xxx on %s" % branch,
425
 
            str(error))
426
 
 
427
372
    def test_unexpected_smart_server_response(self):
428
373
        e = errors.UnexpectedSmartServerResponse(('not yes',))
429
374
        self.assertEqual(
466
411
 
467
412
    def test_duplicate_record_name_error(self):
468
413
        """Test the formatting of DuplicateRecordNameError."""
469
 
        e = errors.DuplicateRecordNameError(u"n\xe5me".encode('utf-8'))
 
414
        e = errors.DuplicateRecordNameError(b"n\xc3\xa5me")
470
415
        self.assertEqual(
471
 
            "Container has multiple records with the same name: n\xc3\xa5me",
472
 
            str(e))
 
416
            u"Container has multiple records with the same name: n\xe5me",
 
417
            text_type(e))
473
418
 
474
419
    def test_check_error(self):
475
 
        # This has a member called 'message', which is problematic in
476
 
        # python2.5 because that is a slot on the base Exception class
477
420
        e = errors.BzrCheckError('example check failure')
478
421
        self.assertEqual(
479
422
            "Internal check failed: example check failure",
488
431
 
489
432
    def test_immortal_pending_deletion_message(self):
490
433
        err = errors.ImmortalPendingDeletion('foo')
491
 
        self.assertEquals(
 
434
        self.assertEqual(
492
435
            "Unable to delete transform temporary directory foo.  "
493
436
            "Please examine foo to see if it contains any files "
494
437
            "you wish to keep, and delete it when you are done.",
496
439
 
497
440
    def test_unable_create_symlink(self):
498
441
        err = errors.UnableCreateSymlink()
499
 
        self.assertEquals(
 
442
        self.assertEqual(
500
443
            "Unable to create symlink on this platform",
501
444
            str(err))
502
445
        err = errors.UnableCreateSymlink(path=u'foo')
503
 
        self.assertEquals(
 
446
        self.assertEqual(
504
447
            "Unable to create symlink 'foo' on this platform",
505
448
            str(err))
506
449
        err = errors.UnableCreateSymlink(path=u'\xb5')
507
 
        self.assertEquals(
508
 
            "Unable to create symlink u'\\xb5' on this platform",
 
450
        self.assertEqual(
 
451
            "Unable to create symlink %s on this platform" % repr(u'\xb5'),
509
452
            str(err))
510
453
 
511
454
    def test_invalid_url_join(self):
512
455
        """Test the formatting of InvalidURLJoin."""
513
 
        e = errors.InvalidURLJoin('Reason', 'base path', ('args',))
 
456
        e = urlutils.InvalidURLJoin('Reason', 'base path', ('args',))
514
457
        self.assertEqual(
515
458
            "Invalid URL join request: Reason: 'base path' + ('args',)",
516
459
            str(e))
517
460
 
518
 
    def test_incorrect_url(self):
519
 
        err = errors.InvalidBugTrackerURL('foo', 'http://bug.com/')
520
 
        self.assertEquals(
521
 
            ("The URL for bug tracker \"foo\" doesn't contain {id}: "
522
 
             "http://bug.com/"),
523
 
            str(err))
524
 
 
525
461
    def test_unable_encode_path(self):
526
462
        err = errors.UnableEncodePath('foo', 'executable')
527
 
        self.assertEquals("Unable to encode executable path 'foo' in "
528
 
            "user encoding " + osutils.get_user_encoding(),
529
 
            str(err))
 
463
        self.assertEqual("Unable to encode executable path 'foo' in "
 
464
                         "user encoding " + osutils.get_user_encoding(),
 
465
                         str(err))
530
466
 
531
467
    def test_unknown_format(self):
532
468
        err = errors.UnknownFormatError('bar', kind='foo')
533
 
        self.assertEquals("Unknown foo format: 'bar'", str(err))
534
 
 
535
 
    def test_unknown_rules(self):
536
 
        err = errors.UnknownRules(['foo', 'bar'])
537
 
        self.assertEquals("Unknown rules detected: foo, bar.", str(err))
538
 
 
539
 
    def test_hook_failed(self):
540
 
        # Create an exc_info tuple by raising and catching an exception.
541
 
        try:
542
 
            1/0
543
 
        except ZeroDivisionError:
544
 
            exc_info = sys.exc_info()
545
 
        err = errors.HookFailed('hook stage', 'hook name', exc_info, warn=False)
546
 
        self.assertStartsWith(
547
 
            str(err), 'Hook \'hook name\' during hook stage failed:\n')
548
 
        self.assertEndsWith(
549
 
            str(err), 'integer division or modulo by zero')
 
469
        self.assertEqual("Unknown foo format: 'bar'", str(err))
550
470
 
551
471
    def test_tip_change_rejected(self):
552
472
        err = errors.TipChangeRejected(u'Unicode message\N{INTERROBANG}')
553
 
        self.assertEquals(
 
473
        self.assertEqual(
554
474
            u'Tip change rejected: Unicode message\N{INTERROBANG}',
555
 
            unicode(err))
556
 
        self.assertEquals(
557
 
            'Tip change rejected: Unicode message\xe2\x80\xbd',
558
 
            str(err))
 
475
            text_type(err))
559
476
 
560
477
    def test_error_from_smart_server(self):
561
478
        error_tuple = ('error', 'tuple')
562
479
        err = errors.ErrorFromSmartServer(error_tuple)
563
 
        self.assertEquals(
 
480
        self.assertEqual(
564
481
            "Error received from smart server: ('error', 'tuple')", str(err))
565
482
 
566
483
    def test_untranslateable_error_from_smart_server(self):
567
484
        error_tuple = ('error', 'tuple')
568
485
        orig_err = errors.ErrorFromSmartServer(error_tuple)
569
486
        err = errors.UnknownErrorFromSmartServer(orig_err)
570
 
        self.assertEquals(
 
487
        self.assertEqual(
571
488
            "Server sent an unexpected error: ('error', 'tuple')", str(err))
572
489
 
573
490
    def test_smart_message_handler_error(self):
575
492
        try:
576
493
            raise Exception("example error")
577
494
        except Exception:
578
 
            exc_info = sys.exc_info()
579
 
        err = errors.SmartMessageHandlerError(exc_info)
580
 
        self.assertStartsWith(
581
 
            str(err), "The message handler raised an exception:\n")
582
 
        self.assertEndsWith(str(err), "Exception: example error\n")
583
 
 
584
 
    def test_must_have_working_tree(self):
585
 
        err = errors.MustHaveWorkingTree('foo', 'bar')
586
 
        self.assertEqual(str(err), "Branching 'bar'(foo) must create a"
587
 
                                   " working tree.")
588
 
 
589
 
    def test_no_such_view(self):
590
 
        err = errors.NoSuchView('foo')
591
 
        self.assertEquals("No such view: foo.", str(err))
592
 
 
593
 
    def test_views_not_supported(self):
594
 
        err = errors.ViewsNotSupported('atree')
595
 
        err_str = str(err)
596
 
        self.assertStartsWith(err_str, "Views are not supported by ")
597
 
        self.assertEndsWith(err_str, "; use 'bzr upgrade' to change your "
598
 
            "tree to a later format.")
599
 
 
600
 
    def test_file_outside_view(self):
601
 
        err = errors.FileOutsideView('baz', ['foo', 'bar'])
602
 
        self.assertEquals('Specified file "baz" is outside the current view: '
603
 
            'foo, bar', str(err))
604
 
 
605
 
    def test_invalid_shelf_id(self):
606
 
        invalid_id = "foo"
607
 
        err = errors.InvalidShelfId(invalid_id)
608
 
        self.assertEqual('"foo" is not a valid shelf id, '
609
 
            'try a number instead.', str(err))
 
495
            err = errors.SmartMessageHandlerError(sys.exc_info())
 
496
        # GZ 2010-11-08: Should not store exc_info in exception instances.
 
497
        try:
 
498
            self.assertStartsWith(
 
499
                str(err), "The message handler raised an exception:\n")
 
500
            self.assertEndsWith(str(err), "Exception: example error\n")
 
501
        finally:
 
502
            del err
610
503
 
611
504
    def test_unresumable_write_group(self):
612
505
        repo = "dummy repo"
627
520
        err = errors.NotBranchError('path')
628
521
        self.assertEqual('Not a branch: "path".', str(err))
629
522
 
630
 
    def test_not_branch_bzrdir_with_repo(self):
631
 
        bzrdir = self.make_repository('repo').bzrdir
632
 
        err = errors.NotBranchError('path', bzrdir=bzrdir)
633
 
        self.assertEqual(
634
 
            'Not a branch: "path": location is a repository.', str(err))
635
 
 
636
 
    def test_not_branch_bzrdir_without_repo(self):
637
 
        bzrdir = self.make_bzrdir('bzrdir')
638
 
        err = errors.NotBranchError('path', bzrdir=bzrdir)
639
 
        self.assertEqual('Not a branch: "path".', str(err))
640
 
 
641
 
    def test_not_branch_laziness(self):
642
 
        real_bzrdir = self.make_bzrdir('path')
 
523
    def test_not_branch_bzrdir_with_recursive_not_branch_error(self):
643
524
        class FakeBzrDir(object):
644
 
            def __init__(self):
645
 
                self.calls = []
646
525
            def open_repository(self):
647
 
                self.calls.append('open_repository')
648
 
                raise errors.NoRepositoryPresent(real_bzrdir)
649
 
        fake_bzrdir = FakeBzrDir()
650
 
        err = errors.NotBranchError('path', bzrdir=fake_bzrdir)
651
 
        self.assertEqual([], fake_bzrdir.calls)
652
 
        str(err)
653
 
        self.assertEqual(['open_repository'], fake_bzrdir.calls)
654
 
        # Stringifying twice doesn't try to open a repository twice.
655
 
        str(err)
656
 
        self.assertEqual(['open_repository'], fake_bzrdir.calls)
 
526
                # str() on the NotBranchError will trigger a call to this,
 
527
                # which in turn will another, identical NotBranchError.
 
528
                raise errors.NotBranchError('path', controldir=FakeBzrDir())
 
529
        err = errors.NotBranchError('path', controldir=FakeBzrDir())
 
530
        self.assertEqual('Not a branch: "path": NotBranchError.', str(err))
 
531
 
 
532
    def test_recursive_bind(self):
 
533
        error = errors.RecursiveBind('foo_bar_branch')
 
534
        msg = ('Branch "foo_bar_branch" appears to be bound to itself. '
 
535
            'Please use `brz unbind` to fix.')
 
536
        self.assertEqualDiff(msg, str(error))
 
537
 
 
538
    def test_retry_with_new_packs(self):
 
539
        fake_exc_info = ('{exc type}', '{exc value}', '{exc traceback}')
 
540
        error = errors.RetryWithNewPacks(
 
541
            '{context}', reload_occurred=False, exc_info=fake_exc_info)
 
542
        self.assertEqual(
 
543
            'Pack files have changed, reload and retry. context: '
 
544
            '{context} {exc value}', str(error))
657
545
 
658
546
 
659
547
class PassThroughError(errors.BzrError):
673
561
    __doc__ = """This class has a docstring but no format string."""
674
562
 
675
563
 
676
 
class TestErrorFormatting(TestCase):
 
564
class TestErrorFormatting(tests.TestCase):
677
565
 
678
566
    def test_always_str(self):
679
567
        e = PassThroughError(u'\xb5', 'bar')
687
575
 
688
576
    def test_missing_format_string(self):
689
577
        e = ErrorWithNoFormat(param='randomvalue')
690
 
        s = self.callDeprecated(
691
 
                ['ErrorWithNoFormat uses its docstring as a format, it should use _fmt instead'],
692
 
                lambda x: str(x), e)
693
 
        ## s = str(e)
694
 
        self.assertEqual(s,
695
 
                "This class has a docstring but no format string.")
 
578
        self.assertStartsWith(str(e),
 
579
                              "Unprintable exception ErrorWithNoFormat")
696
580
 
697
581
    def test_mismatched_format_args(self):
698
582
        # Even though ErrorWithBadFormat's format string does not match the
703
587
            str(e), 'Unprintable exception ErrorWithBadFormat')
704
588
 
705
589
    def test_cannot_bind_address(self):
706
 
        # see <https://bugs.edge.launchpad.net/bzr/+bug/286871>
 
590
        # see <https://bugs.launchpad.net/bzr/+bug/286871>
707
591
        e = errors.CannotBindAddress('example.com', 22,
708
 
            socket.error(13, 'Permission denied'))
709
 
        self.assertContainsRe(str(e),
 
592
                                     socket.error(13, 'Permission denied'))
 
593
        self.assertContainsRe(
 
594
            str(e),
710
595
            r'Cannot bind address "example\.com:22":.*Permission denied')
711
596
 
712
 
    def test_file_timestamp_unavailable(self):            
713
 
        e = errors.FileTimestampUnavailable("/path/foo")
714
 
        self.assertEquals("The filestamp for /path/foo is not available.",
 
597
    def test_transform_rename_failed(self):
 
598
        e = errors.TransformRenameFailed(u"from", u"to", "readonly file", 2)
 
599
        self.assertEqual(
 
600
            u"Failed to rename from to to: readonly file",
715
601
            str(e))
 
602
 
 
603
 
 
604
class TestErrorsUsingTransport(tests.TestCaseWithMemoryTransport):
 
605
    """Tests for errors that need to use a branch or repo."""
 
606
 
 
607
    def test_no_public_branch(self):
 
608
        b = self.make_branch('.')
 
609
        error = errors.NoPublicBranch(b)
 
610
        url = urlutils.unescape_for_display(b.base, 'ascii')
 
611
        self.assertEqualDiff(
 
612
            'There is no public branch set for "%s".' % url, str(error))
 
613
 
 
614
    def test_no_repo(self):
 
615
        dir = controldir.ControlDir.create(self.get_url())
 
616
        error = errors.NoRepositoryPresent(dir)
 
617
        self.assertNotEqual(-1, str(error).find((dir.transport.clone('..').base)))
 
618
        self.assertEqual(-1, str(error).find((dir.transport.base)))
 
619
 
 
620
    def test_corrupt_repository(self):
 
621
        repo = self.make_repository('.')
 
622
        error = errors.CorruptRepository(repo)
 
623
        self.assertEqualDiff("An error has been detected in the repository %s.\n"
 
624
                             "Please run brz reconcile on this repository." %
 
625
                             repo.controldir.root_transport.base,
 
626
                             str(error))
 
627
 
 
628
    def test_not_branch_bzrdir_with_repo(self):
 
629
        controldir = self.make_repository('repo').controldir
 
630
        err = errors.NotBranchError('path', controldir=controldir)
 
631
        self.assertEqual(
 
632
            'Not a branch: "path": location is a repository.', str(err))
 
633
 
 
634
    def test_not_branch_bzrdir_without_repo(self):
 
635
        controldir = self.make_controldir('bzrdir')
 
636
        err = errors.NotBranchError('path', controldir=controldir)
 
637
        self.assertEqual('Not a branch: "path".', str(err))
 
638
 
 
639
    def test_not_branch_laziness(self):
 
640
        real_bzrdir = self.make_controldir('path')
 
641
        class FakeBzrDir(object):
 
642
            def __init__(self):
 
643
                self.calls = []
 
644
            def open_repository(self):
 
645
                self.calls.append('open_repository')
 
646
                raise errors.NoRepositoryPresent(real_bzrdir)
 
647
        fake_bzrdir = FakeBzrDir()
 
648
        err = errors.NotBranchError('path', controldir=fake_bzrdir)
 
649
        self.assertEqual([], fake_bzrdir.calls)
 
650
        str(err)
 
651
        self.assertEqual(['open_repository'], fake_bzrdir.calls)
 
652
        # Stringifying twice doesn't try to open a repository twice.
 
653
        str(err)
 
654
        self.assertEqual(['open_repository'], fake_bzrdir.calls)