/breezy/unstable

To get this branch, use:
bzr branch https://code.breezy-vcs.org/breezy/unstable

« back to all changes in this revision

Viewing changes to breezy/tests/per_transport.py

  • Committer: Jelmer Vernooij
  • Date: 2017-05-24 01:39:33 UTC
  • mfrom: (3815.3776.6)
  • Revision ID: jelmer@jelmer.uk-20170524013933-ir4y4tqtrsiz2ka2
New upstream snapshot.

Show diffs side-by-side

added added

removed removed

Lines of Context:
22
22
 
23
23
import itertools
24
24
import os
25
 
from cStringIO import StringIO
26
 
from StringIO import StringIO as pyStringIO
27
25
import stat
28
26
import sys
29
27
 
30
 
from bzrlib import (
 
28
from .. import (
31
29
    errors,
32
30
    osutils,
33
31
    pyutils,
35
33
    transport as _mod_transport,
36
34
    urlutils,
37
35
    )
38
 
from bzrlib.errors import (ConnectionError,
39
 
                           FileExists,
40
 
                           InvalidURL,
41
 
                           NoSuchFile,
42
 
                           PathError,
43
 
                           TransportNotPossible,
44
 
                           )
45
 
from bzrlib.osutils import getcwd
46
 
from bzrlib.smart import medium
47
 
from bzrlib.tests import (
 
36
from ..errors import (ConnectionError,
 
37
                      FileExists,
 
38
                      InvalidURL,
 
39
                      NoSuchFile,
 
40
                      PathError,
 
41
                      TransportNotPossible,
 
42
                      )
 
43
from ..osutils import getcwd
 
44
from ..sixish import (
 
45
    BytesIO,
 
46
    )
 
47
from ..smart import medium
 
48
from . import (
48
49
    TestSkipped,
49
50
    TestNotApplicable,
50
51
    multiply_tests,
51
52
    )
52
 
from bzrlib.tests import test_server
53
 
from bzrlib.tests.test_transport import TestTransportImplementation
54
 
from bzrlib.transport import (
 
53
from . import test_server
 
54
from .test_transport import TestTransportImplementation
 
55
from ..transport import (
55
56
    ConnectedTransport,
56
57
    Transport,
57
58
    _get_transport_modules,
58
59
    )
59
 
from bzrlib.transport.memory import MemoryTransport
60
 
from bzrlib.transport.remote import RemoteTransport
 
60
from ..transport.memory import MemoryTransport
 
61
from ..transport.remote import RemoteTransport
61
62
 
62
63
 
63
64
def get_transport_test_permutations(module):
82
83
                    {"transport_class":klass,
83
84
                     "transport_server":server_factory})
84
85
                result.append(scenario)
85
 
        except errors.DependencyNotPresent, e:
 
86
        except errors.DependencyNotPresent as e:
86
87
            # Continue even if a dependency prevents us
87
88
            # from adding this test
88
89
            pass
89
90
    return result
90
91
 
91
92
 
92
 
def load_tests(standard_tests, module, loader):
 
93
def load_tests(loader, standard_tests, pattern):
93
94
    """Multiply tests for tranport implementations."""
94
95
    result = loader.suiteClass()
95
96
    scenarios = transport_test_permutations()
100
101
 
101
102
    def setUp(self):
102
103
        super(TransportTests, self).setUp()
103
 
        self.overrideEnv('BZR_NO_SMART_VFS', None)
 
104
        self.overrideEnv('BRZ_NO_SMART_VFS', None)
104
105
 
105
106
    def check_transport_contents(self, content, transport, relpath):
106
107
        """Check that transport.get_bytes(relpath) == content."""
352
353
        if not t._can_roundtrip_unix_modebits():
353
354
            # Can't roundtrip, so no need to run this test
354
355
            return
355
 
        t.put_bytes('mode644', 'test text\n', mode=0644)
356
 
        self.assertTransportMode(t, 'mode644', 0644)
357
 
        t.put_bytes('mode666', 'test text\n', mode=0666)
358
 
        self.assertTransportMode(t, 'mode666', 0666)
359
 
        t.put_bytes('mode600', 'test text\n', mode=0600)
360
 
        self.assertTransportMode(t, 'mode600', 0600)
 
356
        t.put_bytes('mode644', 'test text\n', mode=0o644)
 
357
        self.assertTransportMode(t, 'mode644', 0o644)
 
358
        t.put_bytes('mode666', 'test text\n', mode=0o666)
 
359
        self.assertTransportMode(t, 'mode666', 0o666)
 
360
        t.put_bytes('mode600', 'test text\n', mode=0o600)
 
361
        self.assertTransportMode(t, 'mode600', 0o600)
361
362
        # Yes, you can put_bytes a file such that it becomes readonly
362
 
        t.put_bytes('mode400', 'test text\n', mode=0400)
363
 
        self.assertTransportMode(t, 'mode400', 0400)
 
363
        t.put_bytes('mode400', 'test text\n', mode=0o400)
 
364
        self.assertTransportMode(t, 'mode400', 0o400)
364
365
 
365
366
        # The default permissions should be based on the current umask
366
367
        umask = osutils.get_umask()
367
368
        t.put_bytes('nomode', 'test text\n', mode=None)
368
 
        self.assertTransportMode(t, 'nomode', 0666 & ~umask)
 
369
        self.assertTransportMode(t, 'nomode', 0o666 & ~umask)
369
370
 
370
371
    def test_put_bytes_non_atomic_permissions(self):
371
372
        t = self.get_transport()
375
376
        if not t._can_roundtrip_unix_modebits():
376
377
            # Can't roundtrip, so no need to run this test
377
378
            return
378
 
        t.put_bytes_non_atomic('mode644', 'test text\n', mode=0644)
379
 
        self.assertTransportMode(t, 'mode644', 0644)
380
 
        t.put_bytes_non_atomic('mode666', 'test text\n', mode=0666)
381
 
        self.assertTransportMode(t, 'mode666', 0666)
382
 
        t.put_bytes_non_atomic('mode600', 'test text\n', mode=0600)
383
 
        self.assertTransportMode(t, 'mode600', 0600)
384
 
        t.put_bytes_non_atomic('mode400', 'test text\n', mode=0400)
385
 
        self.assertTransportMode(t, 'mode400', 0400)
 
379
        t.put_bytes_non_atomic('mode644', 'test text\n', mode=0o644)
 
380
        self.assertTransportMode(t, 'mode644', 0o644)
 
381
        t.put_bytes_non_atomic('mode666', 'test text\n', mode=0o666)
 
382
        self.assertTransportMode(t, 'mode666', 0o666)
 
383
        t.put_bytes_non_atomic('mode600', 'test text\n', mode=0o600)
 
384
        self.assertTransportMode(t, 'mode600', 0o600)
 
385
        t.put_bytes_non_atomic('mode400', 'test text\n', mode=0o400)
 
386
        self.assertTransportMode(t, 'mode400', 0o400)
386
387
 
387
388
        # The default permissions should be based on the current umask
388
389
        umask = osutils.get_umask()
389
390
        t.put_bytes_non_atomic('nomode', 'test text\n', mode=None)
390
 
        self.assertTransportMode(t, 'nomode', 0666 & ~umask)
 
391
        self.assertTransportMode(t, 'nomode', 0o666 & ~umask)
391
392
 
392
393
        # We should also be able to set the mode for a parent directory
393
394
        # when it is created
394
 
        t.put_bytes_non_atomic('dir700/mode664', 'test text\n', mode=0664,
395
 
                               dir_mode=0700, create_parent_dir=True)
396
 
        self.assertTransportMode(t, 'dir700', 0700)
397
 
        t.put_bytes_non_atomic('dir770/mode664', 'test text\n', mode=0664,
398
 
                               dir_mode=0770, create_parent_dir=True)
399
 
        self.assertTransportMode(t, 'dir770', 0770)
400
 
        t.put_bytes_non_atomic('dir777/mode664', 'test text\n', mode=0664,
401
 
                               dir_mode=0777, create_parent_dir=True)
402
 
        self.assertTransportMode(t, 'dir777', 0777)
 
395
        t.put_bytes_non_atomic('dir700/mode664', 'test text\n', mode=0o664,
 
396
                               dir_mode=0o700, create_parent_dir=True)
 
397
        self.assertTransportMode(t, 'dir700', 0o700)
 
398
        t.put_bytes_non_atomic('dir770/mode664', 'test text\n', mode=0o664,
 
399
                               dir_mode=0o770, create_parent_dir=True)
 
400
        self.assertTransportMode(t, 'dir770', 0o770)
 
401
        t.put_bytes_non_atomic('dir777/mode664', 'test text\n', mode=0o664,
 
402
                               dir_mode=0o777, create_parent_dir=True)
 
403
        self.assertTransportMode(t, 'dir777', 0o777)
403
404
 
404
405
    def test_put_file(self):
405
406
        t = self.get_transport()
406
407
 
407
408
        if t.is_readonly():
408
409
            self.assertRaises(TransportNotPossible,
409
 
                    t.put_file, 'a', StringIO('some text for a\n'))
 
410
                    t.put_file, 'a', BytesIO(b'some text for a\n'))
410
411
            return
411
412
 
412
 
        result = t.put_file('a', StringIO('some text for a\n'))
 
413
        result = t.put_file('a', BytesIO(b'some text for a\n'))
413
414
        # put_file returns the length of the data written
414
415
        self.assertEqual(16, result)
415
416
        self.assertTrue(t.has('a'))
416
417
        self.check_transport_contents('some text for a\n', t, 'a')
417
418
        # Put also replaces contents
418
 
        result = t.put_file('a', StringIO('new\ncontents for\na\n'))
 
419
        result = t.put_file('a', BytesIO(b'new\ncontents for\na\n'))
419
420
        self.assertEqual(19, result)
420
421
        self.check_transport_contents('new\ncontents for\na\n', t, 'a')
421
422
        self.assertRaises(NoSuchFile,
422
423
                          t.put_file, 'path/doesnt/exist/c',
423
 
                              StringIO('contents'))
 
424
                              BytesIO(b'contents'))
