/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: Martin
  • Date: 2017-06-27 00:10:52 UTC
  • mto: This revision was merged to the branch mainline in revision 6721.
  • Revision ID: gzlist@googlemail.com-20170627001052-o70zln144nmwhamo
Switch c_api helpers for _static_tuple_c to capsules

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))
 
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$")
40
65
 
41
66
    def test_corrupt_dirstate(self):
42
67
        error = errors.CorruptDirstate('path/to/dirstate', 'the reason why')
73
98
                             " its ancestry shows a ghost at {ghost_rev}",
74
99
                             str(error))
75
100
 
76
 
    def test_incompatibleAPI(self):
77
 
        error = errors.IncompatibleAPI("module", (1, 2, 3), (4, 5, 6), (7, 8, 9))
 
101
    def test_incompatibleVersion(self):
 
102
        error = errors.IncompatibleVersion("module", [(4, 5, 6), (7, 8, 9)],
 
103
                (1, 2, 3))
78
104
        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)".',
 
105
            'API module is not compatible; one of versions '
 
106
            '[(4, 5, 6), (7, 8, 9)] is required, but current version is '
 
107
            '(1, 2, 3).',
81
108
            str(error))
82
109
 
83
110
    def test_inconsistent_delta(self):
103
130
        error = errors.InvalidHttpRange('path',
104
131
                                        'Content-Range: potatoes 0-00/o0oo0',
105
132
                                        'bad range')
106
 
        self.assertEquals("Invalid http range"
107
 
                          " 'Content-Range: potatoes 0-00/o0oo0'"
108
 
                          " for path: bad range",
109
 
                          str(error))
 
133
        self.assertEqual("Invalid http range"
 
134
                         " 'Content-Range: potatoes 0-00/o0oo0'"
 
135
                         " for path: bad range",
 
136
                         str(error))
110
137
 
111
138
    def test_invalid_range(self):
112
139
        error = errors.InvalidRange('path', 12, 'bad range')
113
 
        self.assertEquals("Invalid range access in path at 12: bad range",
114
 
                          str(error))
 
140
        self.assertEqual("Invalid range access in path at 12: bad range",
 
141
                         str(error))
115
142
 
116
143
    def test_inventory_modified(self):
117
144
        error = errors.InventoryModified("a tree to be repred")
132
159
            "cannot be broken.",
133
160
            str(error))
134
161
 
 
162
    def test_lock_corrupt(self):
 
163
        error = errors.LockCorrupt("corruption info")
 
164
        self.assertEqualDiff("Lock is apparently held, but corrupted: "
 
165
            "corruption info\n"
 
166
            "Use 'brz break-lock' to clear it",
 
167
            str(error))
 
168
 
135
169
    def test_knit_data_stream_incompatible(self):
136
170
        error = errors.KnitDataStreamIncompatible(
137
171
            'stream format', 'target format')
162
196
        self.assertEqualDiff(
163
197
            "The medium 'a medium' is not connected.", str(error))
164
198
 
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
199
    def test_no_smart_medium(self):
179
200
        error = errors.NoSmartMedium("a transport")
180
201
        self.assertEqualDiff("The transport 'a transport' cannot tunnel the "
184
205
    def test_no_help_topic(self):
185
206
        error = errors.NoHelpTopic("topic")
186
207
        self.assertEqualDiff("No help could be found for 'topic'. "
187
 
            "Please use 'bzr help topics' to obtain a list of topics.",
 
208
            "Please use 'brz help topics' to obtain a list of topics.",
188
209
            str(error))
189
210
 
190
211
    def test_no_such_id(self):
232
253
    def test_unknown_hook(self):
233
254
        error = errors.UnknownHook("branch", "foo")
234
255
        self.assertEqualDiff("The branch hook 'foo' is unknown in this version"
235
 
            " of bzrlib.",
 
256
            " of breezy.",
236
257
            str(error))
237
258
        error = errors.UnknownHook("tree", "bar")
238
259
        self.assertEqualDiff("The tree hook 'bar' is unknown in this version"
239
 
            " of bzrlib.",
 
260
            " of breezy.",
240
261
            str(error))
241
262
 
242
263
    def test_unstackable_branch_format(self):
263
284
            str(error))
