def test_only_wraps_once(self):
# get_readonly_transport just returns the given transport if its
# already readonly.
transport = MemoryTransport()
readonly_transport = get_readonly_transport(transport)
double_readonly = get_readonly_transport(readonly_transport)
self.assertIs(readonly_transport, double_readonly)
def test_escaped_uppercase(self):
"""Uppercase letters are escaped for safety on Windows"""
my_store = store.TransportStore(MemoryTransport(),
prefixed=True,
escaped=True)
# a particularly perverse file-id! :-)
self.assertEquals(my_store._relpath('C:<>'), 'be/%2543%253a%253c%253e')
def test___iter__no_suffix(self):
my_store = TextStore(MemoryTransport(),
prefixed=False,
compressed=False)
stream = StringIO("content")
my_store.add(stream, "foo")
self.assertEqual(set(['foo']), set(my_store.__iter__()))
def test_iter_files_recursive(self):
transport = MemoryTransport()
transport.mkdir('dir')
transport.put_bytes('dir/foo', 'content')
transport.put_bytes('dir/bar', 'content')
transport.put_bytes('bar', 'content')
paths = set(transport.iter_files_recursive())
self.assertEqual(set(['dir/foo', 'dir/bar', 'bar']), paths)
def test_list_dir(self):
transport = MemoryTransport()
transport.put_bytes('foo', 'content')
transport.mkdir('dir')
transport.put_bytes('dir/subfoo', 'content')
transport.put_bytes('dirlike', 'content')
self.assertEquals(['dir', 'dirlike', 'foo'],
sorted(transport.list_dir('.')))
self.assertEquals(['subfoo'], sorted(transport.list_dir('dir')))
def setUp(self):
frontend = InMemoryFrontend()
self.factory = frontend.getLaunchpadObjectFactory()
codehosting_api = frontend.getCodehostingEndpoint()
self.requester = self.factory.makePerson()
self.backing_transport = MemoryTransport()
self.server = self.getServer(codehosting_api, self.requester.id,
self.backing_transport)
self.server.start_server()
self.addCleanup(self.server.stop_server)
def test_copy_suffixes(self):
from_store = self.get_populated_store()
to_store = TextStore(MemoryTransport(), prefixed=True, compressed=True)
to_store.register_suffix('sig')
to_store.copy_all_ids(from_store)
self.assertEqual(1, len(to_store))
self.assertEqual(set(['foo']), set(to_store.__iter__()))
self.assertEqual('content', to_store.get('foo').read())
self.assertEqual('signature', to_store.get('foo', 'sig').read())
self.assertRaises(KeyError, to_store.get, 'missing', 'sig')
def test___iter__escaped(self):
self.vfstore = VersionedFileStore(MemoryTransport(),
prefixed=True, escaped=True, versionedfile_class=WeaveFile)
self.vfstore.get_scope = self.get_scope
self._transaction = transactions.WriteTransaction()
vf = self.vfstore.get_weave_or_empty(' ', self._transaction)
vf.add_lines('a', [], [])
del vf
self._transaction.finish()
self.assertEqual([' '], list(self.vfstore))
def setUp(self):
super(TestFilesystem, self).setUp()
self.disable_directory_isolation()
frontend = InMemoryFrontend()
self.factory = frontend.getLaunchpadObjectFactory()
endpoint = XMLRPCWrapper(frontend.getCodehostingEndpoint())
self.requester = self.factory.makePerson()
self._server = LaunchpadServer(
endpoint, self.requester.id, MemoryTransport())
self._server.start_server()
self.addCleanup(self._server.stop_server)
def setUp(self):
super(TestBranchChangedNotification, self).setUp()
self._server = None
self._branch_changed_log = []
frontend = InMemoryFrontend()
self.factory = frontend.getLaunchpadObjectFactory()
self.codehosting_api = frontend.getCodehostingEndpoint()
self.codehosting_api.branchChanged = self._replacement_branchChanged
self.requester = self.factory.makePerson()
self.backing_transport = MemoryTransport()
self.disable_directory_isolation()
def get_populated_store(self, prefixed=False,
store_class=TextStore, compressed=False):
my_store = store_class(MemoryTransport(), prefixed,
compressed=compressed)
my_store.register_suffix('sig')
stream = StringIO("signature")
my_store.add(stream, "foo", 'sig')
stream = StringIO("content")
my_store.add(stream, "foo")
stream = StringIO("signature for missing base")
my_store.add(stream, "missing", 'sig')
return my_store
def test_openDirectoryMemory(self):
"""openDirectory works on MemoryTransport."""
transport = MemoryTransport()
transport.put_bytes('hello', 'hello')
sftp_server = TransportSFTPServer(AsyncTransport(transport))
deferred = sftp_server.openDirectory('.')
def check_directory(directory):
with closing(directory):
names = [entry[0] for entry in directory]
self.assertEqual(['hello'], names)
return deferred.addCallback(check_directory)
def setUp(self):
super(TestBranchChangedErrorHandling, self).setUp()
self._server = None
frontend = InMemoryFrontend()
self.factory = frontend.getLaunchpadObjectFactory()
self.codehosting_api = frontend.getCodehostingEndpoint()
self.codehosting_api.branchChanged = self._replacement_branchChanged
self.requester = self.factory.makePerson()
self.backing_transport = MemoryTransport()
self.disable_directory_isolation()
# Trap stderr.
self.addCleanup(setattr, sys, 'stderr', sys.stderr)
self._real_stderr = sys.stderr
sys.stderr = codecs.getwriter('utf8')(StringIO())
# To record generated oopsids
self.generated_oopsids = []
def test__format_directory_entries_with_MemoryStat(self):
"""format_directory_entries works with MemoryStat.
MemoryStat lacks many fields, but format_directory_entries works
around that.
"""
t = MemoryTransport()
stat_result = t.stat('.')
entries = self.sftp_server._format_directory_entries(
[stat_result], ['filename'])
self.assertEqual(list(entries), [
('filename', 'drwxr-xr-x 0 0 0 0 '
'Jan 01 1970 filename',
{'atime': 0,
'gid': 0,
'mtime': 0,
'permissions': 16877,
'size': 0,
'uid': 0})])
self.assertIs(None, getattr(stat_result, 'st_mtime', None))
def _populate_from_branch(self):
"""Populate the in-tree state from the branch."""
self._set_basis()
if self._branch_revision_id == _mod_revision.NULL_REVISION:
self._parent_ids = []
else:
self._parent_ids = [self._branch_revision_id]
self._inventory = Inventory(None, self._basis_tree.get_revision_id())
self._file_transport = MemoryTransport()
# TODO copy the revision trees content, or do it lazy, or something.
inventory_entries = self._basis_tree.iter_entries_by_dir()
for path, entry in inventory_entries:
self._inventory.add(entry.copy())
if path == '':
continue
if entry.kind == 'directory':
self._file_transport.mkdir(path)
elif entry.kind == 'file':
self._file_transport.put_file(
path, self._basis_tree.get_file(entry.file_id))
else:
raise NotImplementedError(self._populate_from_branch)
def test_parameters(self):
transport = MemoryTransport()
self.assertEqual(True, transport.listable())
self.assertEqual(False, transport.is_readonly())
def test_put_without_dir_fails(self):
transport = MemoryTransport()
self.assertRaises(NoSuchFile, transport.put_file, 'dir/path',
StringIO('content'))
def setUp(self):
super(TestDirectDatabaseLaunchpadServer, self).setUp()
self.requester = self.factory.makePerson()
self.server = DirectDatabaseLaunchpadServer('lp-test://',
MemoryTransport())
def test_get_missing(self):
transport = MemoryTransport()
self.assertRaises(NoSuchFile, transport.get, 'foo')
def getLaunchpadServer(self, codehosting_api, user_id):
return LaunchpadServer(XMLRPCWrapper(codehosting_api), user_id,
MemoryTransport())
def getLaunchpadServer(self, codehosting_api, user_id):
return LaunchpadInternalServer('lp-test:///',
XMLRPCWrapper(codehosting_api),
MemoryTransport())
def test_has_present(self):
transport = MemoryTransport()
transport.append_bytes('foo', 'content')
self.assertEquals(True, transport.has('foo'))
def test_has_missing(self):
transport = MemoryTransport()
self.assertEquals(False, transport.has('foo'))
def test_tearDown(self):
backing_transport = MemoryTransport()
server = ChrootServer(backing_transport)
server.setUp()
server.tearDown()
self.assertFalse(server.scheme in _get_protocol_handlers().keys())
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_construct(self):
backing_transport = MemoryTransport()
server = ChrootServer(backing_transport)
self.assertEqual(backing_transport, server.backing_transport)
def test_stat(self):
transport = MemoryTransport()
transport.put_bytes('foo', 'content')
transport.put_bytes('bar', 'phowar')
self.assertEqual(7, transport.stat('foo').st_size)
self.assertEqual(6, transport.stat('bar').st_size)
def test_mkdir(self):
transport = MemoryTransport()
transport.mkdir('dir')
transport.append_bytes('dir/path', 'content')
self.assertEqual(transport.get('dir/path').read(), 'content')
def test_mkdir_missing_parent(self):
transport = MemoryTransport()
self.assertRaises(NoSuchFile, transport.mkdir, 'dir/dir')
def test_mkdir_twice(self):
transport = MemoryTransport()
transport.mkdir('dir')
self.assertRaises(FileExists, transport.mkdir, 'dir')
