/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 bzrlib/tests/test_errors.py

  • Committer: John Arbash Meinel
  • Date: 2008-10-08 21:56:12 UTC
  • mto: This revision was merged to the branch mainline in revision 3773.
  • Revision ID: john@arbash-meinel.com-20081008215612-y9v94tqxreqoangx
Simplify the --raw mode.

I didn't realize, but the only node that is special cased is the 'root' node,
and to read it, you actually have to parse it directly, because the
compressed bytes start immediately after the end of the header, rather than
having any padding before the zlib bytes.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_errors.py
1
 
# Copyright (C) 2006-2010 Canonical Ltd
 
1
# Copyright (C) 2006, 2007, 2008 Canonical Ltd
 
2
#   Authors: Robert Collins <robert.collins@canonical.com>
 
3
#            and others
2
4
#
3
5
# This program is free software; you can redistribute it and/or modify
4
6
# it under the terms of the GNU General Public License as published by
12
14
#
13
15
# You should have received a copy of the GNU General Public License
14
16
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
17
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
18
 
17
19
"""Tests for the formatting and construction of errors."""
18
20
 
19
 
import socket
20
21
import sys
21
 
 
22
22
from bzrlib import (
23
23
    bzrdir,
24
24
    errors,
87
87
            "reason: reason for foo",
88
88
            str(error))
89
89
 
90
 
    def test_inconsistent_delta_delta(self):
91
 
        error = errors.InconsistentDeltaDelta([], 'reason')
92
 
        self.assertEqualDiff(
93
 
            "An inconsistent delta was supplied: []\nreason: reason",
94
 
            str(error))
95
 
 
96
90
    def test_in_process_transport(self):
97
91
        error = errors.InProcessTransport('fpp')
98
92
        self.assertEqualDiff(
120
114
            "read without data loss.",
121
115
            str(error))
122
116
 
123
 
    def test_jail_break(self):
124
 
        error = errors.JailBreak("some url")
125
 
        self.assertEqualDiff("An attempt to access a url outside the server"
126
 
            " jail was made: 'some url'.",
127
 
            str(error))
 
117
    def test_install_failed(self):
 
118
        error = errors.InstallFailed(['rev-one'])
 
119
        self.assertEqual("Could not install revisions:\nrev-one", str(error))
 
120
        error = errors.InstallFailed(['rev-one', 'rev-two'])
 
121
        self.assertEqual("Could not install revisions:\nrev-one, rev-two",
 
122
                         str(error))
 
123
        error = errors.InstallFailed([None])
 
124
        self.assertEqual("Could not install revisions:\nNone", str(error))
128
125
 
129
126
    def test_lock_active(self):
130
127
        error = errors.LockActive("lock description")
161
158
        error = errors.MediumNotConnected("a medium")
162
159
        self.assertEqualDiff(
163
160
            "The medium 'a medium' is not connected.", str(error))
164
 
 
 
161
 
165
162
    def test_no_public_branch(self):
166
163
        b = self.make_branch('.')
167
164
        error = errors.NoPublicBranch(b)
174
171
        error = errors.NoRepositoryPresent(dir)
175
172
        self.assertNotEqual(-1, str(error).find((dir.transport.clone('..').base)))
176
173
        self.assertEqual(-1, str(error).find((dir.transport.base)))
177
 
 
 
174
        
178
175
    def test_no_smart_medium(self):
179
176
        error = errors.NoSmartMedium("a transport")
180
177
        self.assertEqualDiff("The transport 'a transport' cannot tunnel the "
248
245
            "You will need to upgrade the branch to permit branch stacking.",
249
246
            str(error))
250
247
 
251
 
    def test_unstackable_location(self):
252
 
        error = errors.UnstackableLocationError('foo', 'bar')
253
 
        self.assertEqualDiff("The branch 'foo' cannot be stacked on 'bar'.",
254
 
            str(error))
255
 
 
256
248
    def test_unstackable_repository_format(self):
257
249
        format = u'foo'
258
250
        url = "/foo"
264
256
 
265
257
    def test_up_to_date(self):
266
258
        error = errors.UpToDateFormat(bzrdir.BzrDirFormat4())