424
425
 
425
426
    def test_put_file_non_atomic(self):
426
427
        t = self.get_transport()
427
428
 
428
429
        if t.is_readonly():
429
430
            self.assertRaises(TransportNotPossible,
430
 
                    t.put_file_non_atomic, 'a', StringIO('some text for a\n'))
 
431
                    t.put_file_non_atomic, 'a', BytesIO(b'some text for a\n'))
431
432
            return
432
433
 
433
434
        self.assertFalse(t.has('a'))
434
 
        t.put_file_non_atomic('a', StringIO('some text for a\n'))
 
435
        t.put_file_non_atomic('a', BytesIO(b'some text for a\n'))
435
436
        self.assertTrue(t.has('a'))
436
437
        self.check_transport_contents('some text for a\n', t, 'a')
437
438
        # Put also replaces contents
438
 
        t.put_file_non_atomic('a', StringIO('new\ncontents for\na\n'))
 
439
        t.put_file_non_atomic('a', BytesIO(b'new\ncontents for\na\n'))
439
440
        self.check_transport_contents('new\ncontents for\na\n', t, 'a')
440
441
 
441
442
        # Make sure we can create another file
442
 
        t.put_file_non_atomic('d', StringIO('contents for\nd\n'))
 
443
        t.put_file_non_atomic('d', BytesIO(b'contents for\nd\n'))
