def test_abspath(self): # The abspath is always relative to the chroot_url. server = ChrootServer(get_transport('memory:///foo/bar/')) server.setUp() transport = get_transport(server.get_url()) self.assertEqual(server.get_url(), transport.abspath('/')) subdir_transport = transport.clone('subdir') self.assertEqual(server.get_url(), subdir_transport.abspath('/')) server.tearDown()
def test_clone(self): server = ChrootServer(get_transport('memory:///foo/bar/')) server.setUp() transport = get_transport(server.get_url()) # relpath from root and root path are the same relpath_cloned = transport.clone('foo') abspath_cloned = transport.clone('/foo') self.assertEqual(server, relpath_cloned.server) self.assertEqual(server, abspath_cloned.server) server.tearDown()
class SmartTCPServer_for_testing(SmartTCPServer): """Server suitable for use by transport tests. This server is backed by the process's cwd. """ def __init__(self, thread_name_suffix=''): SmartTCPServer.__init__(self, None) self.client_path_extra = None self.thread_name_suffix = thread_name_suffix def get_backing_transport(self, backing_transport_server): """Get a backing transport from a server we are decorating.""" return transport.get_transport(backing_transport_server.get_url()) def setUp(self, backing_transport_server=None, client_path_extra='/extra/'): """Set up server for testing. :param backing_transport_server: backing server to use. If not specified, a LocalURLServer at the current working directory will be used. :param client_path_extra: a path segment starting with '/' to append to the root URL for this server. For instance, a value of '/foo/bar/' will mean the root of the backing transport will be published at a URL like `bzr://127.0.0.1:nnnn/foo/bar/`, rather than `bzr://127.0.0.1:nnnn/`. Default value is `extra`, so that tests by default will fail unless they do the necessary path translation. """ if not client_path_extra.startswith('/'): raise ValueError(client_path_extra) from bzrlib.transport.chroot import ChrootServer if backing_transport_server is None: from bzrlib.transport.local import LocalURLServer backing_transport_server = LocalURLServer() self.chroot_server = ChrootServer( self.get_backing_transport(backing_transport_server)) self.chroot_server.setUp() self.backing_transport = transport.get_transport( self.chroot_server.get_url()) self.root_client_path = self.client_path_extra = client_path_extra self.start_background_thread(self.thread_name_suffix) def tearDown(self): self.stop_background_thread() self.chroot_server.tearDown() def get_url(self): url = super(SmartTCPServer_for_testing, self).get_url() return url[:-1] + self.client_path_extra def get_bogus_url(self): """Return a URL which will fail to connect""" return 'bzr://127.0.0.1:1/'
def test_urljoin_preserves_chroot(self): """Using urlutils.join(url, '..') on a chroot URL should not produce a URL that escapes the intended chroot. This is so that it is not possible to escape a chroot by doing:: url = chroot_transport.base parent_url = urlutils.join(url, '..') new_transport = get_transport(parent_url) """ server = ChrootServer(get_transport('memory:///path/')) server.setUp() transport = get_transport(server.get_url()) self.assertRaises(InvalidURLJoin, urlutils.join, transport.base, '..') server.tearDown()
def test_urljoin_preserves_chroot(self): """Using urlutils.join(url, '..') on a chroot URL should not produce a URL that escapes the intended chroot. This is so that it is not possible to escape a chroot by doing:: url = chroot_transport.base parent_url = urlutils.join(url, '..') new_transport = get_transport(parent_url) """ server = ChrootServer(get_transport('memory:///path/')) server.setUp() transport = get_transport(server.get_url()) self.assertRaises( InvalidURLJoin, urlutils.join, transport.base, '..') server.tearDown()
def test_chroot_url_preserves_chroot(self): """Calling get_transport on a chroot transport's base should produce a transport with exactly the same behaviour as the original chroot transport. This is so that it is not possible to escape a chroot by doing:: url = chroot_transport.base parent_url = urlutils.join(url, '..') new_transport = get_transport(parent_url) """ server = ChrootServer(get_transport('memory:///path/subpath')) server.setUp() transport = get_transport(server.get_url()) new_transport = get_transport(transport.base) self.assertEqual(transport.server, new_transport.server) self.assertEqual(transport.base, new_transport.base) server.tearDown()
def test_get_url(self): backing_transport = MemoryTransport() server = ChrootServer(backing_transport) server.setUp() self.assertEqual('chroot-%d:///' % id(server), server.get_url()) server.tearDown()
def test_tearDown(self): backing_transport = MemoryTransport() server = ChrootServer(backing_transport) server.setUp() server.tearDown() self.assertFalse(server.scheme in _get_protocol_handlers().keys())