/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: 2020-04-05 19:11:34 UTC
  • mto: (7490.7.16 work)
  • mto: This revision was merged to the branch mainline in revision 7501.
  • Revision ID: jelmer@jelmer.uk-20200405191134-0aebh8ikiwygxma5
Populate the .gitignore file.

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
    PY3,
 
33
    text_type,
 
34
    )
 
35
 
 
36
 
 
37
class TestErrors(tests.TestCase):
 
38
 
 
39
    def test_no_arg_named_message(self):
 
40
        """Ensure the __init__ and _fmt in errors do not have "message" arg.
 
41
 
 
42
        This test fails if __init__ or _fmt in errors has an argument
 
43
        named "message" as this can cause errors in some Python versions.
 
44
        Python 2.5 uses a slot for StandardError.message.
 
45
        See bug #603461
 
46
        """
 
47
        fmt_pattern = re.compile("%\\(message\\)[sir]")
 
48
        for c in errors.BzrError.__subclasses__():
 
49
            init = getattr(c, '__init__', None)
 
50
            fmt = getattr(c, '_fmt', None)
 
51
            if init:
 
52
                if PY3:
 
53
                    args = inspect.getfullargspec(init)[0]
 
54
                else:
 
55
                    args = inspect.getargspec(init)[0]
 
56
                self.assertFalse('message' in args,
 
57
                                 ('Argument name "message" not allowed for '
 
58
                                  '"errors.%s.__init__"' % c.__name__))
 
59
            if fmt and fmt_pattern.search(fmt):
 
60
                self.assertFalse(True, ('"message" not allowed in '
 
61
                                        '"errors.%s._fmt"' % c.__name__))
33
62
 
34
63
    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
 
    def test_disabled_method(self):
56
 
        error = errors.DisabledMethod("class name")
57
 
        self.assertEqualDiff(
58
 
            "The smart server method 'class name' is disabled.", str(error))
 
64
        error = errors.BadFilenameEncoding(b'bad/filen\xe5me', 'UTF-8')
 
65
        self.assertContainsRe(
 
66
            str(error),
 
67
            "^Filename b?'bad/filen\\\\xe5me' is not valid in your current"
 
68
            " filesystem encoding UTF-8$")
59
69
 
60
70
    def test_duplicate_file_id(self):
61
71
        error = errors.DuplicateFileId('a_file_id', 'foo')
65
75
    def test_duplicate_help_prefix(self):
66
76
        error = errors.DuplicateHelpPrefix('foo')
67
77
        self.assertEqualDiff('The prefix foo is in the help search path twice.',
68
 
            str(error))
 
78
                             str(error))
69
79
 
70
80
    def test_ghost_revisions_have_no_revno(self):
71
81
        error = errors.GhostRevisionsHaveNoRevno('target', 'ghost_rev')
73
83
                             " its ancestry shows a ghost at {ghost_rev}",
74
84
                             str(error))
75
85
 
76
 
    def test_incompatibleAPI(self):
77
 
        error = errors.IncompatibleAPI("module", (1, 2, 3), (4, 5, 6), (7, 8, 9))
 
86
    def test_incompatibleVersion(self):
 
87
        error = errors.IncompatibleVersion("module", [(4, 5, 6), (7, 8, 9)],
 
88
                                           (1, 2, 3))
78
89
        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)".',
 
90
            'API module is not compatible; one of versions '
 
91
            '[(4, 5, 6), (7, 8, 9)] is required, but current version is '
 
92
            '(1, 2, 3).',
81
93
            str(error))
82
94
 
83
95
    def test_inconsistent_delta(self):
103
115
        error = errors.InvalidHttpRange('path',
104
116
                                        'Content-Range: potatoes 0-00/o0oo0',
105
117
                                        'bad range')
106
 
        self.assertEquals("Invalid http range"
107
 
                          " 'Content-Range: potatoes 0-00/o0oo0'"
108
 
                          " for path: bad range",
109
 
                          str(error))
 
118
        self.assertEqual("Invalid http range"
 
119
                         " 'Content-Range: potatoes 0-00/o0oo0'"
 
120
                         " for path: bad range",
 
121
                         str(error))