443
444
        # And overwrite 'a' with empty contents
444
 
        t.put_file_non_atomic('a', StringIO(''))
 
445
        t.put_file_non_atomic('a', BytesIO(b''))
445
446
        self.check_transport_contents('contents for\nd\n', t, 'd')
446
447
        self.check_transport_contents('', t, 'a')
447
448
 
448
449
        self.assertRaises(NoSuchFile, t.put_file_non_atomic, 'no/such/path',
449
 
                                       StringIO('contents\n'))
 
450
                                       BytesIO(b'contents\n'))
450
451
        # Now test the create_parent flag
451
452
        self.assertRaises(NoSuchFile, t.put_file_non_atomic, 'dir/a',
452
 
                                       StringIO('contents\n'))
 
453
                                       BytesIO(b'contents\n'))
453
454
        self.assertFalse(t.has('dir/a'))
454
 
        t.put_file_non_atomic('dir/a', StringIO('contents for dir/a\n'),
 
455
        t.put_file_non_atomic('dir/a', BytesIO(b'contents for dir/a\n'),
455
456
                              create_parent_dir=True)
456
457
        self.check_transport_contents('contents for dir/a\n', t, 'dir/a')
457
458
 
458
459
        # But we still get NoSuchFile if we can't make the parent dir
459
460
        self.assertRaises(NoSuchFile, t.put_file_non_atomic, 'not/there/a',
460
 
                                       StringIO('contents\n'),
 
461
                                       BytesIO(b'contents\n'),
461
462
                                       create_parent_dir=True)
462
463
 
463
464
    def test_put_file_permissions(self):
469
470
        if not t._can_roundtrip_unix_modebits():
470
471
            # Can't roundtrip, so no need to run this test
471
472
            return
472
 
        t.put_file('mode644', StringIO('test text\n'), mode=0644)
473
 
        self.assertTransportMode(t, 'mode644', 0644)
474
 
        t.put_file('mode666', StringIO('test text\n'), mode=0666)
475
 
        self.assertTransportMode(t, 'mode666', 0666)
476
 
        t.put_file('mode600', StringIO('test text\n'), mode=0600)
477
 
        self.assertTransportMode(t, 'mode600', 0600)
 
473
        t.put_file('mode644', BytesIO(b'test text\n'), mode=0o644)
 
474
        self.assertTransportMode(t, 'mode644', 0o644)
 
475
        t.put_file('mode666', BytesIO(b'test text\n'), mode=0o666)
 
476
        self.assertTransportMode(t, 'mode666', 0o666)
 
477
        t.put_file('mode600', BytesIO(b'test text\n'), mode=0o600)
 
478
        self.assertTransportMode(t, 'mode600', 0o600)
478
479
        # Yes, you can put a file such that it becomes readonly
479
 
        t.put_file('mode400', StringIO('test text\n'), mode=0400)
480
 
        self.assertTransportMode(t, 'mode400', 0400)
 
480
        t.put_file('mode400', BytesIO(b'test text\n'), mode=0o400)
 
481
        self.assertTransportMode(t, 'mode400', 0o400)
481
482
        # The default permissions should be based on the current umask
482
483
        umask = osutils.get_umask()
483
 
        t.put_file('nomode', StringIO('test text\n'), mode=None)
484
 
        self.assertTransportMode(t, 'nomode', 0666 & ~umask)
 
484
        t.put_file('nomode', BytesIO(b'test text\n'), mode=None)
 
485
        self.assertTransportMode(t, 'nomode', 0o666 & ~umask)
485
486
 
486
487
    def test_put_file_non_atomic_permissions(self):
487
488
        t = self.get_transport()
491
492
        if not t._can_roundtrip_unix_modebits():
492
493
            # Can't roundtrip, so no need to run this test
493
494
            return
494
 
        t.put_file_non_atomic('mode644', StringIO('test text\n'), mode=0644)
495
 
        self.assertTransportMode(t, 'mode644', 0644)
496
 
        t.put_file_non_atomic('mode666', StringIO('test text\n'), mode=0666)
497
 
        self.assertTransportMode(t, 'mode666', 0666)
498
 
        t.put_file_non_atomic('mode600', StringIO('test text\n'), mode=0600)
499
 
        self.assertTransportMode(t, 'mode600', 0600)
 
495
        t.put_file_non_atomic('mode644', BytesIO(b'test text\n'), mode=0o644)
 
496
        self.assertTransportMode(t, 'mode644', 0o644)
 
497
        t.put_file_non_atomic('mode666', BytesIO(b'test text\n'), mode=0o666)
 
498
        self.assertTransportMode(t, 'mode666', 0o666)
 
499
        t.put_file_non_atomic('mode600', BytesIO(b'test text\n'), mode=0o600)
 
500
        self.assertTransportMode(t, 'mode600', 0o600)
500
501
        # Yes, you can put_file_non_atomic a file such that it becomes readonly
501
 
        t.put_file_non_atomic('mode400', StringIO('test text\n'), mode=0400)
502
 
        self.assertTransportMode(t, 'mode400', 0400)
 
502
        t.put_file_non_atomic('mode400', BytesIO(b'test text\n'), mode=0o400)
 
503
        self.assertTransportMode(t, 'mode400', 0o400)
503
504
 
504
505
        # The default permissions should be based on the current umask
505
506
        umask = osutils.get_umask()
506
 
        t.put_file_non_atomic('nomode', StringIO('test text\n'), mode=None)
507
 
        self.assertTransportMode(t, 'nomode', 0666 & ~umask)
 
507
        t.put_file_non_atomic('nomode', BytesIO(b'test text\n'), mode=None)
 
508
        self.assertTransportMode(t, 'nomode', 0o666 & ~umask)
508
509
 
509
510
        # We should also be able to set the mode for a parent directory
510
511
        # when it is created
511
 
        sio = StringIO()
512
 
        t.put_file_non_atomic('dir700/mode664', sio, mode=0664,
513
 
                              dir_mode=0700, create_parent_dir=True)
514
 
        self.assertTransportMode(t, 'dir700', 0700)
515
 
        t.put_file_non_atomic('dir770/mode664', sio, mode=0664,
516
 
                              dir_mode=0770, create_parent_dir=True)
517
 
        self.assertTransportMode(t, 'dir770', 0770)
518
 
        t.put_file_non_atomic('dir777/mode664', sio, mode=0664,
519
 
                              dir_mode=0777, create_parent_dir=True)
520
 
        self.assertTransportMode(t, 'dir777', 0777)
 
512
        sio = BytesIO()
 
513
        t.put_file_non_atomic('dir700/mode664', sio, mode=0o664,
 
514
                              dir_mode=0o700, create_parent_dir=True)
 
515
        self.assertTransportMode(t, 'dir700', 0o700)
 
516
        t.put_file_non_atomic('dir770/mode664', sio, mode=0o664,
 
517
                              dir_mode=0o770, create_parent_dir=True)
 
518
        self.assertTransportMode(t, 'dir770', 0o770)
 
519
        t.put_file_non_atomic('dir777/mode664', sio, mode=0o664,
 
520
                              dir_mode=0o777, create_parent_dir=True)
 
521
        self.assertTransportMode(t, 'dir777', 0o777)
521
522
 
522
523
    def test_put_bytes_unicode(self):
523
524
        t = self.get_transport()
565
566
 
566
567
        # Test get/put in sub-directories
567
568
        t.put_bytes('dir_a/a', 'contents of dir_a/a')
568
 
        t.put_file('dir_b/b', StringIO('contents of dir_b/b'))
 
569
        t.put_file('dir_b/b', BytesIO(b'contents of dir_b/b'))
569
570
        self.check_transport_contents('contents of dir_a/a', t, 'dir_a/a')
570
571
        self.check_transport_contents('contents of dir_b/b', t, 'dir_b/b')
571
572
 
580
581
            # no sense testing on this transport
581
582
            return
582
583
        # Test mkdir with a mode
583
 
        t.mkdir('dmode755', mode=0755)
584
 
        self.assertTransportMode(t, 'dmode755', 0755)
585
 
        t.mkdir('dmode555', mode=0555)
586
 
        self.assertTransportMode(t, 'dmode555', 0555)
587
 
        t.mkdir('dmode777', mode=0777)
588
 
        self.assertTransportMode(t, 'dmode777', 0777)
589
 
        t.mkdir('dmode700', mode=0700)
590
 
        self.assertTransportMode(t, 'dmode700', 0700)
591
 
        t.mkdir_multi(['mdmode755'], mode=0755)
592
 
        self.assertTransportMode(t, 'mdmode755', 0755)
 
584
        t.mkdir('dmode755', mode=0o755)
 
585
        self.assertTransportMode(t, 'dmode755', 0o755)
 
586
        t.mkdir('dmode555', mode=0o555)
 
587
        self.assertTransportMode(t, 'dmode555', 0o555)
 
588
        t.mkdir('dmode777', mode=0o777)
 
589
        self.assertTransportMode(t, 'dmode777', 0o777)
 
590
        t.mkdir('dmode700', mode=0o700)
 
591
        self.assertTransportMode(t, 'dmode700', 0o700)
 
592
        t.mkdir_multi(['mdmode755'], mode=0o755)
 
593
        self.assertTransportMode(t, 'mdmode755', 0o755)
593
594
 
594
595
        # Default mode should be based on umask
595
596
        umask = osutils.get_umask()
596
597
        t.mkdir('dnomode', mode=None)
597
 
        self.assertTransportMode(t, 'dnomode', 0777 & ~umask)
 
598
        self.assertTransportMode(t, 'dnomode', 0o777 & ~umask)
598
599
 
599
600
    def test_opening_a_file_stream_creates_file(self):
600
601
        t = self.get_transport()
620
621
            handle = t.open_write_stream(name, mode=mode)
621
622
            handle.close()
622
623
            self.assertTransportMode(t, name, expected)
623
 
        check_mode('mode644', 0644, 0644)
624
 
        check_mode('mode666', 0666, 0666)
625
 
        check_mode('mode600', 0600, 0600)
 
624
        check_mode('mode644', 0o644, 0o644)
 
625
        check_mode('mode666', 0o666, 0o666)
 
626
        check_mode('mode600', 0o600, 0o600)
626
627
        # The default permissions should be based on the current umask
627
 
        check_mode('nomode', None, 0666 & ~osutils.get_umask())
 
628
        check_mode('nomode', None, 0o666 & ~osutils.get_umask())
628
629
 
629
630
    def test_copy_to(self):
630
631
        # FIXME: test:   same server to same server (partly done)
670
671
                                          t, f)
