/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: Marius Kruger
  • Date: 2010-07-10 21:28:56 UTC
  • mto: (5384.1.1 integration)
  • mto: This revision was merged to the branch mainline in revision 5385.
  • Revision ID: marius.kruger@enerweb.co.za-20100710212856-uq4ji3go0u5se7hx
* Update documentation
* add NEWS

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_errors.py
1
 
# Copyright (C) 2006-2012, 2016 Canonical Ltd
 
1
# Copyright (C) 2006-2010 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
21
19
import socket
22
20
import sys
23
21
 
24
 
from .. import (
25
 
    controldir,
 
22
from bzrlib import (
 
23
    bzrdir,
26
24
    errors,
27
25
    osutils,
28
 
    tests,
 
26
    symbol_versioning,
29
27
    urlutils,
30
28
    )
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__))
 
29
from bzrlib.tests import TestCase, TestCaseWithTransport
 
30
 
 
31
 
 
32
class TestErrors(TestCaseWithTransport):
62
33
 
63
34
    def test_bad_filename_encoding(self):
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$")
 
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))
69
59
 
70
60
    def test_duplicate_file_id(self):
71
61
        error = errors.DuplicateFileId('a_file_id', 'foo')
75
65
    def test_duplicate_help_prefix(self):
76
66
        error = errors.DuplicateHelpPrefix('foo')
77
67
        self.assertEqualDiff('The prefix foo is in the help search path twice.',
78
 
                             str(error))
 
68
            str(error))
79
69
 
80
70
    def test_ghost_revisions_have_no_revno(self):
81
71
        error = errors.GhostRevisionsHaveNoRevno('target', 'ghost_rev')
83
73
                             " its ancestry shows a ghost at {ghost_rev}",
84
74
                             str(error))
85
75
 
86
 
    def test_incompatibleVersion(self):
87
 
        error = errors.IncompatibleVersion("module", [(4, 5, 6), (7, 8, 9)],
88
 
                                           (1, 2, 3))
 
76
    def test_incompatibleAPI(self):
 
77
        error = errors.IncompatibleAPI("module", (1, 2, 3), (4, 5, 6), (7, 8, 9))
89
78
        self.assertEqualDiff(
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).',
 
79
            'The API for "module" is not compatible with "(1, 2, 3)". '
 
80
            'It supports versions "(4, 5, 6)" to "(7, 8, 9)".',
93
81
            str(error))
94
82
 
95
83
    def test_inconsistent_delta(self):
115
103
        error = errors.InvalidHttpRange('path',
116
104
                                        'Content-Range: potatoes 0-00/o0oo0',
117
105
                                        'bad range')
118
 
        self.assertEqual("Invalid http range"
119
 
                         " 'Content-Range: potatoes 0-00/o0oo0'"
120
 
                         " for path: bad range",
121
 
                         str(error))
 
106
        self.assertEquals("Invalid http range"
 
107
                          " 'Content-Range: potatoes 0-00/o0oo0'"
 
108
                          " for path: bad range",
 
109
                          str(error))
122
110
 
123
111
    def test_invalid_range(self):
124
112
        error = errors.InvalidRange('path', 12, 'bad range')
125
 
        self.assertEqual("Invalid range access in path at 12: bad range",
126
 
                         str(error))
 
113
        self.assertEquals("Invalid range access in path at 12: bad range",
 
114
                          str(error))
127
115
 
128
116
    def test_inventory_modified(self):
129
117
        error = errors.InventoryModified("a tree to be repred")
130
118
        self.assertEqualDiff("The current inventory for the tree 'a tree to "
131
 
                             "be repred' has been modified, so a clean inventory cannot be "
132
 
                             "read without data loss.",
133
 
                             str(error))
 
119
            "be repred' has been modified, so a clean inventory cannot be "
 
120
            "read without data loss.",
 
121
            str(error))
134
122
 
135
123
    def test_jail_break(self):
136
124
        error = errors.JailBreak("some url")
137
125
        self.assertEqualDiff("An attempt to access a url outside the server"
138
 
                             " jail was made: 'some url'.",
139
 
                             str(error))
 
126
            " jail was made: 'some url'.",
 
127
            str(error))
140
128
 
141
129
    def test_lock_active(self):
142
130
        error = errors.LockActive("lock description")
143
131
        self.assertEqualDiff("The lock for 'lock description' is in use and "
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))
 
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))
153
159
 
154
160
    def test_medium_not_connected(self):
155
161
        error = errors.MediumNotConnected("a medium")
156
162
        self.assertEqualDiff(
157
163
            "The medium 'a medium' is not connected.", str(error))
