~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_errors.py

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

• reverse the comparison (2900.2.25 to 3688.3.3)
• stop comparing with revision 3688.3.3

Show diffs side-by-side

added

removed

bzrlib/tests/test_errors.py

1

 

# Copyright (C) 2006, 2007, 2008 Canonical Ltd

 

1

# Copyright (C) 2006, 2007 Canonical Ltd

2

2

#   Authors: Robert Collins <robert.collins@canonical.com>

3

3

#            and others

4

4

#

18

18

 

19

19

"""Tests for the formatting and construction of errors."""

20

20

 

21

 

import sys

22

21

from bzrlib import (

23

22

    bzrdir,

24

23

    errors,

25

 

    osutils,

26

24

    symbol_versioning,

27

 

    urlutils,

28

25

    )

29

26

from bzrlib.tests import TestCase, TestCaseWithTransport

30

27

 

31

28

 

 

29

 

32

30

class TestErrors(TestCaseWithTransport):

33

31

 

34

 

    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

32

    def test_disabled_method(self):

56

33

        error = errors.DisabledMethod("class name")

57

34

        self.assertEqualDiff(

67

44

        self.assertEqualDiff('The prefix foo is in the help search path twice.',

68

45

            str(error))

69

46

 

70

 

    def test_ghost_revisions_have_no_revno(self):

71

 

        error = errors.GhostRevisionsHaveNoRevno('target', 'ghost_rev')

72

 

        self.assertEqualDiff("Could not determine revno for {target} because"

73

 

                             " its ancestry shows a ghost at {ghost_rev}",

74

 

                             str(error))

75

 

 

76

47

    def test_incompatibleAPI(self):

77

48

        error = errors.IncompatibleAPI("module", (1, 2, 3), (4, 5, 6), (7, 8, 9))

78

49

        self.assertEqualDiff(

80

51

            'It supports versions "(4, 5, 6)" to "(7, 8, 9)".',

81

52

            str(error))

82

53

 

83

 

    def test_inconsistent_delta(self):

84

 

        error = errors.InconsistentDelta('path', 'file-id', 'reason for foo')

85

 

        self.assertEqualDiff(

86

 

            "An inconsistent delta was supplied involving 'path', 'file-id'\n"

87

 

            "reason: reason for foo",

88

 

            str(error))

89

 

 

90

54

    def test_in_process_transport(self):

91

55

        error = errors.InProcessTransport('fpp')

92

56

        self.assertEqualDiff(

93

57

            "The transport 'fpp' is only accessible within this process.",

94

58

            str(error))

95

59

 

96

 

    def test_invalid_http_range(self):

97

 

        error = errors.InvalidHttpRange('path',

98

 

                                        'Content-Range: potatoes 0-00/o0oo0',

99

 

                                        'bad range')

100

 

        self.assertEquals("Invalid http range"

101

 

                          " 'Content-Range: potatoes 0-00/o0oo0'"

102

 

                          " for path: bad range",

103

 

                          str(error))

104

 

 

105

 

    def test_invalid_range(self):

106

 

        error = errors.InvalidRange('path', 12, 'bad range')

107

 

        self.assertEquals("Invalid range access in path at 12: bad range",

108

 

                          str(error))

109

 

 

110

60

    def test_inventory_modified(self):

111

61

        error = errors.InventoryModified("a tree to be repred")

112

62

        self.assertEqualDiff("The current inventory for the tree 'a tree to "

136

86

                         '"stream format" into knit of format '

137

87

                         '"target format".', str(error))

138

88

 

139

 

    def test_knit_data_stream_unknown(self):

140

 

        error = errors.KnitDataStreamUnknown(

141

 

            'stream format')

142

 

        self.assertEqual('Cannot parse knit data stream of format '

143

 

                         '"stream format".', str(error))

144

 

 

145

89

    def test_knit_header_error(self):

146

90

        error = errors.KnitHeaderError('line foo\n', 'path/to/file')

147

91

        self.assertEqual("Knit header error: 'line foo\\n' unexpected"

158

102

        error = errors.MediumNotConnected("a medium")

159

103

        self.assertEqualDiff(

160

104

            "The medium 'a medium' is not connected.", str(error))

161

 

 

162

 

    def test_no_public_branch(self):

163

 

        b = self.make_branch('.')

164

 

        error = errors.NoPublicBranch(b)

165

 

        url = urlutils.unescape_for_display(b.base, 'ascii')

166

 

        self.assertEqualDiff(

167

 

            'There is no public branch set for "%s".' % url, str(error))

168

 

 

 

105

        

169

106

    def test_no_repo(self):

170

107

        dir = bzrdir.BzrDir.create(self.get_url())

171

108

        error = errors.NoRepositoryPresent(dir)

196

133

                             " tree atree.", str(error))

197

134

        self.assertIsInstance(error, errors.NoSuchRevision)

198

135

 

199

 

    def test_not_stacked(self):

200

 

        error = errors.NotStacked('a branch')

201

 

        self.assertEqualDiff("The branch 'a branch' is not stacked.",

202

 

            str(error))

203

 

 

204

136

    def test_not_write_locked(self):

205

137

        error = errors.NotWriteLocked('a thing to repr')

206

138

        self.assertEqualDiff("'a thing to repr' is not write locked but needs "

207

139

            "to be.",

208

140

            str(error))

209

141

 

 

142

    def test_read_only_lock_error(self):

 

143

        error = self.applyDeprecated(symbol_versioning.zero_ninetytwo,

 

144

            errors.ReadOnlyLockError, 'filename', 'error message')

 

145

        self.assertEqualDiff("Cannot acquire write lock on filename."

 

146

                             " error message", str(error))

 

147

 

210

148

    def test_lock_failed(self):

211

149

        error = errors.LockFailed('http://canonical.com/', 'readonly transport')

212

150

        self.assertEqualDiff("Cannot lock http://canonical.com/: readonly transport",

220

158

            "the currently open request.",

221

159

            str(error))

222

160

 

223

 

    def test_unavailable_representation(self):

224

 

        error = errors.UnavailableRepresentation(('key',), "mpdiff", "fulltext")

225

 

        self.assertEqualDiff("The encoding 'mpdiff' is not available for key "

226

 

            "('key',) which is encoded as 'fulltext'.",

227

 

            str(error))

228

 

 

229

161

    def test_unknown_hook(self):

230

162

        error = errors.UnknownHook("branch", "foo")

231

163

        self.assertEqualDiff("The branch hook 'foo' is unknown in this version"

236

168

            " of bzrlib.",

237

169

            str(error))

238

170

 

239

 

    def test_unstackable_branch_format(self):

240

 

        format = u'foo'

241

 

        url = "/foo"

242

 

        error = errors.UnstackableBranchFormat(format, url)

243

 

        self.assertEqualDiff(

244

 

            "The branch '/foo'(foo) is not a stackable format. "

245

 

            "You will need to upgrade the branch to permit branch stacking.",

246

 

            str(error))

247

 

 

248

 

    def test_unstackable_repository_format(self):

249

 

        format = u'foo'

250

 

        url = "/foo"

251

 

        error = errors.UnstackableRepositoryFormat(format, url)

252

 

        self.assertEqualDiff(

253

 

            "The repository '/foo'(foo) is not a stackable format. "

254

 

            "You will need to upgrade the repository to permit branch stacking.",

255

 

            str(error))

256

 

 

257

171

    def test_up_to_date(self):

258

172

        error = errors.UpToDateFormat(bzrdir.BzrDirFormat4())

259

173

        self.assertEqualDiff("The branch format Bazaar-NG branch, "

391

305

            host='ahost', port=444, msg='Unable to connect to ssh host',

392

306

            orig_error='my_error')

393

307

 

394

 

    def test_target_not_branch(self):

395

 

        """Test the formatting of TargetNotBranch."""

396

 

        error = errors.TargetNotBranch('foo')

397

 

        self.assertEqual(

398

 

            "Your branch does not have all of the revisions required in "

399

 

            "order to merge this merge directive and the target "

400

 

            "location specified in the merge directive is not a branch: "

401

 

            "foo.", str(error))

402

 

 

403

308

    def test_malformed_bug_identifier(self):

404

309

        """Test the formatting of MalformedBugIdentifier."""

405

310

        error = errors.MalformedBugIdentifier('bogus', 'reason for bogosity')

477

382

        self.assertEqual(

478

383

            "Corrupt or incompatible data stream: my reason", str(e))

479

384

 

480

 

    def test_immortal_pending_deletion_message(self):

481

 

        err = errors.ImmortalPendingDeletion('foo')

482

 

        self.assertEquals(

483

 

            "Unable to delete transform temporary directory foo.  "

484

 

            "Please examine foo to see if it contains any files "

485

 

            "you wish to keep, and delete it when you are done.",

486

 

            str(err))

487

 

 

488

 

    def test_unable_create_symlink(self):

489

 

        err = errors.UnableCreateSymlink()

490

 

        self.assertEquals(

491

 

            "Unable to create symlink on this platform",

492

 

            str(err))

493

 

        err = errors.UnableCreateSymlink(path=u'foo')

494

 

        self.assertEquals(

495

 

            "Unable to create symlink 'foo' on this platform",

496

 

            str(err))

497

 

        err = errors.UnableCreateSymlink(path=u'\xb5')

498

 

        self.assertEquals(

499

 

            "Unable to create symlink u'\\xb5' on this platform",

500

 

            str(err))

501

 

 

502

 

    def test_invalid_url_join(self):

503

 

        """Test the formatting of InvalidURLJoin."""

504

 

        e = errors.InvalidURLJoin('Reason', 'base path', ('args',))

505

 

        self.assertEqual(

506

 

            "Invalid URL join request: Reason: 'base path' + ('args',)",

507

 

            str(e))

508

 

 

509

 

    def test_incorrect_url(self):

510

 

        err = errors.InvalidBugTrackerURL('foo', 'http://bug.com/')

511

 

        self.assertEquals(

512

 

            ("The URL for bug tracker \"foo\" doesn't contain {id}: "

513

 

             "http://bug.com/"),

514

 

            str(err))

515

 

 

516

 

    def test_unable_encode_path(self):

517

 

        err = errors.UnableEncodePath('foo', 'executable')

518

 

        self.assertEquals("Unable to encode executable path 'foo' in "

519

 

            "user encoding " + osutils.get_user_encoding(),

520

 

            str(err))

521

 

 

522

 

    def test_unknown_format(self):

523

 

        err = errors.UnknownFormatError('bar', kind='foo')

524

 

        self.assertEquals("Unknown foo format: 'bar'", str(err))

525

 

 

526

 

    def test_unknown_rules(self):

527

 

        err = errors.UnknownRules(['foo', 'bar'])

528

 

        self.assertEquals("Unknown rules detected: foo, bar.", str(err))

529

 

 

530

 

    def test_hook_failed(self):

531

 

        # Create an exc_info tuple by raising and catching an exception.

532

 

        try:

533

 

            1/0

534

 

        except ZeroDivisionError:

535

 

            exc_info = sys.exc_info()

536

 

        err = errors.HookFailed('hook stage', 'hook name', exc_info)

537

 

        self.assertStartsWith(

538

 

            str(err), 'Hook \'hook name\' during hook stage failed:\n')

539

 

        self.assertEndsWith(

540

 

            str(err), 'integer division or modulo by zero')

541

 

 

542

 

    def test_tip_change_rejected(self):

543

 

        err = errors.TipChangeRejected(u'Unicode message\N{INTERROBANG}')

544

 

        self.assertEquals(

545

 

            u'Tip change rejected: Unicode message\N{INTERROBANG}',

546

 

            unicode(err))

547

 

        self.assertEquals(

548

 

            'Tip change rejected: Unicode message\xe2\x80\xbd',

549

 

            str(err))

550

 

 

551

385

 

552

386

class PassThroughError(errors.BzrError):

553

387

    

• Older »

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