← 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: John Arbash Meinel
  • Date: 2011-05-11 11:35:28 UTC
  • mto: This revision was merged to the branch mainline in revision 5851.
  • Revision ID: john@arbash-meinel.com-20110511113528-qepibuwxicjrbb2h
Break compatibility with python <2.6.

This includes auditing the code for places where we were doing
explicit 'sys.version' checks and removing them as appropriate.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_errors.py
1
 
# Copyright (C) 2006, 2007 Canonical Ltd
2
 
#   Authors: Robert Collins <robert.collins@canonical.com>
3
 
#            and others
 
1
# Copyright (C) 2006-2011 Canonical Ltd
4
2
#
5
3
# This program is free software; you can redistribute it and/or modify
6
4
# it under the terms of the GNU General Public License as published by
14
12
#
15
13
# You should have received a copy of the GNU General Public License
16
14
# along with this program; if not, write to the Free Software
17
 
# 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
18
16
 
19
17
"""Tests for the formatting and construction of errors."""
20
18
 
 
19
import inspect
 
20
import re
 
21
import socket
 
22
import sys
 
23
 
21
24
from bzrlib import (
22
25
    bzrdir,
23
26
    errors,
24
 
    symbol_versioning,
25
 
    )
26
 
from bzrlib.tests import TestCase, TestCaseWithTransport
 
27
    osutils,
 
28
    urlutils,
 
29
    )
 
30
from bzrlib.tests import (
 
31
    TestCase,
 
32
    TestCaseWithTransport,
 
33
    TestSkipped,
 
34
    )
27
35
 
28
36
 
29
37
class TestErrors(TestCaseWithTransport):
30
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
        subclasses_present = getattr(errors.BzrError, '__subclasses__', None)
 
49
        if not subclasses_present:
 
50
            raise TestSkipped('__subclasses__ attribute required for classes. '
 
51
                'Requires Python 2.5 or later.')
 
52
        for c in errors.BzrError.__subclasses__():
 
53
            init = getattr(c, '__init__', None)
 
54
            fmt = getattr(c, '_fmt', None)
 
55
            if init:
 
56
                args = inspect.getargspec(init)[0]
 
57
                self.assertFalse('message' in args,
 
58
                    ('Argument name "message" not allowed for '
 
59
                    '"errors.%s.__init__"' % c.__name__))
 
60
            if fmt and fmt_pattern.search(fmt):
 
61
                self.assertFalse(True, ('"message" not allowed in '
 
62
                    '"errors.%s._fmt"' % c.__name__))
 
63
 
 
64
    def test_bad_filename_encoding(self):
 
65
        error = errors.BadFilenameEncoding('bad/filen\xe5me', 'UTF-8')
 
66
        self.assertEqualDiff(
 
67
            "Filename 'bad/filen\\xe5me' is not valid in your current"
 
68
            " filesystem encoding UTF-8",
 
69
            str(error))
 
70
 
 
71
    def test_corrupt_dirstate(self):
 
72
        error = errors.CorruptDirstate('path/to/dirstate', 'the reason why')
 
73
        self.assertEqualDiff(
 
74
            "Inconsistency in dirstate file path/to/dirstate.\n"
 
75
            "Error: the reason why",
 
76
            str(error))
 
77
 
 
78
    def test_dirstate_corrupt(self):
 
79
        error = errors.DirstateCorrupt('.bzr/checkout/dirstate',
 
80
                                       'trailing garbage: "x"')
 
81
        self.assertEqualDiff("The dirstate file (.bzr/checkout/dirstate)"
 
82
            " appears to be corrupt: trailing garbage: \"x\"",
 
83
            str(error))
 
84
 
31
85
    def test_disabled_method(self):
32
86
        error = errors.DisabledMethod("class name")