158
164
 
 
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
 
159
178
    def test_no_smart_medium(self):
160
179
        error = errors.NoSmartMedium("a transport")
161
180
        self.assertEqualDiff("The transport 'a transport' cannot tunnel the "
162
 
                             "smart protocol.",
163
 
                             str(error))
 
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))
164
189
 
165
190
    def test_no_such_id(self):
166
191
        error = errors.NoSuchId("atree", "anid")
167
192
        self.assertEqualDiff("The file id \"anid\" is not present in the tree "
168
 
                             "atree.",
169
 
                             str(error))
 
193
            "atree.",
 
194
            str(error))
170
195
 
171
196
    def test_no_such_revision_in_tree(self):
172
197
        error = errors.NoSuchRevisionInTree("atree", "anid")
177
202
    def test_not_stacked(self):
178
203
        error = errors.NotStacked('a branch')
179
204
        self.assertEqualDiff("The branch 'a branch' is not stacked.",
180
 
                             str(error))
 
205
            str(error))
181
206
 
182
207
    def test_not_write_locked(self):
183
208
        error = errors.NotWriteLocked('a thing to repr')
184
209
        self.assertEqualDiff("'a thing to repr' is not write locked but needs "
185
 
                             "to be.",
186
 
                             str(error))
 
210
            "to be.",
 
211
            str(error))
187
212
 
188
213
    def test_lock_failed(self):
189
 
        error = errors.LockFailed(
190
 
            'http://canonical.com/', 'readonly transport')
 
214
        error = errors.LockFailed('http://canonical.com/', 'readonly transport')
191
215
        self.assertEqualDiff("Cannot lock http://canonical.com/: readonly transport",
192
 
                             str(error))
 
216
            str(error))
193
217
        self.assertFalse(error.internal_error)
194
218
 
195
219
    def test_too_many_concurrent_requests(self):
196
220
        error = errors.TooManyConcurrentRequests("a medium")
197
221
        self.assertEqualDiff("The medium 'a medium' has reached its concurrent "
198
 
                             "request limit. Be sure to finish_writing and finish_reading on "
199
 
                             "the currently open request.",
200
 
                             str(error))
 
222
            "request limit. Be sure to finish_writing and finish_reading on "
 
223
            "the currently open request.",
 
224
            str(error))
201
225
 
202
226
    def test_unavailable_representation(self):
203
 
        error = errors.UnavailableRepresentation(
204
 
            ('key',), "mpdiff", "fulltext")
 
227
        error = errors.UnavailableRepresentation(('key',), "mpdiff", "fulltext")
205
228
        self.assertEqualDiff("The encoding 'mpdiff' is not available for key "
206
 
                             "('key',) which is encoded as 'fulltext'.",
207
 
                             str(error))
 
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))
208
250
 
209
251
    def test_unstackable_location(self):
210
252
        error = errors.UnstackableLocationError('foo', 'bar')
211
253
        self.assertEqualDiff("The branch 'foo' cannot be stacked on 'bar'.",
212
 
                             str(error))
 
254
            str(error))
213
255
 
214
256
    def test_unstackable_repository_format(self):
215
257
        format = u'foo'
221
263
            str(error))
222
264
 
223
265
    def test_up_to_date(self):
224
 
        error = errors.UpToDateFormat("someformat")
225
 
        self.assertEqualDiff(
226
 
            "The branch format someformat is already at the most "
227
 
            "recent format.", str(error))
 
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))
228
279
 
229
280
    def test_read_error(self):
230
281
        # a unicode path to check that %r is being used.
231
282
        path = u'a path'
232
283
        error = errors.ReadError(path)
233
 
        self.assertContainsRe(str(error), "^Error reading from u?'a 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)
234
322
 
235
323
    def test_bzrerror_from_literal_string(self):
236
324
        # Some code constructs BzrError from a literal string, in which case
239
327
        # perhaps no more is needed.)
240
328
        try:
241
329
            raise errors.BzrError('this is my errors; %d is not expanded')
242
 
        except errors.BzrError as e:
 
330
        except errors.BzrError, e:
243
331
            self.assertEqual('this is my errors; %d is not expanded', str(e))
244
332
 
245
333
    def test_reading_completed(self):
246
334
        error = errors.ReadingCompleted("a request")
247
335
        self.assertEqualDiff("The MediumRequest 'a request' has already had "
248
 
                             "finish_reading called upon it - the request has been completed and"
249
 
                             " no more data may be read.",
250
 
                             str(error))
 
336
            "finish_reading called upon it - the request has been completed and"
 
337
            " no more data may be read.",
 
338
            str(error))
