def start_server(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) self.root_client_path = self.client_path_extra = client_path_extra from breezy.transport.chroot import ChrootServer if backing_transport_server is None: backing_transport_server = LocalURLServer() self.chroot_server = ChrootServer( self.get_backing_transport(backing_transport_server)) self.chroot_server.start_server() self.backing_transport = transport.get_transport_from_url( self.chroot_server.get_url()) super(SmartTCPServer_for_testing, self).start_server()
def test_format_initialize_find_open(self): # loopback test to check the current format initializes to itself. if not self.branch_format.is_supported(): # unsupported formats are not loopback testable # because the default open will not open them and # they may not be initializable. return # supported formats must be able to init and open t = self.get_transport() readonly_t = transport.get_transport_from_url(self.get_readonly_url()) made_branch = self.make_branch('.') self.assertIsInstance(made_branch, _mod_branch.Branch) # find it via bzrdir opening: opened_control = controldir.ControlDir.open(readonly_t.base) direct_opened_branch = opened_control.open_branch() self.assertEqual(direct_opened_branch.__class__, made_branch.__class__) self.assertEqual(opened_control, direct_opened_branch.controldir) self.assertIsInstance(direct_opened_branch._format, self.branch_format.__class__) # find it via Branch.open opened_branch = _mod_branch.Branch.open(readonly_t.base) self.assertIsInstance(opened_branch, made_branch.__class__) self.assertEqual(made_branch._format.__class__, opened_branch._format.__class__) # if it has a unique id string, can we probe for it ? try: self.branch_format.get_format_string() except NotImplementedError: return self.assertEqual(self.branch_format, opened_control.find_branch_format())
def start_server(self, backing_server=None): """Setup the Chroot on backing_server.""" if backing_server is not None: self.backing_transport = transport.get_transport_from_url( backing_server.get_url()) else: self.backing_transport = transport.get_transport_from_path('.') super(TestingChrootServer, self).start_server()
def test_abspath_root_sibling_server(self): server = stub_sftp.SFTPSiblingAbsoluteServer() server.start_server() self.addCleanup(server.stop_server) transport = _mod_transport.get_transport_from_url(server.get_url()) self.assertFalse(transport.abspath('/').endswith('/~/')) self.assertTrue(transport.abspath('/').endswith('/')) del transport
def start_server(self, backing_server=None): """Setup the Chroot on backing_server.""" if backing_server is not None: self.backing_transport = transport.get_transport_from_url( backing_server.get_url()) else: self.backing_transport = transport.get_transport_from_path('.') self.backing_transport.clone('added-by-filter').ensure_base() self.filter_func = lambda x: 'added-by-filter/' + x super(TestingPathFilteringServer, self).start_server()
def test_different_format_not_equal(self): """Different format repositories are comparable and not the same. Comparing different format repository objects should give a negative result, rather than trigger an exception (which could happen with a naive __eq__ implementation, e.g. due to missing attributes). """ repo = self.make_repository('repo') other_repo = self.make_repository('other', format='default') if repo._format == other_repo._format: # We're testing the default format! So we have to use a non-default # format for other_repo. transport.get_transport_from_url( self.get_vfs_only_url()).delete_tree('other') other_repo = self.make_repository('other', format='knit') # Make sure the other_repo is not a RemoteRepository. other_bzrdir = controldir.ControlDir.open( self.get_vfs_only_url('other')) other_repo = other_bzrdir.open_repository() self.assertDifferentRepo(repo, other_repo)
def test_bad_connection_ssh(self): """None => auto-detect vendor""" f = open(os.devnull, "wb") self.addCleanup(f.close) self.set_vendor(None, f) t = _mod_transport.get_transport_from_url(self.bogus_url) try: self.assertRaises(errors.ConnectionError, t.get, 'foobar') except NameError as e: if "global name 'SSHException'" in str(e): self.knownFailure('Known NameError bug in paramiko 1.6.1') raise
def test_create_anonymous_lightweight_checkout(self): """A lightweight checkout from a readonly branch should succeed.""" tree_a = self.make_branch_and_tree('a') rev_id = tree_a.commit('put some content in the branch') # open the branch via a readonly transport url = self.get_readonly_url(urlutils.basename(tree_a.branch.base)) t = transport.get_transport_from_url(url) if not tree_a.branch.controldir._format.supports_transport(t): raise tests.TestNotApplicable("format does not support transport") source_branch = _mod_branch.Branch.open(url) # sanity check that the test will be valid self.assertRaises((errors.LockError, errors.TransportNotPossible), source_branch.lock_write) checkout = source_branch.create_checkout('c', lightweight=True) self.assertEqual(rev_id, checkout.last_revision())
def get_transport_for_connection(self, set_config): port = self.get_server().port if set_config: conf = config.AuthenticationConfig() conf._get_config().update( {'sftptest': { 'scheme': 'ssh', 'port': port, 'user': '******' }}) conf._save() t = _mod_transport.get_transport_from_url('sftp://localhost:%d' % port) # force a connection to be performed. t.has('foo') return t
def test_jail_hook(self): request.jail_info.transports = None _pre_open_hook = request._pre_open_hook # Any transport is fine if jail_info.transports is None t = self.get_transport('foo') _pre_open_hook(t) # A transport in jail_info.transports is allowed request.jail_info.transports = [t] _pre_open_hook(t) # A child of a transport in jail_info is allowed _pre_open_hook(t.clone('child')) # A parent is not allowed self.assertRaises(errors.JailBreak, _pre_open_hook, t.clone('..')) # A completely unrelated transport is not allowed self.assertRaises(errors.JailBreak, _pre_open_hook, transport.get_transport_from_url('http://host/'))
async def bzr_backend(request): vcs_manager = request.app.vcs_manager package = request.match_info["package"] branch_name = request.match_info.get("branch") repo = await _bzr_open_repo(vcs_manager, request.app.db, package) if branch_name: try: get_suite_config(request.app.config, branch_name) except KeyError: raise web.HTTPNotFound(text='no such suite: %s' % branch_name) transport = repo.user_transport.clone(branch_name) else: transport = repo.user_transport transport.ensure_base() if await is_worker(request.app.db, request): backing_transport = transport else: backing_transport = get_transport_from_url("readonly+" + transport.base) out_buffer = BytesIO() request_data_bytes = await request.read() protocol_factory, unused_bytes = medium._get_protocol_factory_for_bytes( request_data_bytes) smart_protocol_request = protocol_factory(transport, out_buffer.write, ".", backing_transport) smart_protocol_request.accept_bytes(unused_bytes) if smart_protocol_request.next_read_size() != 0: # The request appears to be incomplete, or perhaps it's just a # newer version we don't understand. Regardless, all we can do # is return an error response in the format of our version of the # protocol. response_data = b"error\x01incomplete request\n" else: response_data = out_buffer.getvalue() response = web.StreamResponse(status=200) response.content_type = "application/octet-stream" await response.prepare(request) await response.write(response_data) await response.write_eof() return response
def test_open_containing(self): self.assertRaises(errors.NotBranchError, _mod_branch.Branch.open_containing, self.get_readonly_url('')) self.assertRaises(errors.NotBranchError, _mod_branch.Branch.open_containing, self.get_readonly_url('g/p/q')) branch = self.make_branch('.') if not branch.controldir._format.supports_transport( transport.get_transport_from_url(self.get_readonly_url('.'))): raise tests.TestNotApplicable("format does not support transport") branch, relpath = _mod_branch.Branch.open_containing( self.get_readonly_url('')) self.assertEqual('', relpath) branch, relpath = _mod_branch.Branch.open_containing( self.get_readonly_url('g/p/q')) self.assertEqual('g/p/q', relpath)
def test_bad_connection_paramiko(self): """Test that a real connection attempt raises the right error""" from breezy.transport import ssh self.set_vendor(ssh.ParamikoVendor()) t = _mod_transport.get_transport_from_url(self.bogus_url) self.assertRaises(errors.ConnectionError, t.get, 'foobar')
def get_backing_transport(self, backing_transport_server): """Get a backing transport from a server we are decorating.""" url = 'readonly+' + backing_transport_server.get_url() return transport.get_transport_from_url(url)
def get_backing_transport(self, backing_transport_server): """Get a backing transport from a server we are decorating.""" return transport.get_transport_from_url( backing_transport_server.get_url())