← 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: Canonical.com Patch Queue Manager
  • Date: 2009-09-18 08:02:43 UTC
  • mfrom: (4634.43.21 bzr-ssh-homedir-take-3)
  • Revision ID: pqm@pqm.ubuntu.com-20090918080243-b04lrnure68z8rzc
(andrew) Implement home directory relative URLs for bzr:// and
        bzr+ssh://. (#109143)

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.pathfilter import PathFilteringServer
51
52
 
52
53
 
53
54
# TODO: Should possibly split transport-specific tests into their own files.
80
81
            register_lazy_transport('bar', 'bzrlib.tests.test_transport',
81
82
                                    'TestTransport.SampleHandler')
82
83
            self.assertEqual([SampleHandler.__module__,
83
 
                              'bzrlib.transport.chroot'],
 
84
                              'bzrlib.transport.chroot',
 
85
                              'bzrlib.transport.pathfilter'],
84
86
                             _get_transport_modules())
85
87
        finally:
86
88
            _set_protocol_handlers(handlers)
446
448
            server.tearDown()
447
449
 
448
450
 
 
451
class PathFilteringDecoratorTransportTest(TestCase):
 
452
    """Pathfilter decoration specific tests."""
 
453
 
 
454
    def test_abspath(self):
 
455
        # The abspath is always relative to the base of the backing transport.
 
456
        server = PathFilteringServer(get_transport('memory:///foo/bar/'),
 
457
            lambda x: x)
 
458
        server.setUp()
 
459
        transport = get_transport(server.get_url())
 
460
        self.assertEqual(server.get_url(), transport.abspath('/'))
 
461
 
 
462
        subdir_transport = transport.clone('subdir')
 
463
        self.assertEqual(server.get_url(), subdir_transport.abspath('/'))
 
464
        server.tearDown()
 
465
 
 
466
    def make_pf_transport(self, filter_func=None):
 
467
        """Make a PathFilteringTransport backed by a MemoryTransport.
 
468
        
 
469
        :param filter_func: by default this will be a no-op function.  Use this
 
470
            parameter to override it."""
 
471
        if filter_func is None:
 
472
            filter_func = lambda x: x
 
473
        server = PathFilteringServer(
 
474
            get_transport('memory:///foo/bar/'), filter_func)
 
475
        server.setUp()
 
476
        self.addCleanup(server.tearDown)
 
477
        return get_transport(server.get_url())
 
478
 
 
479
    def test__filter(self):
 
480
        # _filter (with an identity func as filter_func) always returns
 
481
        # paths relative to the base of the backing transport.
 
482
        transport = self.make_pf_transport()
 
483
        self.assertEqual('foo', transport._filter('foo'))
 
484
        self.assertEqual('foo/bar', transport._filter('foo/bar'))
 
485
        self.assertEqual('', transport._filter('..'))
 
486
        self.assertEqual('', transport._filter('/'))
 
487
        # The base of the pathfiltering transport is taken into account too.
 
488
        transport = transport.clone('subdir1/subdir2')
 
489
        self.assertEqual('subdir1/subdir2/foo', transport._filter('foo'))
 
490
        self.assertEqual(
 
491
            'subdir1/subdir2/foo/bar', transport._filter('foo/bar'))
 
492
        self.assertEqual('subdir1', transport._filter('..'))
 
493
        self.assertEqual('', transport._filter('/'))
 
494
 
 
495
    def test_filter_invocation(self):
 
496
        filter_log = []
 
497
        def filter(path):
 
498
            filter_log.append(path)
 
499
            return path
 
500
        transport = self.make_pf_transport(filter)
 
501
        transport.has('abc')
 
502
        self.assertEqual(['abc'], filter_log)
 
503
        del filter_log[:]
 
504
        transport.clone('abc').has('xyz')
 
505
        self.assertEqual(['abc/xyz'], filter_log)
 
506
        del filter_log[:]
 
507
        transport.has('/abc')
 
508
        self.assertEqual(['abc'], filter_log)
 
509
 
 
510
    def test_clone(self):
 
511
        transport = self.make_pf_transport()
 
512
        # relpath from root and root path are the same
 
513
        relpath_cloned = transport.clone('foo')
 
514
        abspath_cloned = transport.clone('/foo')
 
515
        self.assertEqual(transport.server, relpath_cloned.server)
 
516
        self.assertEqual(transport.server, abspath_cloned.server)
 
517
 
 
518
    def test_url_preserves_pathfiltering(self):
 
519
        """Calling get_transport on a pathfiltered transport's base should
 
520
        produce a transport with exactly the same behaviour as the original
 
521
        pathfiltered transport.
 
522
 
 
523
        This is so that it is not possible to escape (accidentally or
 
524
        otherwise) the filtering by doing::
 
525
            url = filtered_transport.base
 
526
            parent_url = urlutils.join(url, '..')
 
527
            new_transport = get_transport(parent_url)
 
528
        """
 
529
        transport = self.make_pf_transport()
 
530
        new_transport = get_transport(transport.base)
 
531
        self.assertEqual(transport.server, new_transport.server)
 
532
        self.assertEqual(transport.base, new_transport.base)
 
533
 
 
534
 
449
535
class ReadonlyDecoratorTransportTest(TestCase):
450
536
    """Readonly decoration specific tests."""
451
537