251
339
 
252
340
    def test_writing_completed(self):
253
341
        error = errors.WritingCompleted("a request")
254
342
        self.assertEqualDiff("The MediumRequest 'a request' has already had "
255
 
                             "finish_writing called upon it - accept bytes may not be called "
256
 
                             "anymore.",
257
 
                             str(error))
 
343
            "finish_writing called upon it - accept bytes may not be called "
 
344
            "anymore.",
 
345
            str(error))
258
346
 
259
347
    def test_writing_not_completed(self):
260
348
        error = errors.WritingNotComplete("a request")
261
349
        self.assertEqualDiff("The MediumRequest 'a request' has not has "
262
 
                             "finish_writing called upon it - until the write phase is complete"
263
 
                             " no data may be read.",
264
 
                             str(error))
 
350
            "finish_writing called upon it - until the write phase is complete"
 
351
            " no data may be read.",
 
352
            str(error))
265
353
 
266
354
    def test_transport_not_possible(self):
267
355
        error = errors.TransportNotPossible('readonly', 'original error')
268
356
        self.assertEqualDiff('Transport operation not possible:'
269
 
                             ' readonly original error', str(error))
 
357
                         ' readonly original error', str(error))
270
358
 
271
359
    def assertSocketConnectionError(self, expected, *args, **kwargs):
272
360
        """Check the formatting of a SocketConnectionError exception"""
320
408
            "location specified in the merge directive is not a branch: "
321
409
            "foo.", str(error))
322
410
 
 
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
 
323
427
    def test_unexpected_smart_server_response(self):
324
428
        e = errors.UnexpectedSmartServerResponse(('not yes',))
325
429
        self.assertEqual(
362
466
 
363
467
    def test_duplicate_record_name_error(self):
364
468
        """Test the formatting of DuplicateRecordNameError."""
365
 
        e = errors.DuplicateRecordNameError(b"n\xc3\xa5me")
 
469
        e = errors.DuplicateRecordNameError(u"n\xe5me".encode('utf-8'))
366
470
        self.assertEqual(
367
 
            u"Container has multiple records with the same name: n\xe5me",
368
 
            text_type(e))
 
471
            "Container has multiple records with the same name: n\xc3\xa5me",
 
472
            str(e))
369
473
 
370
474
    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
371
477
        e = errors.BzrCheckError('example check failure')
372
478
        self.assertEqual(
373
479
            "Internal check failed: example check failure",
382
488
 
383
489
    def test_immortal_pending_deletion_message(self):
384
490
        err = errors.ImmortalPendingDeletion('foo')
385
 
        self.assertEqual(
 
491
        self.assertEquals(
386
492
            "Unable to delete transform temporary directory foo.  "
387
493
            "Please examine foo to see if it contains any files "
388
494
            "you wish to keep, and delete it when you are done.",
389
495
            str(err))
390
496
 
 
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
 
391
511
    def test_invalid_url_join(self):
392
512
        """Test the formatting of InvalidURLJoin."""
393
 
        e = urlutils.InvalidURLJoin('Reason', 'base path', ('args',))
 
513
        e = errors.InvalidURLJoin('Reason', 'base path', ('args',))
394
514
        self.assertEqual(
395
515
            "Invalid URL join request: Reason: 'base path' + ('args',)",
396
516
            str(e))
397
517
 
 
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
 
398
525
    def test_unable_encode_path(self):
399
526
        err = errors.UnableEncodePath('foo', 'executable')
400
 
        self.assertEqual("Unable to encode executable path 'foo' in "
401
 
                         "user encoding " + osutils.get_user_encoding(),
402
 
                         str(err))
 
527
        self.assertEquals("Unable to encode executable path 'foo' in "
 
528
            "user encoding " + osutils.get_user_encoding(),
 
529
            str(err))
403
530
 
404
531
    def test_unknown_format(self):
405
532
        err = errors.UnknownFormatError('bar', kind='foo')
406
 
        self.assertEqual("Unknown foo format: 'bar'", str(err))
 
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')
407
550
 
408
551
    def test_tip_change_rejected(self):
409
552
        err = errors.TipChangeRejected(u'Unicode message\N{INTERROBANG}')
410
 
        self.assertEqual(
 
553
        self.assertEquals(
411
554
            u'Tip change rejected: Unicode message\N{INTERROBANG}',
412
 
            text_type(err))
 
555
            unicode(err))
 
556
        self.assertEquals(
 
557
            'Tip change rejected: Unicode message\xe2\x80\xbd',
 
558
            str(err))
413
559
 
414
560
    def test_error_from_smart_server(self):
415
561
        error_tuple = ('error', 'tuple')
416
562
        err = errors.ErrorFromSmartServer(error_tuple)
417
 
        self.assertEqual(
 
563
        self.assertEquals(
418
564
            "Error received from smart server: ('error', 'tuple')", str(err))
419
565
 
420
566
    def test_untranslateable_error_from_smart_server(self):
421
567
        error_tuple = ('error', 'tuple')
422
568
        orig_err = errors.ErrorFromSmartServer(error_tuple)
423
569
        err = errors.UnknownErrorFromSmartServer(orig_err)
424
 
        self.assertEqual(
 
570
        self.assertEquals(
425
571
            "Server sent an unexpected error: ('error', 'tuple')", str(err))
426
572
 
427
573
    def test_smart_message_handler_error(self):
429
575
        try:
430
576
            raise Exception("example error")
431
577
        except Exception:
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
 
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))
440
610
 
441
611
    def test_unresumable_write_group(self):
442
612
        repo = "dummy repo"
457
627
        err = errors.NotBranchError('path')
458
628
        self.assertEqual('Not a branch: "path".', str(err))
459
629
 
460
 
    def test_not_branch_bzrdir_with_recursive_not_branch_error(self):
 
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')
461
643
        class FakeBzrDir(object):
 
644
            def __init__(self):
 
645
                self.calls = []
462
646
            def open_repository(self):
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))
 
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
    def test_invalid_pattern(self):
 