671
672
        del temp_transport
672
673
 
673
 
        for mode in (0666, 0644, 0600, 0400):
 
674
        for mode in (0o666, 0o644, 0o600, 0o400):
674
675
            temp_transport = MemoryTransport("memory:///")
675
676
            t.copy_to(files, temp_transport, mode=mode)
676
677
            for f in files:
697
698
        t.put_bytes('b', 'contents\nfor b\n')
698
699
 
699
700
        self.assertEqual(20,
700
 
            t.append_file('a', StringIO('add\nsome\nmore\ncontents\n')))
 
701
            t.append_file('a', BytesIO(b'add\nsome\nmore\ncontents\n')))
701
702
 
702
703
        self.check_transport_contents(
703
704
            'diff\ncontents for\na\nadd\nsome\nmore\ncontents\n',
705
706
 
706
707
        # a file with no parent should fail..
707
708
        self.assertRaises(NoSuchFile,
708
 
                          t.append_file, 'missing/path', StringIO('content'))
 
709
                          t.append_file, 'missing/path', BytesIO(b'content'))
709
710
 
710
711
        # And we can create new files, too
711
712
        self.assertEqual(0,
712
 
            t.append_file('c', StringIO('some text\nfor a missing file\n')))
 
713
            t.append_file('c', BytesIO(b'some text\nfor a missing file\n')))
