/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-06-10 01:35:53 UTC
  • mto: (6670.4.8 move-bzr)
  • mto: This revision was merged to the branch mainline in revision 6681.
  • Revision ID: jelmer@jelmer.uk-20170610013553-560y7mn3su4pp763
Fix remaining tests.

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