110
122
 
111
123
    def test_invalid_range(self):
112
124
        error = errors.InvalidRange('path', 12, 'bad range')
113
 
        self.assertEquals("Invalid range access in path at 12: bad range",
114
 
                          str(error))
 
125
        self.assertEqual("Invalid range access in path at 12: bad range",
 
126
                         str(error))
115
127
 
116
128
    def test_inventory_modified(self):
117
129
        error = errors.InventoryModified("a tree to be repred")
118
130
        self.assertEqualDiff("The current inventory for the tree 'a tree to "
119
 
            "be repred' has been modified, so a clean inventory cannot be "
120
 
            "read without data loss.",
121
 
            str(error))
 
131
                             "be repred' has been modified, so a clean inventory cannot be "
 
132
                             "read without data loss.",
 
133
                             str(error))
122
134
 
123
135
    def test_jail_break(self):
124
136
        error = errors.JailBreak("some url")
125
137
        self.assertEqualDiff("An attempt to access a url outside the server"
126
 
            " jail was made: 'some url'.",
127
 
            str(error))
 
138
                             " jail was made: 'some url'.",
 
139
                             str(error))
128
140
 
129
141
    def test_lock_active(self):
130
142
        error = errors.LockActive("lock description")
131
143
        self.assertEqualDiff("The lock for 'lock description' is in use and "
132
 
            "cannot be broken.",
133
 
            str(error))
134
 
 
135
 
    def test_knit_data_stream_incompatible(self):
136
 
        error = errors.KnitDataStreamIncompatible(
137
 
            'stream format', 'target format')
138
 
        self.assertEqual('Cannot insert knit data stream of format '
139
 
                         '"stream format" into knit of format '
140
 
                         '"target format".', str(error))
141
 
 
142
 
    def test_knit_data_stream_unknown(self):
143
 
        error = errors.KnitDataStreamUnknown(
144
 
            'stream format')
145
 
        self.assertEqual('Cannot parse knit data stream of format '
146
 
                         '"stream format".', str(error))
147
 
 
148
 
    def test_knit_header_error(self):
149
 
        error = errors.KnitHeaderError('line foo\n', 'path/to/file')
150
 
        self.assertEqual("Knit header error: 'line foo\\n' unexpected"
151
 
                         " for file \"path/to/file\".", str(error))
152
 
 
153
 
    def test_knit_index_unknown_method(self):
154
 
        error = errors.KnitIndexUnknownMethod('http://host/foo.kndx',
155
 
                                              ['bad', 'no-eol'])
156
 
        self.assertEqual("Knit index http://host/foo.kndx does not have a"
157
 
                         " known method in options: ['bad', 'no-eol']",
158
 
                         str(error))
 
144
                             "cannot be broken.",
 
145
                             str(error))
 
146
 
 
147
    def test_lock_corrupt(self):
 
148
        error = errors.LockCorrupt("corruption info")
 
149
        self.assertEqualDiff("Lock is apparently held, but corrupted: "
 
150
                             "corruption info\n"
 
151
                             "Use 'brz break-lock' to clear it",
 
152
                             str(error))
159
153
 
160
154
    def test_medium_not_connected(self):
161
155
        error = errors.MediumNotConnected("a medium")
162
156
        self.assertEqualDiff(
163
157
            "The medium 'a medium' is not connected.", str(error))
164
158
 
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
159
    def test_no_smart_medium(self):
179
160
        error = errors.NoSmartMedium("a transport")
180
161
        self.assertEqualDiff("The transport 'a transport' cannot tunnel the "
181
 
            "smart protocol.",
182
 
            str(error))
183
 
 
184
 
    def test_no_help_topic(self):
185
 
        error = errors.NoHelpTopic("topic")
186
 
        self.assertEqualDiff("No help could be found for 'topic'. "
187
 
            "Please use 'bzr help topics' to obtain a list of topics.",
188
 
            str(error))
 
162
                             "smart protocol.",
 
163
                             str(error))
189
164
 
190
165
    def test_no_such_id(self):