33
87
        self.assertEqualDiff(
43
97
        self.assertEqualDiff('The prefix foo is in the help search path twice.',
44
98
            str(error))
45
99
 
 
100
    def test_ghost_revisions_have_no_revno(self):
 
101
        error = errors.GhostRevisionsHaveNoRevno('target', 'ghost_rev')
 
102
        self.assertEqualDiff("Could not determine revno for {target} because"
 
103
                             " its ancestry shows a ghost at {ghost_rev}",
 
104
                             str(error))
 
105
 
46
106
    def test_incompatibleAPI(self):
47
107
        error = errors.IncompatibleAPI("module", (1, 2, 3), (4, 5, 6), (7, 8, 9))
48
108
        self.assertEqualDiff(
50
110
            'It supports versions "(4, 5, 6)" to "(7, 8, 9)".',
51
111
            str(error))
52
112
 
 
113
    def test_inconsistent_delta(self):
 
114
        error = errors.InconsistentDelta('path', 'file-id', 'reason for foo')
 
115
        self.assertEqualDiff(
 
116
            "An inconsistent delta was supplied involving 'path', 'file-id'\n"
 
117
            "reason: reason for foo",
 
118
            str(error))
 
119
 
 
120
    def test_inconsistent_delta_delta(self):
 
121
        error = errors.InconsistentDeltaDelta([], 'reason')
 
122
        self.assertEqualDiff(
 
123
            "An inconsistent delta was supplied: []\nreason: reason",
 
124
            str(error))
 
125
 
53
126
    def test_in_process_transport(self):
54
127
        error = errors.InProcessTransport('fpp')
55
128
        self.assertEqualDiff(
56
129
            "The transport 'fpp' is only accessible within this process.",
57
130
            str(error))
58
131
 
 
132
    def test_invalid_http_range(self):
 
133
        error = errors.InvalidHttpRange('path',
 
134
                                        'Content-Range: potatoes 0-00/o0oo0',
 
135
                                        'bad range')
 
136
        self.assertEquals("Invalid http range"
 
137
                          " 'Content-Range: potatoes 0-00/o0oo0'"
 
138
                          " for path: bad range",
 
139
                          str(error))
 
140
 
 
141
    def test_invalid_range(self):
 
142
        error = errors.InvalidRange('path', 12, 'bad range')
 
143
        self.assertEquals("Invalid range access in path at 12: bad range",
 
144
                          str(error))
 
145
 
59
146
    def test_inventory_modified(self):
60
147
        error = errors.InventoryModified("a tree to be repred")
61
148
        self.assertEqualDiff("The current inventory for the tree 'a tree to "
63
150
            "read without data loss.",
64
151
            str(error))
65
152
 
66
 
    def test_install_failed(self):
67
 
        error = errors.InstallFailed(['rev-one'])
68
 
        self.assertEqual("Could not install revisions:\nrev-one", str(error))
69
 
        error = errors.InstallFailed(['rev-one', 'rev-two'])
70
 
        self.assertEqual("Could not install revisions:\nrev-one, rev-two",
71
 
                         str(error))
72
 
        error = errors.InstallFailed([None])
73
 
        self.assertEqual("Could not install revisions:\nNone", str(error))
 
153
    def test_jail_break(self):
 
154
        error = errors.JailBreak("some url")
 
155
        self.assertEqualDiff("An attempt to access a url outside the server"
 
156
            " jail was made: 'some url'.",
 
157
            str(error))
74
158
 
75
159
    def test_lock_active(self):
76
160
        error = errors.LockActive("lock description")
78
162
            "cannot be broken.",
79
163
            str(error))
80
164
 
 
165
    def test_lock_corrupt(self):
 
166
        error = errors.LockCorrupt("corruption info")
 
167
        self.assertEqualDiff("Lock is apparently held, but corrupted: "
 
168
            "corruption info\n"
 
169
            "Use 'bzr break-lock' to clear it",
 
170
            str(error))
 
171
 
81
172
    def test_knit_data_stream_incompatible(self):
82
173
        error = errors.KnitDataStreamIncompatible(
83
174
            'stream format', 'target format')
85
176
                         '"stream format" into knit of format '
86
177
                         '"target format".', str(error))
87
178
 
 
179
    def test_knit_data_stream_unknown(self):
 
180
        error = errors.KnitDataStreamUnknown(
 
181
            'stream format')
 
182
        self.assertEqual('Cannot parse knit data stream of format '
 
183
                         '"stream format".', str(error))
 
184
 
88
185
    def test_knit_header_error(self):
89
186
        error = errors.KnitHeaderError('line foo\n', 'path/to/file')
