← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_errors.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2010-03-29 08:06:16 UTC
  • mfrom: (5120.1.1 integration)
  • Revision ID: pqm@pqm.ubuntu.com-20100329080616-84azimjwafaukcey
(igc) Fix py2exe packaging of sqlite3

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_errors.py
1
 
# Copyright (C) 2006 by Canonical Ltd
2
 
#   Authors: Robert Collins <robert.collins@canonical.com>
 
1
# Copyright (C) 2006-2010 Canonical Ltd
3
2
#
4
3
# This program is free software; you can redistribute it and/or modify
5
4
# it under the terms of the GNU General Public License as published by
13
12
#
14
13
# You should have received a copy of the GNU General Public License
15
14
# along with this program; if not, write to the Free Software
16
 
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17
16
 
18
17
"""Tests for the formatting and construction of errors."""
19
18
 
20
 
import bzrlib.bzrdir as bzrdir
21
 
import bzrlib.errors as errors
22
 
from bzrlib.tests import TestCaseWithTransport
 
19
import socket
 
20
import sys
 
21
 
 
22
from bzrlib import (
 
23
    bzrdir,
 
24
    errors,
 
25
    osutils,
 
26
    symbol_versioning,
 
27
    urlutils,
 
28
    )
 
29
from bzrlib.tests import TestCase, TestCaseWithTransport
23
30
 
24
31
 
25
32
class TestErrors(TestCaseWithTransport):
26
33
 
 
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
    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))
 
59
 
 
60
    def test_duplicate_file_id(self):
 
61
        error = errors.DuplicateFileId('a_file_id', 'foo')
 
62
        self.assertEqualDiff('File id {a_file_id} already exists in inventory'
 
63
                             ' as foo', str(error))
 
64
 
 
65
    def test_duplicate_help_prefix(self):
 
66
        error = errors.DuplicateHelpPrefix('foo')
 
67
        self.assertEqualDiff('The prefix foo is in the help search path twice.',
 
68
            str(error))
 
69
 
 
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
    def test_incompatibleAPI(self):
 
77
        error = errors.IncompatibleAPI("module", (1, 2, 3), (4, 5, 6), (7, 8, 9))
 
78
        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)".',
 
81
            str(error))
 
82
 
 
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
    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
    def test_in_process_transport(self):
 
97
        error = errors.InProcessTransport('fpp')
 
98
        self.assertEqualDiff(
 
99
            "The transport 'fpp' is only accessible within this process.",
 
100
            str(error))
 
101
 
 
102
    def test_invalid_http_range(self):
 
103
        error = errors.InvalidHttpRange('path',
 
104
                                        'Content-Range: potatoes 0-00/o0oo0',
 
105
                                        'bad range')
 
106
        self.assertEquals("Invalid http range"
 
107
                          " 'Content-Range: potatoes 0-00/o0oo0'"
 
108
                          " for path: bad range",
 
109
                          str(error))
 
110
 
 
111
    def test_invalid_range(self):
 
112
        error = errors.InvalidRange('path', 12, 'bad range')
 
113
        self.assertEquals("Invalid range access in path at 12: bad range",
 
114
                          str(error))
 
115
 
 
116
    def test_inventory_modified(self):
 
117
        error = errors.InventoryModified("a tree to be repred")
 
118
        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))
 
122
 
 
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))
 
128
 
 
129
    def test_lock_active(self):
 
130
        error = errors.LockActive("lock description")
 
131
        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))
 
159
 
 
160
    def test_medium_not_connected(self):
 
161
        error = errors.MediumNotConnected("a medium")
 
162
        self.assertEqualDiff(
 
163
            "The medium 'a medium' is not connected.", str(error))
 
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
 
27
172
    def test_no_repo(self):
28
173
        dir = bzrdir.BzrDir.create(self.get_url())
29
174
        error = errors.NoRepositoryPresent(dir)
30
 
        self.assertNotEqual(-1, str(error).find(repr(dir.transport.clone('..').base)))
31
 
        self.assertEqual(-1, str(error).find(repr(dir.transport.base)))
 
175
        self.assertNotEqual(-1, str(error).find((dir.transport.clone('..').base)))
 
176
        self.assertEqual(-1, str(error).find((dir.transport.base)))
 
177
 
 
178
    def test_no_smart_medium(self):
 
