← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_transport.py

  • Committer: John Arbash Meinel
  • Author(s): Mark Hammond
  • Date: 2008-09-09 17:02:21 UTC
  • mto: This revision was merged to the branch mainline in revision 3697.
  • Revision ID: john@arbash-meinel.com-20080909170221-svim3jw2mrz0amp3
An updated transparent icon for bzr.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_transport.py
48
48
from bzrlib.transport.memory import MemoryTransport
49
49
from bzrlib.transport.local import (LocalTransport,
50
50
                                    EmulatedWin32LocalTransport)
51
 
from bzrlib.transport.remote import (
52
 
    BZR_DEFAULT_PORT,
53
 
    RemoteTCPTransport
54
 
    )
55
51
 
56
52
 
57
53
# TODO: Should possibly split transport-specific tests into their own files.
78
74
        try:
79
75
            _clear_protocol_handlers()
80
76
            register_transport_proto('foo')
81
 
            register_lazy_transport('foo', 'bzrlib.tests.test_transport', 'TestTransport.SampleHandler')
 
77
            register_lazy_transport('foo', 'bzrlib.tests.test_transport',
 
78
                                    'TestTransport.SampleHandler')
82
79
            register_transport_proto('bar')
83
 
            register_lazy_transport('bar', 'bzrlib.tests.test_transport', 'TestTransport.SampleHandler')