191
166
        error = errors.NoSuchId("atree", "anid")
192
167
        self.assertEqualDiff("The file id \"anid\" is not present in the tree "
193
 
            "atree.",
194
 
            str(error))
 
168
                             "atree.",
 
169
                             str(error))
195
170
 
196
171
    def test_no_such_revision_in_tree(self):
197
172
        error = errors.NoSuchRevisionInTree("atree", "anid")
202
177
    def test_not_stacked(self):
203
178
        error = errors.NotStacked('a branch')
204
179
        self.assertEqualDiff("The branch 'a branch' is not stacked.",
205
 
            str(error))
 
180
                             str(error))
206
181
 
207
182
    def test_not_write_locked(self):
208
183
        error = errors.NotWriteLocked('a thing to repr')
209
184
        self.assertEqualDiff("'a thing to repr' is not write locked but needs "
210
 
            "to be.",
211
 
            str(error))
 
185
                             "to be.",
 
186
                             str(error))
212
187
 
213
188
    def test_lock_failed(self):
214
 
        error = errors.LockFailed('http://canonical.com/', 'readonly transport')
 
189
        error = errors.LockFailed(
 
190
            'http://canonical.com/', 'readonly transport')
215
191
        self.assertEqualDiff("Cannot lock http://canonical.com/: readonly transport",
216
 
            str(error))
 
192
                             str(error))
217
193
        self.assertFalse(error.internal_error)
218
194
 
219
195
    def test_too_many_concurrent_requests(self):
220
196
        error = errors.TooManyConcurrentRequests("a medium")
221
197
        self.assertEqualDiff("The medium 'a medium' has reached its concurrent "
222
 
            "request limit. Be sure to finish_writing and finish_reading on "
223
 
            "the currently open request.",
224
 
            str(error))
 
198
                             "request limit. Be sure to finish_writing and finish_reading on "
 
199
                             "the currently open request.",
 
200
                             str(error))
225
201
 
226
202
    def test_unavailable_representation(self):
227
 
        error = errors.UnavailableRepresentation(('key',), "mpdiff", "fulltext")
 
203
        error = errors.UnavailableRepresentation(
 
204
            ('key',), "mpdiff", "fulltext")
228
205
        self.assertEqualDiff("The encoding 'mpdiff' is not available for key "
229
 
            "('key',) which is encoded as 'fulltext'.",
230
 
            str(error))
231
 
 
232
 
    def test_unknown_hook(self):
233
 
        error = errors.UnknownHook("branch", "foo")
234
 
        self.assertEqualDiff("The branch hook 'foo' is unknown in this version"
235
 
            " of bzrlib.",
236
 
            str(error))
237
 
        error = errors.UnknownHook("tree", "bar")
238
 
        self.assertEqualDiff("The tree hook 'bar' is unknown in this version"
239
 
            " of bzrlib.",
240
 
            str(error))
241
 
 
242
 
    def test_unstackable_branch_format(self):
243
 
        format = u'foo'
244
 
        url = "/foo"
245
 
        error = errors.UnstackableBranchFormat(format, url)
246
 
        self.assertEqualDiff(
247
 
            "The branch '/foo'(foo) is not a stackable format. "
248
 
            "You will need to upgrade the branch to permit branch stacking.",
249
 
            str(error))
 
206
                             "('key',) which is encoded as 'fulltext'.",
 
207
                             str(error))
250
208
 
251
209
    def test_unstackable_location(self):
252
210
        error = errors.UnstackableLocationError('foo', 'bar')
253
211
        self.assertEqualDiff("The branch 'foo' cannot be stacked on 'bar'.",
254
 
            str(error))
 
212
                             str(error))
255
213
 
256
214
    def test_unstackable_repository_format(self):
257
215
        format = u'foo'
263
221
            str(error))
264
222
 
265
223
    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))
 
224
        error = errors.UpToDateFormat("someformat")
 
225
        self.assertEqualDiff(
 
226
            "The branch format someformat is already at the most "
 
227
            "recent format.", str(error))
279
228
 
280
229
    def test_read_error(self):
281
230
        # a unicode path to check that %r is being used.