90
187
        self.assertEqual("Knit header error: 'line foo\\n' unexpected"
101
198
        error = errors.MediumNotConnected("a medium")
102
199
        self.assertEqualDiff(
103
200
            "The medium 'a medium' is not connected.", str(error))
104
 
        
 
201
 
 
202
    def test_no_public_branch(self):
 
203
        b = self.make_branch('.')
 
204
        error = errors.NoPublicBranch(b)
 
205
        url = urlutils.unescape_for_display(b.base, 'ascii')
 
206
        self.assertEqualDiff(
 
207
            'There is no public branch set for "%s".' % url, str(error))
 
208
 
105
209
    def test_no_repo(self):
106
210
        dir = bzrdir.BzrDir.create(self.get_url())
107
211
        error = errors.NoRepositoryPresent(dir)
108
212
        self.assertNotEqual(-1, str(error).find((dir.transport.clone('..').base)))
109
213
        self.assertEqual(-1, str(error).find((dir.transport.base)))
110
 
        
 
214
 
111
215
    def test_no_smart_medium(self):
112
216
        error = errors.NoSmartMedium("a transport")
113
217
        self.assertEqualDiff("The transport 'a transport' cannot tunnel the "
132
236
                             " tree atree.", str(error))
133
237
        self.assertIsInstance(error, errors.NoSuchRevision)
134
238
 
 
239
    def test_not_stacked(self):
 
240
        error = errors.NotStacked('a branch')
 
241
        self.assertEqualDiff("The branch 'a branch' is not stacked.",
 
242
            str(error))
 
243
 
135
244
    def test_not_write_locked(self):
136
245
        error = errors.NotWriteLocked('a thing to repr')
137
246
        self.assertEqualDiff("'a thing to repr' is not write locked but needs "
138
247
            "to be.",
139
248
            str(error))
140
249
 
141
 
    def test_read_only_lock_error(self):
142
 
        error = self.applyDeprecated(symbol_versioning.zero_ninetytwo,
143
 
            errors.ReadOnlyLockError, 'filename', 'error message')
144
 
        self.assertEqualDiff("Cannot acquire write lock on filename."
145
 
                             " error message", str(error))
146
 
 
147
250
    def test_lock_failed(self):
148
251
        error = errors.LockFailed('http://canonical.com/', 'readonly transport')
149
252
        self.assertEqualDiff("Cannot lock http://canonical.com/: readonly transport",
157
260
            "the currently open request.",
158
261
            str(error))
159
262
 
 
263
    def test_unavailable_representation(self):
 
264
        error = errors.UnavailableRepresentation(('key',), "mpdiff", "fulltext")
 
265
        self.assertEqualDiff("The encoding 'mpdiff' is not available for key "
 
266
            "('key',) which is encoded as 'fulltext'.",
 
267
            str(error))
 
268
 
160
269
    def test_unknown_hook(self):
161
270
        error = errors.UnknownHook("branch", "foo")
162
271
        self.assertEqualDiff("The branch hook 'foo' is unknown in this version"
167
276
            " of bzrlib.",
168
277
            str(error))
169
278
 
 
279
    def test_unstackable_branch_format(self):
 
280
        format = u'foo'
 
281
        url = "/foo"
 
282
        error = errors.UnstackableBranchFormat(format, url)
 
283
        self.assertEqualDiff(
 
284
            "The branch '/foo'(foo) is not a stackable format. "
 
285
            "You will need to upgrade the branch to permit branch stacking.",
 
286
            str(error))
 
287
 
 
288
    def test_unstackable_location(self):
 
289
        error = errors.UnstackableLocationError('foo', 'bar')
 
290
        self.assertEqualDiff("The branch 'foo' cannot be stacked on 'bar'.",
 
291
            str(error))
 
292
 
 
293
    def test_unstackable_repository_format(self):
 
294
        format = u'foo'
 
295
        url = "/foo"
 
296
        error = errors.UnstackableRepositoryFormat(format, url)
 
297
        self.assertEqualDiff(
 
298
            "The repository '/foo'(foo) is not a stackable format. "
 
299
            "You will need to upgrade the repository to permit branch stacking.",
 
300
            str(error))
 
301
 
170
302
    def test_up_to_date(self):
171
 
        error = errors.UpToDateFormat(bzrdir.BzrDirFormat4())
172
 
        self.assertEqualDiff("The branch format Bazaar-NG branch, "
173
 
                             "format 0.0.4 is already at the most "
174
 
                             "recent format.",
175
 
                             str(error))
 
303
        error = errors.UpToDateFormat("someformat")
 
304
        self.assertEqualDiff(
 
305
            "The branch format someformat is already at the most "
 
306
            "recent format.", str(error))
176
307
 
177
308
    def test_corrupt_repository(self):
178
309
        repo = self.make_repository('.')
304
435
            host='ahost', port=444, msg='Unable to connect to ssh host',
305
436
            orig_error='my_error')