84
 
            self.assertEqual([SampleHandler.__module__, 'bzrlib.transport.chroot'],
 
80
            register_lazy_transport('bar', 'bzrlib.tests.test_transport',
 
81
                                    'TestTransport.SampleHandler')
 
82
            self.assertEqual([SampleHandler.__module__,
 
83
                              'bzrlib.transport.chroot'],
85
84
                             _get_transport_modules())
86
85
        finally:
87
86
            _set_protocol_handlers(handlers)
153
152
 
154
153
 
155
154
class TestCoalesceOffsets(TestCase):
156
 
    
157
 
    def check(self, expected, offsets, limit=0, fudge=0):
 
155
 
 
156
    def check(self, expected, offsets, limit=0, max_size=0, fudge=0):
158
157
        coalesce = Transport._coalesce_offsets
159
158
        exp = [_CoalescedOffset(*x) for x in expected]
160
 
        out = list(coalesce(offsets, limit=limit, fudge_factor=fudge))
 
159
        out = list(coalesce(offsets, limit=limit, fudge_factor=fudge,
 
160
                            max_size=max_size))
161
161
        self.assertEqual(exp, out)
162
162
 
163
163
    def test_coalesce_empty(self):
170
170
        self.check([(0, 10, [(0, 10)]),
171
171
                    (20, 10, [(0, 10)]),
172
172
                   ], [(0, 10), (20, 10)])
173
 
            
 
173
 
174
174
    def test_coalesce_unsorted(self):
175
175
        self.check([(20, 10, [(0, 10)]),
176
176
                    (0, 10, [(0, 10)]),
180
180
        self.check([(0, 20, [(0, 10), (10, 10)])],
181
181
                   [(0, 10), (10, 10)])
182
182
 
 
183
    # XXX: scary, http.readv() can't handle that --vila20071209
183
184
    def test_coalesce_overlapped(self):
184
185
        self.check([(0, 15, [(0, 10), (5, 10)])],
185
186
                   [(0, 10), (5, 10)])
209
210
                   ], [(10, 10), (30, 10), (100, 10)],
210
211
                   fudge=10
211
212
                  )
 
213
    def test_coalesce_max_size(self):
 
214
        self.check([(10, 20, [(0, 10), (10, 10)]),
 
215
                    (30, 50, [(0, 50)]),
 
216
                    # If one range is above max_size, it gets its own coalesced
 
217
                    # offset
 
218
                    (100, 80, [(0, 80),]),],
 
219
                   [(10, 10), (20, 10), (30, 50), (100, 80)],
 
220
                   max_size=50
 
221
                  )
 
222
 
 
223
    def test_coalesce_no_max_size(self):
 
224
        self.check([(10, 170, [(0, 10), (10, 10), (20, 50), (70, 100)]),],
 
225
                   [(10, 10), (20, 10), (30, 50), (80, 100)],
 
226
                  )
212
227
 
213
228
 
214
229
class TestMemoryTransport(TestCase):
418
433
        self.assertEqual(True, transport.is_readonly())
419
434
 
420
435
    def test_http_parameters(self):
421
 
        from bzrlib.tests.HttpServer import HttpServer
 
436
        from bzrlib.tests.http_server import HttpServer
422
437
        import bzrlib.transport.readonly as readonly
423
 
        # connect to . via http which is not listable
 
438
        # connect to '.' via http which is not listable
424
439
        server = HttpServer()
425
440
        server.setUp()
426
441
        try:
451
466
    def test_http_parameters(self):
452
467
        # the listable and is_readonly parameters
453
468
        # are not changed by the fakenfs decorator
454
 
        from bzrlib.tests.HttpServer import HttpServer
455
 
        # connect to . via http which is not listable
 
469
        from bzrlib.tests.http_server import HttpServer
 
470
        # connect to '.' via http which is not listable
456
471
        server = HttpServer()
457
472
        server.setUp()
458
473
        try:
619
634
    def test_parse_url(self):
620
635
        t = ConnectedTransport('http://simple.example.com/home/source')
621
636
        self.assertEquals(t._host, 'simple.example.com')
622
 
        self.assertEquals(t._port, 80)
 
637
        self.assertEquals(t._port, None)
623
638
        self.assertEquals(t._path, '/home/source/')
624
639
        self.failUnless(t._user is None)
625
640
        self.failUnless(t._password is None)
626
641
 
627
642
        self.assertEquals(t.base, 'http://simple.example.com/home/source/')
628
643
 
 
644
    def test_parse_url_with_at_in_user(self):
 
645
        # Bug 228058
 
646
        t = ConnectedTransport('ftp://user@host.com@www.host.com/')
 
647
        self.assertEquals(t._user, 'user@host.com')
 
648
 
629
649
    def test_parse_quoted_url(self):
630
650
        t = ConnectedTransport('http://ro%62ey:h%40t@ex%41mple.com:2222/path')
631
651
        self.assertEquals(t._host, 'exAmple.com')
716
736
        self.assertIsNot(t1, t2)
717
737
 
718
738
 
719
 
class TestRemoteTCPTransport(TestCase):
720
 
    """Tests for bzr:// transport (RemoteTCPTransport)."""
721
 
 
722
 
    def test_relpath_with_implicit_port(self):
723
 
        """Connected transports with the same URL are the same, even if the
724
 
        port is implicit.
725
 
 
726
 
        So t.relpath(url) should always be '' if t.base is the same as url, or
727
 
        if the only difference is that one explicitly specifies the default
728
 
        port and the other doesn't specify a port.
729
 
        """
730
 
        t_implicit_port = RemoteTCPTransport('bzr://host.com/')
731
 
        self.assertEquals('', t_implicit_port.relpath('bzr://host.com/'))
732
 
        self.assertEquals('', t_implicit_port.relpath('bzr://host.com:4155/'))
733
 
        t_explicit_port = RemoteTCPTransport('bzr://host.com:4155/')
734
 
        self.assertEquals('', t_explicit_port.relpath('bzr://host.com/'))
735
 
        self.assertEquals('', t_explicit_port.relpath('bzr://host.com:4155/'))
736
 
 
737
 
    def test_construct_uses_default_port(self):
738
 
        """If no port is specified, then RemoteTCPTransport uses
739
 
        BZR_DEFAULT_PORT.
740
 
        """
741
 
        t = get_transport('bzr://host.com/')
742
 
        self.assertEquals(BZR_DEFAULT_PORT, t._port)
743
 
 
744
 
    def test_url_omits_default_port(self):
745
 
        """If a RemoteTCPTransport uses the default port, then its base URL
746
 
        will omit the port.
747
 
 
748
 
        This is like how ":80" is omitted from "http://example.com/".
749
 
        """
750
 
        t = get_transport('bzr://host.com:4155/')
751
 
        self.assertEquals('bzr://host.com/', t.base)
752
 
 
753
 
    def test_url_includes_non_default_port(self):
754
 
        """Non-default ports are included in the transport's URL.
755
 
 
756
 
        Contrast this to `test_url_omits_default_port`.
757
 
        """
758
 
        t = get_transport('bzr://host.com:666/')
759
 
        self.assertEquals('bzr://host.com:666/', t.base)
760
 
 
761
 
 
762
 
class SSHPortTestMixin(object):
763
 
    """Mixin class for testing SSH-based transports' use of ports in URLs.
764
 
    
765
 
    Unlike other connected transports, SSH-based transports (sftp, bzr+ssh)
766
 
    don't have a default port, because the user may have OpenSSH configured to
767
 
    use a non-standard port.
768
 
    """
769
 
 
770
 
    def make_url(self, netloc):
771
 
        """Make a url for the given netloc, using the scheme defined on the
772
 
        TestCase.
773
 
        """
774
 
        return '%s://%s/' % (self.scheme, netloc)
775
 
 
776
 
    def test_relpath_with_implicit_port(self):
777
 
        """SSH-based transports with the same URL are the same.
778
 
        
779
 
        Note than an unspecified port number is different to port 22 (because
780
 
        OpenSSH may be configured to use a non-standard port).
781
 
 
782
 
        So t.relpath(url) should always be '' if t.base is the same as url, but
783
 
        raise PathNotChild if the ports in t and url are not both specified (or
784
 
        both unspecified).
785
 
        """
786
 
        url_implicit_port = self.make_url('host.com')
787
 
        url_explicit_port = self.make_url('host.com:22')
788
 
 
789
 
        t_implicit_port = get_transport(url_implicit_port)
790
 
        self.assertEquals('', t_implicit_port.relpath(url_implicit_port))
791
 
        self.assertRaises(
792
 
            PathNotChild, t_implicit_port.relpath, url_explicit_port)
793
 
        
794
 
        t_explicit_port = get_transport(url_explicit_port)
795
 
        self.assertRaises(
796
 
            PathNotChild, t_explicit_port.relpath, url_implicit_port)
797
 
        self.assertEquals('', t_explicit_port.relpath(url_explicit_port))
798
 
 
799
 
    def test_construct_with_no_port(self):
800
 
        """If no port is specified, then the SSH-based transport's _port will
801
 
        be None.
802
 
        """
803
 
        t = get_transport(self.make_url('host.com'))
804
 
        self.assertEquals(None, t._port)
805
 
 
806
 
    def test_url_with_no_port(self):
807
 
        """If no port was specified, none is shown in the base URL."""
808
 
        t = get_transport(self.make_url('host.com'))
809
 
        self.assertEquals(self.make_url('host.com'), t.base)
810
 
 
811
 
    def test_url_includes_port(self):
812
 
        """An SSH-based transport's base will show the port if one was
813
 
        specified, even if that port is 22, because we do not assume 22 is the
814
 
        default port.
815
 
        """
816
 
        # 22 is the "standard" port for SFTP.
817
 
        t = get_transport(self.make_url('host.com:22'))
818
 
        self.assertEquals(self.make_url('host.com:22'), t.base)
819
 
        # 666 is not a standard port.
820
 
        t = get_transport(self.make_url('host.com:666'))
821
 
        self.assertEquals(self.make_url('host.com:666'), t.base)
822
 
 
823
 
 
824
 
class SFTPTransportPortTest(TestCase, SSHPortTestMixin):
825
 
    """Tests for sftp:// transport (SFTPTransport)."""
826
 
 
827
 
    scheme = 'sftp'
828
 
 
829
 
 
830
 
class BzrSSHTransportPortTest(TestCase, SSHPortTestMixin):
831
 
    """Tests for bzr+ssh:// transport (RemoteSSHTransport)."""
832
 
 
833
 
    scheme = 'bzr+ssh'
834
 
 
835
 
 
836
739
class TestTransportTrace(TestCase):
837
740
 
838
741
    def test_get(self):