282
231
        path = u'a path'
283
232
        error = errors.ReadError(path)
284
 
        self.assertEqualDiff("Error reading from u'a path'.", str(error))
285
 
 
286
 
    def test_bad_index_format_signature(self):
287
 
        error = errors.BadIndexFormatSignature("foo", "bar")
288
 
        self.assertEqual("foo is not an index of type bar.",
289
 
            str(error))
290
 
 
291
 
    def test_bad_index_data(self):
292
 
        error = errors.BadIndexData("foo")
293
 
        self.assertEqual("Error in data for index foo.",
294
 
            str(error))
295
 
 
296
 
    def test_bad_index_duplicate_key(self):
297
 
        error = errors.BadIndexDuplicateKey("foo", "bar")
298
 
        self.assertEqual("The key 'foo' is already in index 'bar'.",
299
 
            str(error))
300
 
 
301
 
    def test_bad_index_key(self):
302
 
        error = errors.BadIndexKey("foo")
303
 
        self.assertEqual("The key 'foo' is not a valid key.",
304
 
            str(error))
305
 
 
306
 
    def test_bad_index_options(self):
307
 
        error = errors.BadIndexOptions("foo")
308
 
        self.assertEqual("Could not parse options for index foo.",
309
 
            str(error))
310
 
 
311
 
    def test_bad_index_value(self):
312
 
        error = errors.BadIndexValue("foo")
313
 
        self.assertEqual("The value 'foo' is not a valid value.",
314
 
            str(error))
315
 
 
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)
 
233
        self.assertContainsRe(str(error), "^Error reading from u?'a path'.$")
322
234
 
323
235
    def test_bzrerror_from_literal_string(self):
324
236
        # Some code constructs BzrError from a literal string, in which case
327
239
        # perhaps no more is needed.)
328
240
        try:
329
241
            raise errors.BzrError('this is my errors; %d is not expanded')
330
 
        except errors.BzrError, e:
 
242
        except errors.BzrError as e:
331
243
            self.assertEqual('this is my errors; %d is not expanded', str(e))
332
244
 
333
245
    def test_reading_completed(self):
334
246
        error = errors.ReadingCompleted("a request")
335
247
        self.assertEqualDiff("The MediumRequest 'a request' has already had "
336
 
            "finish_reading called upon it - the request has been completed and"
337
 
            " no more data may be read.",
338
 
            str(error))
 
248
                             "finish_reading called upon it - the request has been completed and"
 
249
                             " no more data may be read.",
 
250
                             str(error))
339
251
 
340
252
    def test_writing_completed(self):
341
253
        error = errors.WritingCompleted("a request")
342
254
        self.assertEqualDiff("The MediumRequest 'a request' has already had "
343
 
            "finish_writing called upon it - accept bytes may not be called "
344
 
            "anymore.",
345
 
            str(error))
 
255
                             "finish_writing called upon it - accept bytes may not be called "
 
256
                             "anymore.",
 
257
                             str(error))
346
258
 
347
259
    def test_writing_not_completed(self):
348
260
        error = errors.WritingNotComplete("a request")
349
261
        self.assertEqualDiff("The MediumRequest 'a request' has not has "
350
 
            "finish_writing called upon it - until the write phase is complete"
351
 
            " no data may be read.",
352
 
            str(error))
 
262
                             "finish_writing called upon it - until the write phase is complete"
 
263
                             " no data may be read.",
 
264
                             str(error))
353
265
 
354
266
    def test_transport_not_possible(self):
355
267
        error = errors.TransportNotPossible('readonly', 'original error')
356
268
        self.assertEqualDiff('Transport operation not possible:'
357
 
                         ' readonly original error', str(error))
 
269
                             ' readonly original error', str(error))
358
270
 
359
271
    def assertSocketConnectionError(self, expected, *args, **kwargs):
360
272
        """Check the formatting of a SocketConnectionError exception"""
408
320
            "location specified in the merge directive is not a branch: "
409
321
            "foo.", str(error))
410
322
 
411
 
    def test_malformed_bug_identifier(self):
412
 
        """Test the formatting of MalformedBugIdentifier."""