713
714
        self.check_transport_contents('some text\nfor a missing file\n',
714
715
                                      t, 'c')
715
716
 
745
746
        t.put_bytes('b', 'contents\nfor b\n')
746
747
 
747
748
        self.assertEqual((43, 15),
748
 
            t.append_multi([('a', StringIO('and\nthen\nsome\nmore\n')),
749
 
                            ('b', StringIO('some\nmore\nfor\nb\n'))]))
 
749
            t.append_multi([('a', BytesIO(b'and\nthen\nsome\nmore\n')),
 
750
                            ('b', BytesIO(b'some\nmore\nfor\nb\n'))]))
750
751
 
751
752
        self.check_transport_contents(
752
753
            'diff\ncontents for\na\n'
759
760
                t, 'b')
760
761
 
761
762
        self.assertEqual((62, 31),
762
 
            t.append_multi(iter([('a', StringIO('a little bit more\n')),
763
 
                                 ('b', StringIO('from an iterator\n'))])))
 
763
            t.append_multi(iter([('a', BytesIO(b'a little bit more\n')),
 
764
                                 ('b', BytesIO(b'from an iterator\n'))])))
764
765
        self.check_transport_contents(
765
766
            'diff\ncontents for\na\n'
766
767
            'add\nsome\nmore\ncontents\n'
774
775
                t, 'b')