659
        error = errors.InvalidPattern('Bad pattern msg.')
 
660
        self.assertEqualDiff("Invalid pattern(s) found. Bad pattern msg.",
 
661
            str(error))
482
662
 
483
663
 
484
664
class PassThroughError(errors.BzrError):
498
678
    __doc__ = """This class has a docstring but no format string."""
499
679
 
500
680
 
501
 
class TestErrorFormatting(tests.TestCase):
 
681
class TestErrorFormatting(TestCase):
502
682
 
503
683
    def test_always_str(self):
504
684
        e = PassThroughError(u'\xb5', 'bar')
505
685
        self.assertIsInstance(e.__str__(), str)
506
 
        # In Python 2 str(foo) *must* return a real byte string
 
686
        # In Python str(foo) *must* return a real byte string
507
687
        # not a Unicode string. The following line would raise a
508
688
        # Unicode error, because it tries to call str() on the string
509
689
        # returned from e.__str__(), and it has non ascii characters
510
690
        s = str(e)
511
 
        if PY3:
512
 
            self.assertEqual('Pass through \xb5 and bar', s)
513
 
        else:
514
 
            self.assertEqual('Pass through \xc2\xb5 and bar', s)
 
691
        self.assertEqual('Pass through \xc2\xb5 and bar', s)
515
692
 
516
693
    def test_missing_format_string(self):
517
694
        e = ErrorWithNoFormat(param='randomvalue')
518
 
        self.assertStartsWith(str(e),
519
 
                              "Unprintable exception ErrorWithNoFormat")
 
695
        s = self.callDeprecated(
 
696
                ['ErrorWithNoFormat uses its docstring as a format, it should use _fmt instead'],
 
697
                lambda x: str(x), e)
 
698
        ## s = str(e)
 
699
        self.assertEqual(s,
 
700
                "This class has a docstring but no format string.")
520
701
 
521
702
    def test_mismatched_format_args(self):
522
703
        # Even though ErrorWithBadFormat's format string does not match the
529
710
    def test_cannot_bind_address(self):
530
711
        # see <https://bugs.launchpad.net/bzr/+bug/286871>
531
712
        e = errors.CannotBindAddress('example.com', 22,
532
 
                                     socket.error(13, 'Permission denied'))
533
 
        self.assertContainsRe(
534
 
            str(e),
 
713
            socket.error(13, 'Permission denied'))
 
714
        self.assertContainsRe(str(e),
535
715
            r'Cannot bind address "example\.com:22":.*Permission denied')
536
716
 
 
717
    def test_file_timestamp_unavailable(self):            
 
718
        e = errors.FileTimestampUnavailable("/path/foo")
 
719
        self.assertEquals("The filestamp for /path/foo is not available.",
 
720
            str(e))
 
721
            
537
722
    def test_transform_rename_failed(self):
538
723
        e = errors.TransformRenameFailed(u"from", u"to", "readonly file", 2)
539
 
        self.assertEqual(
 
724
        self.assertEquals(
540
725
            u"Failed to rename from to to: readonly file",
541
726
            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)