264
285
 
265
286
    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))
 
287
        error = errors.UpToDateFormat("someformat")
 
288
        self.assertEqualDiff(
 
289
            "The branch format someformat is already at the most "
 
290
            "recent format.", str(error))
279
291
 
280
292
    def test_read_error(self):
281
293
        # a unicode path to check that %r is being used.
282
294
        path = u'a path'
283
295
        error = errors.ReadError(path)
284
 
        self.assertEqualDiff("Error reading from u'a path'.", str(error))
 
296
        self.assertContainsRe(str(error), "^Error reading from u?'a path'.$")
285
297
 
286
298
    def test_bad_index_format_signature(self):
287
299
        error = errors.BadIndexFormatSignature("foo", "bar")
313
325
        self.assertEqual("The value 'foo' is not a valid value.",
314
326
            str(error))
315
327
 
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
328
    def test_bzrerror_from_literal_string(self):
324
329
        # Some code constructs BzrError from a literal string, in which case
325
330
        # no further formatting is done.  (I'm not sure raising the base class
327
332
        # perhaps no more is needed.)
328
333
        try:
329
334
            raise errors.BzrError('this is my errors; %d is not expanded')
330
 
        except errors.BzrError, e:
 
335
        except errors.BzrError as e:
331
336
            self.assertEqual('this is my errors; %d is not expanded', str(e))
332
337
 
333
338
    def test_reading_completed(self):
413
418
        error = errors.MalformedBugIdentifier('bogus', 'reason for bogosity')
414
419
        self.assertEqual(
415
420
            '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,
 
421
            'See "brz help bugs" for more information on this feature.',
425
422
            str(error))
426
423
 
427
424
    def test_unexpected_smart_server_response(self):
466
463
 
467
464
    def test_duplicate_record_name_error(self):
468
465
        """Test the formatting of DuplicateRecordNameError."""
469
 
        e = errors.DuplicateRecordNameError(u"n\xe5me".encode('utf-8'))
 
466
        e = errors.DuplicateRecordNameError(b"n\xc3\xa5me")
470
467
        self.assertEqual(
471
 
            "Container has multiple records with the same name: n\xc3\xa5me",
472
 
            str(e))
 
468
            u"Container has multiple records with the same name: n\xe5me",
 
469
            text_type(e))
473
470
 
474
471
    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
472
        e = errors.BzrCheckError('example check failure')