306
437
 
 
438
    def test_target_not_branch(self):
 
439
        """Test the formatting of TargetNotBranch."""
 
440
        error = errors.TargetNotBranch('foo')
 
441
        self.assertEqual(
 
442
            "Your branch does not have all of the revisions required in "
 
443
            "order to merge this merge directive and the target "
 
444
            "location specified in the merge directive is not a branch: "
 
445
            "foo.", str(error))
 
446
 
307
447
    def test_malformed_bug_identifier(self):
308
448
        """Test the formatting of MalformedBugIdentifier."""
309
449
        error = errors.MalformedBugIdentifier('bogus', 'reason for bogosity')
310
450
        self.assertEqual(
311
 
            "Did not understand bug identifier bogus: reason for bogosity",
 
451
            'Did not understand bug identifier bogus: reason for bogosity. '
 
452
            'See "bzr help bugs" for more information on this feature.',
312
453
            str(error))
313
454
 
314
455
    def test_unknown_bug_tracker_abbreviation(self):
365
506
        self.assertEqual(
366
507
            "Container has multiple records with the same name: n\xc3\xa5me",
367
508
            str(e))
368
 
        
 
509
 
369
510
    def test_check_error(self):
370
511
        # This has a member called 'message', which is problematic in
371
512
        # python2.5 because that is a slot on the base Exception class
403
544
            "Unable to create symlink u'\\xb5' on this platform",
404
545
            str(err))
405
546
 
 
547
    def test_invalid_url_join(self):
 
548
        """Test the formatting of InvalidURLJoin."""
 
549
        e = errors.InvalidURLJoin('Reason', 'base path', ('args',))
 
550
        self.assertEqual(
 
551
            "Invalid URL join request: Reason: 'base path' + ('args',)",
 
552
            str(e))
 
553
 
 
554
    def test_incorrect_url(self):
 
555
        err = errors.InvalidBugTrackerURL('foo', 'http://bug.com/')
 
556
        self.assertEquals(
 
557
            ("The URL for bug tracker \"foo\" doesn't contain {id}: "
 
558
             "http://bug.com/"),
 
559
            str(err))
 
560
 
 
561
    def test_unable_encode_path(self):
 
562
        err = errors.UnableEncodePath('foo', 'executable')
 
563
        self.assertEquals("Unable to encode executable path 'foo' in "
 
564
            "user encoding " + osutils.get_user_encoding(),
 
565
            str(err))
 
566
 
 
567
    def test_unknown_format(self):
 
568
        err = errors.UnknownFormatError('bar', kind='foo')
 
569
        self.assertEquals("Unknown foo format: 'bar'", str(err))
 
570
 
 
571
    def test_unknown_rules(self):
 
572
        err = errors.UnknownRules(['foo', 'bar'])
 
573
        self.assertEquals("Unknown rules detected: foo, bar.", str(err))
 
574
 
 
575
    def test_hook_failed(self):
 
576
        # Create an exc_info tuple by raising and catching an exception.
 
577
        try:
 
578
            1/0
 
579
        except ZeroDivisionError:
 
580
            exc_info = sys.exc_info()
 
581
        err = errors.HookFailed('hook stage', 'hook name', exc_info, warn=False)
 
582
        self.assertStartsWith(
 
583
            str(err), 'Hook \'hook name\' during hook stage failed:\n')
 
584
        self.assertEndsWith(
 
585
            str(err), 'integer division or modulo by zero')
 
586
 
 
587
    def test_tip_change_rejected(self):
 
588
        err = errors.TipChangeRejected(u'Unicode message\N{INTERROBANG}')
 
589
        self.assertEquals(
 
590
            u'Tip change rejected: Unicode message\N{INTERROBANG}',
 
591
            unicode(err))
 
