~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_errors.py

• browse files at revision 3806.1.1
• compare with another revision
• download diff
• download tarball
• view history from revision 3806.1.1

• reverse the comparison (3806.1.1 to 5076.4.6)
• stop comparing with revision 5076.4.6

Show diffs side-by-side

added

removed

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):

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))

• Older »

Loggerhead is a web-based interface for Breezy
Version: 2.0.1