413
 
        error = errors.MalformedBugIdentifier('bogus', 'reason for bogosity')
414
 
        self.assertEqual(
415
 
            '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,
425
 
            str(error))
426
 
 
427
323
    def test_unexpected_smart_server_response(self):
428
324
        e = errors.UnexpectedSmartServerResponse(('not yes',))
429
325
        self.assertEqual(
466
362
 
467
363
    def test_duplicate_record_name_error(self):
468
364
        """Test the formatting of DuplicateRecordNameError."""
469
 
        e = errors.DuplicateRecordNameError(u"n\xe5me".encode('utf-8'))
 
365
        e = errors.DuplicateRecordNameError(b"n\xc3\xa5me")
470
366
        self.assertEqual(
471
 
            "Container has multiple records with the same name: n\xc3\xa5me",
472
 
            str(e))
 
367
            u"Container has multiple records with the same name: n\xe5me",
 
368
            text_type(e))
473
369
 
474
370
    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
371
        e = errors.BzrCheckError('example check failure')
478
372
        self.assertEqual(
479
373
            "Internal check failed: example check failure",
488
382
 
489
383
    def test_immortal_pending_deletion_message(self):
490
384
        err = errors.ImmortalPendingDeletion('foo')
491
 
        self.assertEquals(
 
385
        self.assertEqual(
492
386
            "Unable to delete transform temporary directory foo.  "
493
387
            "Please examine foo to see if it contains any files "
494
388
            "you wish to keep, and delete it when you are done.",
495
389
            str(err))
496
390
 
497
 
    def test_unable_create_symlink(self):
498
 
        err = errors.UnableCreateSymlink()
499
 
        self.assertEquals(
500
 
            "Unable to create symlink on this platform",
501
 
            str(err))
502
 
        err = errors.UnableCreateSymlink(path=u'foo')
503
 
        self.assertEquals(
504
 
            "Unable to create symlink 'foo' on this platform",
505
 
            str(err))
506
 
        err = errors.UnableCreateSymlink(path=u'\xb5')
507
 
        self.assertEquals(
508
 
            "Unable to create symlink u'\\xb5' on this platform",
509
 
            str(err))
510
 
 
511
391
    def test_invalid_url_join(self):
512
392
        """Test the formatting of InvalidURLJoin."""
513
 
        e = errors.InvalidURLJoin('Reason', 'base path', ('args',))
 
393
        e = urlutils.InvalidURLJoin('Reason', 'base path', ('args',))
514
394
        self.assertEqual(
515
395
            "Invalid URL join request: Reason: 'base path' + ('args',)",
516
396
            str(e))
517
397
 
518
 
    def test_incorrect_url(self):
519
 
        err = errors.InvalidBugTrackerURL('foo', 'http://bug.com/')
520
 
        self.assertEquals(
521
 
            ("The URL for bug tracker \"foo\" doesn't contain {id}: "
522
 
             "http://bug.com/"),
523
 
            str(err))
524
 
 
525
398
    def test_unable_encode_path(self):
526
399
        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))
 
400
        self.assertEqual("Unable to encode executable path 'foo' in "
 
401
                         "user encoding " + osutils.get_user_encoding(),
 
402
                         str(err))
530
403
 
531
404
    def test_unknown_format(self):
532
405
        err = errors.UnknownFormatError('bar', kind='foo')
533
 
        self.assertEquals("Unknown foo format: 'bar'", str(err))
534
 
 
535
 
    def test_unknown_rules(self):
536
 
        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')
 
406
        self.assertEqual("Unknown foo format: 'bar'", str(err))
550
407
 
551
408
    def test_tip_change_rejected(self):
552
409
        err = errors.TipChangeRejected(u'Unicode message\N{INTERROBANG}')
553
 
        self.assertEquals(
 
410
        self.assertEqual(
554
411
            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))
 
412
            text_type(err))
559
413
 
560
414
    def test_error_from_smart_server(self):
561
415
        error_tuple = ('error', 'tuple')
562
416
        err = errors.ErrorFromSmartServer(error_tuple)