179
        error = errors.NoSmartMedium("a transport")
 
180
        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))
 
189
 
 
190
    def test_no_such_id(self):
 
191
        error = errors.NoSuchId("atree", "anid")
 
192
        self.assertEqualDiff("The file id \"anid\" is not present in the tree "
 
193
            "atree.",
 
194
            str(error))
 
195
 
 
196
    def test_no_such_revision_in_tree(self):
 
197
        error = errors.NoSuchRevisionInTree("atree", "anid")
 
198
        self.assertEqualDiff("The revision id {anid} is not present in the"
 
199
                             " tree atree.", str(error))
 
200
        self.assertIsInstance(error, errors.NoSuchRevision)
 
201
 
 
202
    def test_not_stacked(self):
 
203
        error = errors.NotStacked('a branch')
 
204
        self.assertEqualDiff("The branch 'a branch' is not stacked.",
 
205
            str(error))
 
206
 
 
207
    def test_not_write_locked(self):
 
208
        error = errors.NotWriteLocked('a thing to repr')
 
209
        self.assertEqualDiff("'a thing to repr' is not write locked but needs "
 
210
            "to be.",
 
211
            str(error))
 
212
 
 
213
    def test_lock_failed(self):
 
214
        error = errors.LockFailed('http://canonical.com/', 'readonly transport')
 
215
        self.assertEqualDiff("Cannot lock http://canonical.com/: readonly transport",
 
216
            str(error))
 
217
        self.assertFalse(error.internal_error)
 
218
 
 
219
    def test_too_many_concurrent_requests(self):
 
220
        error = errors.TooManyConcurrentRequests("a medium")
 
221
        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))
 
225
 
 
226
    def test_unavailable_representation(self):
 
227
        error = errors.UnavailableRepresentation(('key',), "mpdiff", "fulltext")
 
228
        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))
 
250
 
 
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
    def test_unstackable_repository_format(self):
 
257
        format = u'foo'
 
258
        url = "/foo"
 
259
        error = errors.UnstackableRepositoryFormat(format, url)
 
260
        self.assertEqualDiff(
 
261
            "The repository '/foo'(foo) is not a stackable format. "
 
262
            "You will need to upgrade the repository to permit branch stacking.",
 
263
            str(error))
32
264
 
33
265
    def test_up_to_date(self):
34
266
        error = errors.UpToDateFormat(bzrdir.BzrDirFormat4())
35
 
        self.assertEqualDiff("The branch format Bazaar-NG branch, "
36
 
                             "format 0.0.4 is already at the most "
 
267
        self.assertEqualDiff("The branch format All-in-one "
 
268
                             "format 4 is already at the most "
37
269
                             "recent format.",
38
270
                             str(error))
39
271
 
44
276
                             "Please run bzr reconcile on this repository." %
45
277
                             repo.bzrdir.root_transport.base,
46
278
                             str(error))
 
279
 
 
280
    def test_read_error(self):
 
281
        # a unicode path to check that %r is being used.
 
282
        path = u'a path'
 
283
        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)
 
322
 
 
323
    def test_bzrerror_from_literal_string(self):
 
324
        # Some code constructs BzrError from a literal string, in which case
 
325
        # no further formatting is done.  (I'm not sure raising the base class
 
326
        # is a great idea, but if the exception is not intended to be caught
 
327
        # perhaps no more is needed.)
 
328
        try:
 
329
            raise errors.BzrError('this is my errors; %d is not expanded')
 
330
        except errors.BzrError, e:
 
331
            self.assertEqual('this is my errors; %d is not expanded', str(e))
 
332
 
 
333
    def test_reading_completed(self):
 
334
        error = errors.ReadingCompleted("a request")
 
335
        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))
 
339
 
 
340
    def test_writing_completed(self):
 
341
        error = errors.WritingCompleted("a request")
 
342
        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))
 
346
 
 
347
    def test_writing_not_completed(self):
 
348
        error = errors.WritingNotComplete("a request")
 
349
        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))
 
353
 
 
354
    def test_transport_not_possible(self):
 
355
        error = errors.TransportNotPossible('readonly', 'original error')
 
356
        self.assertEqualDiff('Transport operation not possible:'
 
357
                         ' readonly original error', str(error))
 
358
 
 
359
    def assertSocketConnectionError(self, expected, *args, **kwargs):
 