775
776
 
776
777
        self.assertEqual((80, 0),
777
 
            t.append_multi([('a', StringIO('some text in a\n')),
778
 
                            ('d', StringIO('missing file r\n'))]))
 
778
            t.append_multi([('a', BytesIO(b'some text in a\n')),
 
779
                            ('d', BytesIO(b'missing file r\n'))]))
779
780
 
780
781
        self.check_transport_contents(
781
782
            'diff\ncontents for\na\n'
792
793
        t = self.get_transport()
793
794
        if t.is_readonly():
794
795
            self.assertRaises(TransportNotPossible,
795
 
                t.append_file, 'f', StringIO('f'), mode=None)
 
796
                t.append_file, 'f', BytesIO(b'f'), mode=None)
796
797
            return
797
 
        t.append_file('f', StringIO('f'), mode=None)
 
798
        t.append_file('f', BytesIO(b'f'), mode=None)
798
799
 
799
800
    def test_append_bytes_mode(self):
800
801
        # check append_bytes accepts a mode
1049
1050
 
1050
1051
        try:
1051
1052
            st = t.stat('.')
1052
 
        except TransportNotPossible, e:
 
1053
        except TransportNotPossible as e:
1053
1054
            # This transport cannot stat
1054
1055
            return
1055
1056
 