563
 
        self.assertEquals(
 
417
        self.assertEqual(
564
418
            "Error received from smart server: ('error', 'tuple')", str(err))
565
419
 
566
420
    def test_untranslateable_error_from_smart_server(self):
567
421
        error_tuple = ('error', 'tuple')
568
422
        orig_err = errors.ErrorFromSmartServer(error_tuple)
569
423
        err = errors.UnknownErrorFromSmartServer(orig_err)
570
 
        self.assertEquals(
 
424
        self.assertEqual(
571
425
            "Server sent an unexpected error: ('error', 'tuple')", str(err))
572
426
 
573
427
    def test_smart_message_handler_error(self):
575
429
        try:
576
430
            raise Exception("example error")
577
431
        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))
 
432
            err = errors.SmartMessageHandlerError(sys.exc_info())
 
433
        # GZ 2010-11-08: Should not store exc_info in exception instances.
 
434
        try:
 
435
            self.assertStartsWith(
 
436
                str(err), "The message handler raised an exception:\n")
 
437
            self.assertEndsWith(str(err), "Exception: example error\n")
 
438
        finally:
 
439
            del err
610
440
 
611
441
    def test_unresumable_write_group(self):
612
442
        repo = "dummy repo"
627
457
        err = errors.NotBranchError('path')
628
458
        self.assertEqual('Not a branch: "path".', str(err))
629
459
 
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')
 
460
    def test_not_branch_bzrdir_with_recursive_not_branch_error(self):
643
461
        class FakeBzrDir(object):
644
 
            def __init__(self):
645
 
                self.calls = []
646
462
            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)
 
463
                # str() on the NotBranchError will trigger a call to this,
 
464
                # which in turn will another, identical NotBranchError.
 
465
                raise errors.NotBranchError('path', controldir=FakeBzrDir())
 
466
        err = errors.NotBranchError('path', controldir=FakeBzrDir())
 
467
        self.assertEqual('Not a branch: "path": NotBranchError.', str(err))
 
468
 
 
469
    def test_recursive_bind(self):
 
470
        error = errors.RecursiveBind('foo_bar_branch')
 
471
        msg = ('Branch "foo_bar_branch" appears to be bound to itself. '
 
472
               'Please use `brz unbind` to fix.')
 
473
        self.assertEqualDiff(msg, str(error))
 
474
 
 
475
    def test_retry_with_new_packs(self):
 
476
        fake_exc_info = ('{exc type}', '{exc value}', '{exc traceback}')
 
477
        error = errors.RetryWithNewPacks(
 
478
            '{context}', reload_occurred=False, exc_info=fake_exc_info)
 
479
        self.assertEqual(
 
480
            'Pack files have changed, reload and retry. context: '
 
481
            '{context} {exc value}', str(error))
657
482
 
658
483
 
659
484
class PassThroughError(errors.BzrError):
673
498
    __doc__ = """This class has a docstring but no format string."""
674
499
 
675
500
 
676
 
class TestErrorFormatting(TestCase):
 
501
class TestErrorFormatting(tests.TestCase):
677
502
 
678
503
    def test_always_str(self):
679
504
        e = PassThroughError(u'\xb5', 'bar')
680
505
        self.assertIsInstance(e.__str__(), str)
681
 
        # In Python str(foo) *must* return a real byte string
 
506
        # In Python 2 str(foo) *must* return a real byte string
682
507
        # not a Unicode string. The following line would raise a
683
508
        # Unicode error, because it tries to call str() on the string
684
509
        # returned from e.__str__(), and it has non ascii characters
685
510
        s = str(e)
686
 
        self.assertEqual('Pass through \xc2\xb5 and bar', s)
 
511
        if PY3:
 
512
            self.assertEqual('Pass through \xb5 and bar', s)
 
513
        else:
 
514
            self.assertEqual('Pass through \xc2\xb5 and bar', s)
687
515
 
688
516
    def test_missing_format_string(self):
689
517
        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.")
 
518
        self.assertStartsWith(str(e),
 
519
                              "Unprintable exception ErrorWithNoFormat")
696
520
 