592
        self.assertEquals(
 
593
            'Tip change rejected: Unicode message\xe2\x80\xbd',
 
594
            str(err))
 
595
 
 
596
    def test_error_from_smart_server(self):
 
597
        error_tuple = ('error', 'tuple')
 
598
        err = errors.ErrorFromSmartServer(error_tuple)
 
599
        self.assertEquals(
 
600
            "Error received from smart server: ('error', 'tuple')", str(err))
 
601
 
 
602
    def test_untranslateable_error_from_smart_server(self):
 
603
        error_tuple = ('error', 'tuple')
 
604
        orig_err = errors.ErrorFromSmartServer(error_tuple)
 
605
        err = errors.UnknownErrorFromSmartServer(orig_err)
 
606
        self.assertEquals(
 
607
            "Server sent an unexpected error: ('error', 'tuple')", str(err))
 
608
 
 
609
    def test_smart_message_handler_error(self):
 
610
        # Make an exc_info tuple.
 
611
        try:
 
612
            raise Exception("example error")
 
613
        except Exception:
 
614
            exc_info = sys.exc_info()
 
615
        err = errors.SmartMessageHandlerError(exc_info)
 
616
        self.assertStartsWith(
 
617
            str(err), "The message handler raised an exception:\n")
 
618
        self.assertEndsWith(str(err), "Exception: example error\n")
 
619
 
 
620
    def test_must_have_working_tree(self):
 
621
        err = errors.MustHaveWorkingTree('foo', 'bar')
 
622
        self.assertEqual(str(err), "Branching 'bar'(foo) must create a"
 
623
                                   " working tree.")
 
624
 
 
625
    def test_no_such_view(self):
 
626
        err = errors.NoSuchView('foo')
 
627
        self.assertEquals("No such view: foo.", str(err))
 
628
 
 
629
    def test_views_not_supported(self):
 
630
        err = errors.ViewsNotSupported('atree')
 
631
        err_str = str(err)
 
632
        self.assertStartsWith(err_str, "Views are not supported by ")
 
633
        self.assertEndsWith(err_str, "; use 'bzr upgrade' to change your "
 
634
            "tree to a later format.")
 
635
 
 
636
    def test_file_outside_view(self):
 
637
        err = errors.FileOutsideView('baz', ['foo', 'bar'])
 
638
        self.assertEquals('Specified file "baz" is outside the current view: '
 
639
            'foo, bar', str(err))
 
640
 
 
641
    def test_invalid_shelf_id(self):
 
642
        invalid_id = "foo"
 
643
        err = errors.InvalidShelfId(invalid_id)
 
644
        self.assertEqual('"foo" is not a valid shelf id, '
 
645
            'try a number instead.', str(err))
 
646
 
 
647
    def test_unresumable_write_group(self):
 
648
        repo = "dummy repo"
 
649
        wg_tokens = ['token']
 
650
        reason = "a reason"
 
651
        err = errors.UnresumableWriteGroup(repo, wg_tokens, reason)
 
652
        self.assertEqual(
 
653
            "Repository dummy repo cannot resume write group "
 
654
            "['token']: a reason", str(err))
 
655
 
 
656
    def test_unsuspendable_write_group(self):
 
657
        repo = "dummy repo"
 
658
        err = errors.UnsuspendableWriteGroup(repo)
 
659
        self.assertEqual(
 
660
            'Repository dummy repo cannot suspend a write group.', str(err))
 
661
 
 
662
    def test_not_branch_no_args(self):
 
663
        err = errors.NotBranchError('path')
 
664
        self.assertEqual('Not a branch: "path".', str(err))
 
665
 
 
666
    def test_not_branch_bzrdir_with_repo(self):
 
667
        bzrdir = self.make_repository('repo').bzrdir
 
668
        err = errors.NotBranchError('path', bzrdir=bzrdir)
 
669
        self.assertEqual(
 
670
            'Not a branch: "path": location is a repository.', str(err))
 
671
 
 
672
    def test_not_branch_bzrdir_without_repo(self):
 
673
        bzrdir = self.make_bzrdir('bzrdir')
 
674
        err = errors.NotBranchError('path', bzrdir=bzrdir)
 
675
        self.assertEqual('Not a branch: "path".', str(err))
 