267
 
        self.assertEqualDiff("The branch format All-in-one "
268
 
                             "format 4 is already at the most "
 
259
        self.assertEqualDiff("The branch format Bazaar-NG branch, "
 
260
                             "format 0.0.4 is already at the most "
269
261
                             "recent format.",
270
262
                             str(error))
271
263
 
412
404
        """Test the formatting of MalformedBugIdentifier."""
413
405
        error = errors.MalformedBugIdentifier('bogus', 'reason for bogosity')
414
406
        self.assertEqual(
415
 
            'Did not understand bug identifier bogus: reason for bogosity. '
416
 
            'See "bzr help bugs" for more information on this feature.',
 
407
            "Did not understand bug identifier bogus: reason for bogosity",
417
408
            str(error))
418
409
 
419
410
    def test_unknown_bug_tracker_abbreviation(self):
470
461
        self.assertEqual(
471
462
            "Container has multiple records with the same name: n\xc3\xa5me",
472
463
            str(e))
473
 
 
 
464
        
474
465
    def test_check_error(self):
475
466
        # This has a member called 'message', which is problematic in
476
467
        # python2.5 because that is a slot on the base Exception class
542
533
            1/0
543
534
        except ZeroDivisionError:
544
535
            exc_info = sys.exc_info()
545
 
        err = errors.HookFailed('hook stage', 'hook name', exc_info, warn=False)
 
536
        err = errors.HookFailed('hook stage', 'hook name', exc_info)
546
537
        self.assertStartsWith(
547
538
            str(err), 'Hook \'hook name\' during hook stage failed:\n')
548
539
        self.assertEndsWith(
570
561
        self.assertEquals(
571
562
            "Server sent an unexpected error: ('error', 'tuple')", str(err))
572
563
 
573
 
    def test_smart_message_handler_error(self):
574
 
        # Make an exc_info tuple.
575
 
        try:
576
 
            raise Exception("example error")
577
 
        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))
610
 
 
611
 
    def test_unresumable_write_group(self):
612
 
        repo = "dummy repo"
613
 
        wg_tokens = ['token']
614
 
        reason = "a reason"
615
 
        err = errors.UnresumableWriteGroup(repo, wg_tokens, reason)
616
 
        self.assertEqual(
617
 
            "Repository dummy repo cannot resume write group "
618
 
            "['token']: a reason", str(err))
619
 
 
620
 
    def test_unsuspendable_write_group(self):
621
 
        repo = "dummy repo"
622
 
        err = errors.UnsuspendableWriteGroup(repo)
623
 
        self.assertEqual(
624
 
            'Repository dummy repo cannot suspend a write group.', str(err))
625
 
 
626
 
    def test_not_branch_no_args(self):
627
 
        err = errors.NotBranchError('path')
628
 
        self.assertEqual('Not a branch: "path".', str(err))
629
 
 
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')
643
 
        class FakeBzrDir(object):
644
 
            def __init__(self):
645
 
                self.calls = []
646
 
            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)
657
 
 
658
564
 
659
565
class PassThroughError(errors.BzrError):
660
 
 
 
566
    
661
567
    _fmt = """Pass through %(foo)s and %(bar)s"""
662
568
 
663
569
    def __init__(self, foo, bar):
670
576
 
671
577
 
672
578
class ErrorWithNoFormat(errors.BzrError):
673
 
    __doc__ = """This class has a docstring but no format string."""
 
579
    """This class has a docstring but no format string."""
674
580
 
675
581
 
676
582
class TestErrorFormatting(TestCase):
677
 
 
 
583
    
678
584
    def test_always_str(self):
679
585
        e = PassThroughError(u'\xb5', 'bar')
680
586
        self.assertIsInstance(e.__str__(), str)
691
597
                ['ErrorWithNoFormat uses its docstring as a format, it should use _fmt instead'],
692
598
                lambda x: str(x), e)
693
599
        ## s = str(e)
694
 
        self.assertEqual(s,
 
600
        self.assertEqual(s, 
695
601
                "This class has a docstring but no format string.")
696
602
 
697
603
    def test_mismatched_format_args(self):
701
607
        e = ErrorWithBadFormat(not_thing='x')
702
608
        self.assertStartsWith(
703
609
            str(e), 'Unprintable exception ErrorWithBadFormat')
704
 
 
705
 
    def test_cannot_bind_address(self):
706
 
        # see <https://bugs.edge.launchpad.net/bzr/+bug/286871>
707
 
        e = errors.CannotBindAddress('example.com', 22,
708
 
            socket.error(13, 'Permission denied'))
709
 
        self.assertContainsRe(str(e),
710
 
            r'Cannot bind address "example\.com:22":.*Permission denied')
711
 
 
712
 
    def test_file_timestamp_unavailable(self):            
713
 
        e = errors.FileTimestampUnavailable("/path/foo")
714
 
        self.assertEquals("The filestamp for /path/foo is not available.",
715
 
            str(e))