360
        """Check the formatting of a SocketConnectionError exception"""
 
361
        e = errors.SocketConnectionError(*args, **kwargs)
 
362
        self.assertEqual(expected, str(e))
 
363
 
 
364
    def test_socket_connection_error(self):
 
365
        """Test the formatting of SocketConnectionError"""
 
366
 
 
367
        # There should be a default msg about failing to connect
 
368
        # we only require a host name.
 
369
        self.assertSocketConnectionError(
 
370
            'Failed to connect to ahost',
 
371
            'ahost')
 
372
 
 
373
        # If port is None, we don't put :None
 
374
        self.assertSocketConnectionError(
 
375
            'Failed to connect to ahost',
 
376
            'ahost', port=None)
 
377
        # But if port is supplied we include it
 
378
        self.assertSocketConnectionError(
 
379
            'Failed to connect to ahost:22',
 
380
            'ahost', port=22)
 
381
 
 
382
        # We can also supply extra information about the error
 
383
        # with or without a port
 
384
        self.assertSocketConnectionError(
 
385
            'Failed to connect to ahost:22; bogus error',
 
386
            'ahost', port=22, orig_error='bogus error')
 
387
        self.assertSocketConnectionError(
 
388
            'Failed to connect to ahost; bogus error',
 
389
            'ahost', orig_error='bogus error')
 
390
        # An exception object can be passed rather than a string
 
391
        orig_error = ValueError('bad value')
 
392
        self.assertSocketConnectionError(
 
393
            'Failed to connect to ahost; %s' % (str(orig_error),),
 
394
            host='ahost', orig_error=orig_error)
 
395
 
 
396
        # And we can supply a custom failure message
 
397
        self.assertSocketConnectionError(
 
398
            'Unable to connect to ssh host ahost:444; my_error',
 
399
            host='ahost', port=444, msg='Unable to connect to ssh host',
 
400
            orig_error='my_error')
 
401
 
 
402
    def test_target_not_branch(self):
 
403
        """Test the formatting of TargetNotBranch."""
 
404
        error = errors.TargetNotBranch('foo')
 
405
        self.assertEqual(
 
406
            "Your branch does not have all of the revisions required in "
 
407
            "order to merge this merge directive and the target "
 
408
            "location specified in the merge directive is not a branch: "
 
409
            "foo.", str(error))
 
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
 
 
427
    def test_unexpected_smart_server_response(self):
 
428
        e = errors.UnexpectedSmartServerResponse(('not yes',))
 
429
        self.assertEqual(
 
430
            "Could not understand response from smart server: ('not yes',)",
 
431
            str(e))
 
432
 
 
433
    def test_unknown_container_format(self):
 
434
        """Test the formatting of UnknownContainerFormatError."""
 
435
        e = errors.UnknownContainerFormatError('bad format string')
 
436
        self.assertEqual(
 
437
            "Unrecognised container format: 'bad format string'",
 
438
            str(e))
 
439
 
 
440
    def test_unexpected_end_of_container(self):
 
441
        """Test the formatting of UnexpectedEndOfContainerError."""
 
442
        e = errors.UnexpectedEndOfContainerError()
 
443
        self.assertEqual(
 
444
            "Unexpected end of container stream", str(e))
 
445
 
 
446
    def test_unknown_record_type(self):
 
447
        """Test the formatting of UnknownRecordTypeError."""
 
448
        e = errors.UnknownRecordTypeError("X")
 
449
        self.assertEqual(
 
450
            "Unknown record type: 'X'",
 
451
            str(e))
 
452
 
 
453
    def test_invalid_record(self):
 
454
        """Test the formatting of InvalidRecordError."""
 
455
        e = errors.InvalidRecordError("xxx")
 
456
        self.assertEqual(
 
457
            "Invalid record: xxx",
 
458
            str(e))
 
459
 
 
460
    def test_container_has_excess_data(self):
 
461
        """Test the formatting of ContainerHasExcessDataError."""
 
462
        e = errors.ContainerHasExcessDataError("excess bytes")
 
463
        self.assertEqual(
 
464
            "Container has data after end marker: 'excess bytes'",
 
465
            str(e))
 
466
 
 
467
    def test_duplicate_record_name_error(self):
 
468
        """Test the formatting of DuplicateRecordNameError."""
 