697
521
    def test_mismatched_format_args(self):
698
522
        # Even though ErrorWithBadFormat's format string does not match the
703
527
            str(e), 'Unprintable exception ErrorWithBadFormat')
704
528
 
705
529
    def test_cannot_bind_address(self):
706
 
        # see <https://bugs.edge.launchpad.net/bzr/+bug/286871>
 
530
        # see <https://bugs.launchpad.net/bzr/+bug/286871>
707
531
        e = errors.CannotBindAddress('example.com', 22,
708
 
            socket.error(13, 'Permission denied'))
709
 
        self.assertContainsRe(str(e),
 
532
                                     socket.error(13, 'Permission denied'))
 
533
        self.assertContainsRe(
 
534
            str(e),
710
535
            r'Cannot bind address "example\.com:22":.*Permission denied')
711
536
 
712
 
    def test_file_timestamp_unavailable(self):            
713
 
        e = errors.FileTimestampUnavailable("/path/foo")
714
 
        self.assertEquals("The filestamp for /path/foo is not available.",
 
537
    def test_transform_rename_failed(self):
 
538
        e = errors.TransformRenameFailed(u"from", u"to", "readonly file", 2)
 
539
        self.assertEqual(
 
540
            u"Failed to rename from to to: readonly file",
715
541
            str(e))
 
542
 
 
543
 
 
544
class TestErrorsUsingTransport(tests.TestCaseWithMemoryTransport):
 
545
    """Tests for errors that need to use a branch or repo."""
 
546
 
 
547
    def test_no_public_branch(self):
 
548
        b = self.make_branch('.')
 
549
        error = errors.NoPublicBranch(b)
 
550
        url = urlutils.unescape_for_display(b.base, 'ascii')
 
551
        self.assertEqualDiff(
 
552
            'There is no public branch set for "%s".' % url, str(error))
 
553
 
 
554
    def test_no_repo(self):
 
555
        dir = controldir.ControlDir.create(self.get_url())
 
556
        error = errors.NoRepositoryPresent(dir)
 
557
        self.assertNotEqual(-1,
 
558
                            str(error).find((dir.transport.clone('..').base)))
 
559
        self.assertEqual(-1, str(error).find((dir.transport.base)))
 
560
 
 
561
    def test_corrupt_repository(self):
 
562
        repo = self.make_repository('.')
 
563
        error = errors.CorruptRepository(repo)
 
564
        self.assertEqualDiff("An error has been detected in the repository %s.\n"
 
565
                             "Please run brz reconcile on this repository." %
 
566
                             repo.controldir.root_transport.base,
 
567
                             str(error))
 
568
 
 
569
    def test_not_branch_bzrdir_with_repo(self):
 
570
        controldir = self.make_repository('repo').controldir
 
571
        err = errors.NotBranchError('path', controldir=controldir)
 
572
        self.assertEqual(
 
573
            'Not a branch: "path": location is a repository.', str(err))
 
574
 
 
575
    def test_not_branch_bzrdir_without_repo(self):
 
576
        controldir = self.make_controldir('bzrdir')
 
577
        err = errors.NotBranchError('path', controldir=controldir)
 
578
        self.assertEqual('Not a branch: "path".', str(err))
 
579
 
 
580
    def test_not_branch_laziness(self):
 
581
        real_bzrdir = self.make_controldir('path')
 
582
 
 
583
        class FakeBzrDir(object):
 
584
            def __init__(self):
 
585
                self.calls = []
 
586
 
 
587
            def open_repository(self):
 
588
                self.calls.append('open_repository')
 
589
                raise errors.NoRepositoryPresent(real_bzrdir)
 
590
        fake_bzrdir = FakeBzrDir()
 
591
        err = errors.NotBranchError('path', controldir=fake_bzrdir)
 
592
        self.assertEqual([], fake_bzrdir.calls)
 
593
        str(err)
 
594
        self.assertEqual(['open_repository'], fake_bzrdir.calls)
 
595
        # Stringifying twice doesn't try to open a repository twice.
 
596
        str(err)
 
597
        self.assertEqual(['open_repository'], fake_bzrdir.calls)