478
473
        self.assertEqual(
479
474
            "Internal check failed: example check failure",
488
483
 
489
484
    def test_immortal_pending_deletion_message(self):
490
485
        err = errors.ImmortalPendingDeletion('foo')
491
 
        self.assertEquals(
 
486
        self.assertEqual(
492
487
            "Unable to delete transform temporary directory foo.  "
493
488
            "Please examine foo to see if it contains any files "
494
489
            "you wish to keep, and delete it when you are done.",
496
491
 
497
492
    def test_unable_create_symlink(self):
498
493
        err = errors.UnableCreateSymlink()
499
 
        self.assertEquals(
 
494
        self.assertEqual(
500
495
            "Unable to create symlink on this platform",
501
496
            str(err))
502
497
        err = errors.UnableCreateSymlink(path=u'foo')
503
 
        self.assertEquals(
 
498
        self.assertEqual(
504
499
            "Unable to create symlink 'foo' on this platform",
505
500
            str(err))
506
501
        err = errors.UnableCreateSymlink(path=u'\xb5')
507
 
        self.assertEquals(
508
 
            "Unable to create symlink u'\\xb5' on this platform",
 
502
        self.assertEqual(
 
503
            "Unable to create symlink %s on this platform" % repr(u'\xb5'),
509
504
            str(err))
510
505
 
511
506
    def test_invalid_url_join(self):
517
512
 
518
513
    def test_incorrect_url(self):
519
514
        err = errors.InvalidBugTrackerURL('foo', 'http://bug.com/')
520
 
        self.assertEquals(
 
515
        self.assertEqual(
521
516
            ("The URL for bug tracker \"foo\" doesn't contain {id}: "
522
517
             "http://bug.com/"),
523
518
            str(err))
524
519
 
525
520
    def test_unable_encode_path(self):
526
521
        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))
 
522
        self.assertEqual("Unable to encode executable path 'foo' in "
 
523
                         "user encoding " + osutils.get_user_encoding(),
 
524
                         str(err))
530
525
 
531
526
    def test_unknown_format(self):
532
527
        err = errors.UnknownFormatError('bar', kind='foo')
533
 
        self.assertEquals("Unknown foo format: 'bar'", str(err))
 
528
        self.assertEqual("Unknown foo format: 'bar'", str(err))
534
529
 
535
530
    def test_unknown_rules(self):
536
531
        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')
 
532
        self.assertEqual("Unknown rules detected: foo, bar.", str(err))
550
533
 
551
534
    def test_tip_change_rejected(self):
552
535
        err = errors.TipChangeRejected(u'Unicode message\N{INTERROBANG}')
553
 
        self.assertEquals(
 
536
        self.assertEqual(
554
537
            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))
 
538
            text_type(err))
559
539
 
560
540
    def test_error_from_smart_server(self):
561
541
        error_tuple = ('error', 'tuple')
562
542
        err = errors.ErrorFromSmartServer(error_tuple)
563
 
        self.assertEquals(
 
543
        self.assertEqual(
564
544
            "Error received from smart server: ('error', 'tuple')", str(err))
565
545
 
566
546
    def test_untranslateable_error_from_smart_server(self):
567
547
        error_tuple = ('error', 'tuple')
568
548
        orig_err = errors.ErrorFromSmartServer(error_tuple)
569
549
        err = errors.UnknownErrorFromSmartServer(orig_err)
570
 
        self.assertEquals(
 
550
        self.assertEqual(
571
551
            "Server sent an unexpected error: ('error', 'tuple')", str(err))
572
552
 
573
553
    def test_smart_message_handler_error(self):
575
555
        try:
576
556
            raise Exception("example error")
577
557
        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")
 
558
            err = errors.SmartMessageHandlerError(sys.exc_info())
 
559
        # GZ 2010-11-08: Should not store exc_info in exception instances.
 
560
        try:
 
561
            self.assertStartsWith(
 
562
                str(err), "The message handler raised an exception:\n")
 
563
            self.assertEndsWith(str(err), "Exception: example error\n")
 
564
        finally:
 
565
            del err
583
566
 
584
567
    def test_must_have_working_tree(self):
585
568
        err = errors.MustHaveWorkingTree('foo', 'bar')
588
571
 
589
572
    def test_no_such_view(self):
590
573
        err = errors.NoSuchView('foo')
591
 
        self.assertEquals("No such view: foo.", str(err))
 
574
        self.assertEqual("No such view: foo.", str(err))
592
575
 
593
576
    def test_views_not_supported(self):
594
577
        err = errors.ViewsNotSupported('atree')
595
578
        err_str = str(err)
596
579
        self.assertStartsWith(err_str, "Views are not supported by ")
597
 
        self.assertEndsWith(err_str, "; use 'bzr upgrade' to change your "
 
580
        self.assertEndsWith(err_str, "; use 'brz upgrade' to change your "
598
581
            "tree to a later format.")
599
582
 
600
583
    def test_file_outside_view(self):
601
584
        err = errors.FileOutsideView('baz', ['foo', 'bar'])
602
 
        self.assertEquals('Specified file "baz" is outside the current view: '
603
 
            'foo, bar', str(err))
 
585
        self.assertEqual('Specified file "baz" is outside the current view: '
 
586
                         'foo, bar', str(err))
604
587
 
605
588
    def test_invalid_shelf_id(self):
606
589
        invalid_id = "foo"
607
590
        err = errors.InvalidShelfId(invalid_id)
608
591
        self.assertEqual('"foo" is not a valid shelf id, '
609
 
            'try a number instead.', str(err))
 
592
                         'try a number instead.', str(err))
610
593
 
611
594
    def test_unresumable_write_group(self):
612
595
        repo = "dummy repo"
627
610
        err = errors.NotBranchError('path')
628
611
        self.assertEqual('Not a branch: "path".', str(err))
629
612
 
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')
 
613
    def test_not_branch_bzrdir_with_recursive_not_branch_error(self):
643
614
        class FakeBzrDir(object):
644
 
            def __init__(self):
645
 
                self.calls = []
646
615
            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)
 
616
                # str() on the NotBranchError will trigger a call to this,
 
617
                # which in turn will another, identical NotBranchError.
 
618
                raise errors.NotBranchError('path', controldir=FakeBzrDir())
 
619
        err = errors.NotBranchError('path', controldir=FakeBzrDir())
 
620
        self.assertEqual('Not a branch: "path": NotBranchError.', str(err))
 
621
 
 
622
    def test_invalid_pattern(self):
 
623
        error = errors.InvalidPattern('Bad pattern msg.')
 
624
        self.assertEqualDiff("Invalid pattern(s) found. Bad pattern msg.",
 
625
            str(error))
 
626
 
 
627
    def test_recursive_bind(self):
 
628
        error = errors.RecursiveBind('foo_bar_branch')
 
629
        msg = ('Branch "foo_bar_branch" appears to be bound to itself. '
 
630
            'Please use `brz unbind` to fix.')
 
631
        self.assertEqualDiff(msg, str(error))
 
632
 
 
633
    def test_retry_with_new_packs(self):
 
634
        fake_exc_info = ('{exc type}', '{exc value}', '{exc traceback}')
 
635
        error = errors.RetryWithNewPacks(
 
636
            '{context}', reload_occurred=False, exc_info=fake_exc_info)
 
637
        self.assertEqual(
 
638
            'Pack files have changed, reload and retry. context: '
 
639
            '{context} {exc value}', str(error))
657
640
 
658
641
 
659
642
class PassThroughError(errors.BzrError):
673
656
    __doc__ = """This class has a docstring but no format string."""
674
657
 
675
658
 
676
 
class TestErrorFormatting(TestCase):
 
659
class TestErrorFormatting(tests.TestCase):
677
660
 
678
661
    def test_always_str(self):
679
662
        e = PassThroughError(u'\xb5', 'bar')
687
670
 
688
671
    def test_missing_format_string(self):
689
672
        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.")
 
673
        self.assertStartsWith(str(e),
 
674
                              "Unprintable exception ErrorWithNoFormat")
696
675
 
697
676
    def test_mismatched_format_args(self):
698
677
        # Even though ErrorWithBadFormat's format string does not match the
703
682
            str(e), 'Unprintable exception ErrorWithBadFormat')
704
683
 
705
684
    def test_cannot_bind_address(self):
706
 
        # see <https://bugs.edge.launchpad.net/bzr/+bug/286871>
 
685
        # see <https://bugs.launchpad.net/bzr/+bug/286871>
707
686
        e = errors.CannotBindAddress('example.com', 22,
708
 
            socket.error(13, 'Permission denied'))
709
 
        self.assertContainsRe(str(e),
 
687
                                     socket.error(13, 'Permission denied'))
 
688
        self.assertContainsRe(
 
689
            str(e),
710
690
            r'Cannot bind address "example\.com:22":.*Permission denied')
711
691
 
712
 
    def test_file_timestamp_unavailable(self):            
 
692
    def test_file_timestamp_unavailable(self):
713
693
        e = errors.FileTimestampUnavailable("/path/foo")
714
 
        self.assertEquals("The filestamp for /path/foo is not available.",
 
694
        self.assertEqual("The filestamp for /path/foo is not available.",
 
695
                         str(e))
 
696
 
 
697
    def test_transform_rename_failed(self):
 
698
        e = errors.TransformRenameFailed(u"from", u"to", "readonly file", 2)
 
699
        self.assertEqual(
 
700
            u"Failed to rename from to to: readonly file",
715
701
            str(e))
 
702
 
 
703
 
 
704
class TestErrorsUsingTransport(tests.TestCaseWithMemoryTransport):
 
705
    """Tests for errors that need to use a branch or repo."""
 
706
 
 
707
    def test_no_public_branch(self):
 
708
        b = self.make_branch('.')
 
709
        error = errors.NoPublicBranch(b)
 
710
        url = urlutils.unescape_for_display(b.base, 'ascii')
 
711
        self.assertEqualDiff(
 
712
            'There is no public branch set for "%s".' % url, str(error))
 
713
 
 
714
    def test_no_repo(self):
 
715
        dir = controldir.ControlDir.create(self.get_url())
 
716
        error = errors.NoRepositoryPresent(dir)
 
717
        self.assertNotEqual(-1, str(error).find((dir.transport.clone('..').base)))
 
718
        self.assertEqual(-1, str(error).find((dir.transport.base)))
 
719
 
 
720
    def test_corrupt_repository(self):
 
721
        repo = self.make_repository('.')
 
722
        error = errors.CorruptRepository(repo)
 
723
        self.assertEqualDiff("An error has been detected in the repository %s.\n"
 
724
                             "Please run brz reconcile on this repository." %
 
725
                             repo.controldir.root_transport.base,
 
726
                             str(error))
 
727
 
 
728
    def test_unknown_bug_tracker_abbreviation(self):
 
729
        """Test the formatting of UnknownBugTrackerAbbreviation."""
 
730
        branch = self.make_branch('some_branch')
 
731
        error = errors.UnknownBugTrackerAbbreviation('xxx', branch)
 
732
        self.assertEqual(
 
733
            "Cannot find registered bug tracker called xxx on %s" % branch,
 
734
            str(error))
 
735
 
 
736
    def test_not_branch_bzrdir_with_repo(self):
 
737
        controldir = self.make_repository('repo').controldir
 
738
        err = errors.NotBranchError('path', controldir=controldir)
 
739
        self.assertEqual(
 
740
            'Not a branch: "path": location is a repository.', str(err))
 
741
 
 
742
    def test_not_branch_bzrdir_without_repo(self):
 
743
        controldir = self.make_controldir('bzrdir')
 
744
        err = errors.NotBranchError('path', controldir=controldir)
 
745
        self.assertEqual('Not a branch: "path".', str(err))
 
746
 
 
747
    def test_not_branch_laziness(self):
 
748
        real_bzrdir = self.make_controldir('path')
 
749
        class FakeBzrDir(object):
 
750
            def __init__(self):
 
751
                self.calls = []
 
752
            def open_repository(self):
 
753
                self.calls.append('open_repository')
 
754
                raise errors.NoRepositoryPresent(real_bzrdir)
 
755
        fake_bzrdir = FakeBzrDir()
 
756
        err = errors.NotBranchError('path', controldir=fake_bzrdir)
 
757
        self.assertEqual([], fake_bzrdir.calls)
 
758
        str(err)
 
759
        self.assertEqual(['open_repository'], fake_bzrdir.calls)
 
760
        # Stringifying twice doesn't try to open a repository twice.
 
761
        str(err)
 
762
        self.assertEqual(['open_repository'], fake_bzrdir.calls)