469
        e = errors.DuplicateRecordNameError(u"n\xe5me".encode('utf-8'))
 
470
        self.assertEqual(
 
471
            "Container has multiple records with the same name: n\xc3\xa5me",
 
472
            str(e))
 
473
 
 
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
 
477
        e = errors.BzrCheckError('example check failure')
 
478
        self.assertEqual(
 
479
            "Internal check failed: example check failure",
 
480
            str(e))
 
481
        self.assertTrue(e.internal_error)
 
482
 
 
483
    def test_repository_data_stream_error(self):
 
484
        """Test the formatting of RepositoryDataStreamError."""
 
485
        e = errors.RepositoryDataStreamError(u"my reason")
 
486
        self.assertEqual(
 
487
            "Corrupt or incompatible data stream: my reason", str(e))
 
488
 
 
489
    def test_immortal_pending_deletion_message(self):
 
490
        err = errors.ImmortalPendingDeletion('foo')
 
491
        self.assertEquals(
 
492
            "Unable to delete transform temporary directory foo.  "
 
493
            "Please examine foo to see if it contains any files "
 
494
            "you wish to keep, and delete it when you are done.",
 
495
            str(err))
 
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
 
 
511
    def test_invalid_url_join(self):
 
512
        """Test the formatting of InvalidURLJoin."""
 
513
        e = errors.InvalidURLJoin('Reason', 'base path', ('args',))
 
514
        self.assertEqual(
 
515
            "Invalid URL join request: Reason: 'base path' + ('args',)",
 
516
            str(e))
 
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
 
 
525
    def test_unable_encode_path(self):
 
526
        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))
 
530
 
 
531
    def test_unknown_format(self):
 
532
        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')
 
550
 
 
551
    def test_tip_change_rejected(self):
 
552
        err = errors.TipChangeRejected(u'Unicode message\N{INTERROBANG}')
 
553
        self.assertEquals(
 
554
            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))
 
559
 
 
560
    def test_error_from_smart_server(self):
 
561
        error_tuple = ('error', 'tuple')
 
562
        err = errors.ErrorFromSmartServer(error_tuple)
 
563
        self.assertEquals(
 
564
            "Error received from smart server: ('error', 'tuple')", str(err))
 
565
 
 
566
    def test_untranslateable_error_from_smart_server(self):
 
567
        error_tuple = ('error', 'tuple')
 
568
        orig_err = errors.ErrorFromSmartServer(error_tuple)
 
569
        err = errors.UnknownErrorFromSmartServer(orig_err)
 
570
        self.assertEquals(
 
571
            "Server sent an unexpected error: ('error', 'tuple')", str(err))
 
572
 
 
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
 
 
659
class PassThroughError(errors.BzrError):
 
660
 
 
661
    _fmt = """Pass through %(foo)s and %(bar)s"""
 
662
 
 
663
    def __init__(self, foo, bar):
 
664
        errors.BzrError.__init__(self, foo=foo, bar=bar)
 
665
 
 
666
 
 
667
class ErrorWithBadFormat(errors.BzrError):
 
668
 
 
669
    _fmt = """One format specifier: %(thing)s"""
 
670
 
 
671
 
 
672
class ErrorWithNoFormat(errors.BzrError):
 
673
    """This class has a docstring but no format string."""
 
674
 
 
675
 
 
676
class TestErrorFormatting(TestCase):
 
677
 
 
678
    def test_always_str(self):
 
679
        e = PassThroughError(u'\xb5', 'bar')
 
680
        self.assertIsInstance(e.__str__(), str)
 
681
        # In Python str(foo) *must* return a real byte string
 
682
        # not a Unicode string. The following line would raise a
 
683
        # Unicode error, because it tries to call str() on the string
 
684
        # returned from e.__str__(), and it has non ascii characters
 
685
        s = str(e)
 
686
        self.assertEqual('Pass through \xc2\xb5 and bar', s)
 
687
 
 
688
    def test_missing_format_string(self):
 
689
        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.")
 
696
 
 
697
    def test_mismatched_format_args(self):
 
698
        # Even though ErrorWithBadFormat's format string does not match the
 
699
        # arguments we constructing it with, we can still stringify an instance
 
700
        # of this exception. The resulting string will say its unprintable.
 
701
        e = ErrorWithBadFormat(not_thing='x')
 
702
        self.assertStartsWith(
 
703
            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))