676
 
 
677
    def test_not_branch_bzrdir_with_recursive_not_branch_error(self):
 
678
        class FakeBzrDir(object):
 
679
            def open_repository(self):
 
680
                # str() on the NotBranchError will trigger a call to this,
 
681
                # which in turn will another, identical NotBranchError.
 
682
                raise errors.NotBranchError('path', bzrdir=FakeBzrDir())
 
683
        err = errors.NotBranchError('path', bzrdir=FakeBzrDir())
 
684
        self.assertEqual('Not a branch: "path".', str(err))
 
685
 
 
686
    def test_not_branch_laziness(self):
 
687
        real_bzrdir = self.make_bzrdir('path')
 
688
        class FakeBzrDir(object):
 
689
            def __init__(self):
 
690
                self.calls = []
 
691
            def open_repository(self):
 
692
                self.calls.append('open_repository')
 
693
                raise errors.NoRepositoryPresent(real_bzrdir)
 
694
        fake_bzrdir = FakeBzrDir()
 
695
        err = errors.NotBranchError('path', bzrdir=fake_bzrdir)
 
696
        self.assertEqual([], fake_bzrdir.calls)
 
697
        str(err)
 
698
        self.assertEqual(['open_repository'], fake_bzrdir.calls)
 
699
        # Stringifying twice doesn't try to open a repository twice.
 
700
        str(err)
 
701
        self.assertEqual(['open_repository'], fake_bzrdir.calls)
 
702
 
 
703
    def test_invalid_pattern(self):
 
704
        error = errors.InvalidPattern('Bad pattern msg.')
 
705
        self.assertEqualDiff("Invalid pattern(s) found. Bad pattern msg.",
 
706
            str(error))
 
707
 
 
708
    def test_recursive_bind(self):
 
709
        error = errors.RecursiveBind('foo_bar_branch')
 
710
        msg = ('Branch "foo_bar_branch" appears to be bound to itself. '
 
711
            'Please use `bzr unbind` to fix.')
 
712
        self.assertEqualDiff(msg, str(error))
 
713
 
406
714
 
407
715
class PassThroughError(errors.BzrError):
408
 
    
 
716
 
409
717
    _fmt = """Pass through %(foo)s and %(bar)s"""
410
718
 
411
719
    def __init__(self, foo, bar):
418
726
 
419
727
 
420
728
class ErrorWithNoFormat(errors.BzrError):
421
 
    """This class has a docstring but no format string."""
 
729
    __doc__ = """This class has a docstring but no format string."""
422
730
 
423
731
 
424
732
class TestErrorFormatting(TestCase):
425
 
    
 
733
 
426
734
    def test_always_str(self):
427
735
        e = PassThroughError(u'\xb5', 'bar')
428
736
        self.assertIsInstance(e.__str__(), str)
439
747
                ['ErrorWithNoFormat uses its docstring as a format, it should use _fmt instead'],
440
748
                lambda x: str(x), e)
441
749
        ## s = str(e)
442
 
        self.assertEqual(s, 
 
750
        self.assertEqual(s,
443
751
                "This class has a docstring but no format string.")
444
752
 
445
753
    def test_mismatched_format_args(self):
449
757
        e = ErrorWithBadFormat(not_thing='x')
450
758
        self.assertStartsWith(
451
759
            str(e), 'Unprintable exception ErrorWithBadFormat')
 
760
 
 
761
    def test_cannot_bind_address(self):
 
762
        # see <https://bugs.launchpad.net/bzr/+bug/286871>
 
763
        e = errors.CannotBindAddress('example.com', 22,
 
764
            socket.error(13, 'Permission denied'))
 
765
        self.assertContainsRe(str(e),
 
766
            r'Cannot bind address "example\.com:22":.*Permission denied')
 
767
 
 
768
    def test_file_timestamp_unavailable(self):            
 
769
        e = errors.FileTimestampUnavailable("/path/foo")
 
770
        self.assertEquals("The filestamp for /path/foo is not available.",
 
771
            str(e))
 
772
            
 
773
    def test_transform_rename_failed(self):
 
774
        e = errors.TransformRenameFailed(u"from", u"to", "readonly file", 2)
 
775
        self.assertEquals(
 
776
            u"Failed to rename from to to: readonly file",
 
777
            str(e))