1135
1136
            return
1136
1137
 
1137
1138
        def sorted_list(d, transport):
1138
 
            l = list(transport.list_dir(d))
1139
 
            l.sort()
 
1139
            l = sorted(transport.list_dir(d))
1140
1140
            return l
1141
1141
 
1142
1142
        self.assertEqual([], sorted_list('.', t))
1417
1417
        transport = self.get_transport()
1418
1418
        try:
1419
1419
            p = transport.local_abspath('.')
1420
 
        except (errors.NotLocalUrl, TransportNotPossible), e:
 
1420
        except (errors.NotLocalUrl, TransportNotPossible) as e:
1421
1421
            # should be formattable
1422
1422
            s = str(e)
1423
1423
        else:
1456
1456
        paths = set(transport.iter_files_recursive())
1457
1457
        # nb the directories are not converted
1458
1458
        self.assertEqual(paths,
1459
 
                    set(['isolated/dir/foo',
 
1459
                    {'isolated/dir/foo',
1460
1460
                         'isolated/dir/bar',
1461
1461
                         'isolated/dir/b%2525z',
1462
 
                         'isolated/bar']))
 
1462
                         'isolated/bar'})
1463
1463
        sub_transport = transport.clone('isolated')
1464
1464
        paths = set(sub_transport.iter_files_recursive())
1465
1465
        self.assertEqual(paths,
1466
 
            set(['dir/foo', 'dir/bar', 'dir/b%2525z', 'bar']))
 
1466
            {'dir/foo', 'dir/bar', 'dir/b%2525z', 'bar'})
1467
1467
 
1468
1468
    def test_copy_tree(self):
1469
1469
        # TODO: test file contents and permissions are preserved. This test was
1486
1486
        transport.copy_tree('from', 'to')
1487
1487
        paths = set(transport.iter_files_recursive())
1488
1488
        self.assertEqual(paths,
1489
 
                    set(['from/dir/foo',
 
1489
                    {'from/dir/foo',
1490
1490
                         'from/dir/bar',
1491
1491
                         'from/dir/b%2525z',
1492
1492
                         'from/bar',
1493
1493
                         'to/dir/foo',
1494
1494
                         'to/dir/bar',
1495
1495
                         'to/dir/b%2525z',
1496
 
                         'to/bar',]))
 
1496
                         'to/bar',})
1497
1497
 
1498
1498
    def test_copy_tree_to_transport(self):
1499
1499
        transport = self.get_transport()
1516
1516
        from_transport.copy_tree_to_transport(to_transport)
1517
1517
        paths = set(transport.iter_files_recursive())
1518
1518
        self.assertEqual(paths,
1519
 
                    set(['from/dir/foo',
 
1519
                    {'from/dir/foo',
1520
1520
                         'from/dir/bar',
1521
1521
                         'from/dir/b%2525z',
1522
1522
                         'from/bar',
1523
1523
                         'to/dir/foo',
1524
1524
                         'to/dir/bar',
1525
1525
                         'to/dir/b%2525z',
1526
 
                         'to/bar',]))
 
1526
                         'to/bar',})
1527
1527
 
1528
1528
    def test_unicode_paths(self):
1529
1529
        """Test that we can read/write files with Unicode names."""