def test_delete_recursive(self, mock_children, mock_delete):
wrapped_doc = IndexedFile(
**{
'name': 'folder1',
'system': 'test.system',
'path': '/path/to/folder',
'format': 'folder'
})
base = BaseESFile('test_user',
system='test.system',
wrapped_doc=wrapped_doc)
object.__setattr__(base, '_wrapped', wrapped_doc)
object.__setattr__(base, 'format', 'folder')
object.__setattr__(base, 'path', '/path/to/folder')
child_doc = IndexedFile(
**{
'name': 'child1',
'system': 'test.system',
'path': '/path/to/child1',
'format': 'file'
})
base_child = BaseESFile('test_user',
system='test.system',
wrapped_doc=child_doc)
object.__setattr__(base_child, '_wrapped', child_doc)
object.__setattr__(base_child, 'format', 'file')
object.__setattr__(base_child, 'path', '/path/to/child1')
mock_children.return_value = iter([base_child])
base.delete()
# Assert 2 delete calls: 1 for parent, 1 for child
self.assertEqual(mock_delete.call_count, 2)
def test_children_function(self, mock_index):
child_doc1 = IndexedFile(**{
'name': 'child1',
'system': 'test.system',
'path': '/path/to/child1'
})
child_doc2 = IndexedFile(**{
'name': 'child2',
'system': 'test.system',
'path': '/path/to/child2'
})
mock_index.return_value.children.side_effect = [([child_doc1], 'KEY1'),
([child_doc2], 'KEY2'),
([], None)]
wrapped_doc = IndexedFile(**{
'name': 'file1',
'system': 'test.system',
'path': '/path/to/file'
})
base = BaseESFile('test_user',
system='test.system',
wrapped_doc=wrapped_doc)
# Need to set attrs manually because the custom setter/getter in BaseESResource are mocked
object.__setattr__(base, 'username', 'test_user')
object.__setattr__(base, '_reindex', False)
object.__setattr__(base, 'system', 'test.system')
object.__setattr__(base, 'path', '/path/to/file')
child_generator = base.children(limit=1)
for child in child_generator:
continue
mock_index().children.assert_has_calls([
call('test_user', 'test.system', '/path/to/file', limit=1),
call('test_user',
'test.system',
'/path/to/file',
limit=1,
search_after='KEY1'),
call('test_user',
'test.system',
'/path/to/file',
limit=1,
search_after='KEY2'),
])
# Check that iteration ends after all children have been listed.
self.assertRaises(StopIteration, child_generator.__next__)
def setUp(self):
# configure regular user
user = get_user_model().objects.get(pk=2)
user.set_password('user/password')
user.save()
f1 = IndexedFile(
length=1,
path="ds_user/test",
)
f1.save(refresh=True)
f2 = IndexedFile(
length=1,
path="ds_user/test",
)
f2.save(refresh=True)
def test_children_returns_when_hits(self, mock_search, mock_get):
search_res = IndexedFile(**{
'name': 'res1',
'system': 'test.system',
'path': '/path/to/res1'
})
search_res.meta.id = 'MOCK ID'
mock_search().filter().filter().sort().extra(
).execute.return_value.hits.__len__.return_value = 1
mock_search().filter().filter().sort().extra().execute(
).__iter__.return_value = [search_res]
mock_search().filter().filter().sort().extra(
).execute.return_value.hits.hits = [{
'sort': 'MOCK SORTKEY'
}]
mock_get.return_value = search_res
children = IndexedFile.children('test_user',
system='test.system',
path='/')
mock_get.assert_called_with('MOCK ID')
self.assertEqual(children, ([search_res], 'MOCK SORTKEY'))
def test_from_path_multiple_hits(self, mock_search, mock_delete):
"""
When there are multiple files sharing a system and path, ensure we delete
all but one and return the remaining document.
"""
search_res = IndexedFile(**{
'name': 'res1',
'system': 'test.system',
'path': '/path/to/res1'
})
# Need to mock either slicing the result or retrieving a single element.
def mock_getitem(i):
if type(i) is slice:
return [search_res, search_res]
else:
return search_res
# mock a search result with 3 hits and the ability to get/slice.
mock_res = MagicMock()
mock_res.hits.total = 3
mock_res.__getitem__.side_effect = mock_getitem
mock_search().filter().filter().execute.return_value = mock_res
doc_from_path = IndexedFile.from_path('test.system', '/path/to/res1')
mock_search().filter.assert_called_with(
'term', **{'system._exact': 'test.system'})
mock_search().filter().filter.assert_called_with(
'term', **{'path._exact': '/path/to/res1'})
self.assertEqual(mock_delete.call_count, 2)
self.assertEqual(doc_from_path, search_res)
def test_from_path_multiple_hits(self, mock_refresh, mock_get, mock_search,
mock_delete):
"""
When there are multiple files sharing a system and path, ensure we delete
all but one and return the remaining document.
"""
search_res = IndexedFile(**{
'name': 'res1',
'system': 'test.system',
'path': '/path/to/res1'
})
sys_filter = Q('term', **{'system._exact': 'test.system'})
path_filter = Q('term', **{'path._exact': '/path/to/res1'})
# Need to mock either slicing the result or retrieving a single element.
mock_res = MagicMock()
mock_res.hits.total.value = 3
mock_search().filter().execute.return_value = mock_res
mock_get.return_value = search_res
doc_from_path = IndexedFile.from_path('test.system', '/path/to/res1')
self.assertEqual(mock_search().filter().delete.call_count, 1)
self.assertEqual(doc_from_path, search_res)
def test_search(self, mock_search, mock_base):
request = MagicMock()
request.query_string = 'test_query'
request.username = '******'
mock_res = MagicMock()
mock_res.hits.total.value = 1
mock_res.__iter__.return_value = [IndexedFile(name='file01')]
mock_search().query().extra().execute.return_value = mock_res
sm = PrivateDataSearchManager(request)
expected_result = {
'trail': [{
'name': '$SEARCH',
'path': '/$SEARCH'
}],
'name': '$SEARCH',
'path': '/',
'system': 'test.system',
'type': 'dir',
'children': [{
'name': 'file01'
}],
'permissions': 'READ'
}
listing = sm.listing('test.system', '/')
self.assertEqual(listing, expected_result)
def test_attrs(self):
f = IndexedFile()
self.assertTrue(hasattr(f, 'name'))
self.assertTrue(hasattr(f, 'path'))
self.assertTrue(hasattr(f, 'lastModified'))
self.assertTrue(hasattr(f, 'length'))
self.assertTrue(hasattr(f, 'format'))
self.assertTrue(hasattr(f, 'mimeType'))
self.assertTrue(hasattr(f, 'type'))
self.assertTrue(hasattr(f, 'system'))
def test_update(self, mock_update):
wrapped_doc = IndexedFile(
**{
'name': 'folder1',
'system': 'test.system',
'path': '/path/to/folder',
'format': 'folder'
})
base = BaseESResource(wrapped_doc=wrapped_doc)
base.update(**{'name': 'folder2'})
mock_update.assert_called_with(**{'name': 'folder2'})
def test_init(self, mock_wrap):
wrapped_doc = IndexedFile(
**{
'name': 'folder1',
'system': 'test.system',
'path': '/path/to/folder',
'format': 'folder'
})
BaseESResource(wrapped_doc=wrapped_doc)
mock_wrap.assert_called_with(wrapped_doc)
def test_class_init_with_wrap(self):
wd = IndexedFile(**{
'name': 'file1',
'system': 'test.system',
'path': '/path/to/file'
})
base = BaseESFile('test_user', wrapped_doc=wd)
self.mock_base_init.assert_called_with(wd)
self.mock_base_setattr.assert_has_calls(
[call('username', 'test_user'),
call('_reindex', False)])
def test_to_dict(self, mock_to_dict):
wrapped_doc = IndexedFile(
**{
'name': 'folder1',
'system': 'test.system',
'path': '/path/to/folder',
'format': 'folder'
})
base = BaseESResource(wrapped_doc=wrapped_doc)
base.to_dict()
mock_to_dict.assert_called_with()
def test_wrap(self, mock_update):
wrapped_doc = IndexedFile(
**{
'name': 'folder1',
'system': 'test.system',
'path': '/path/to/folder',
'format': 'folder'
})
base = BaseESResource(wrapped_doc=wrapped_doc)
self.assertEqual(base._wrapped, wrapped_doc)
base_with_kwargs = BaseESResource(wrapped_doc=wrapped_doc,
**{'name': 'folder2'})
mock_update.assert_called_with(**{'name': 'folder2'})
def test_delete_no_dir(self, mock_delete):
wrapped_doc = IndexedFile(
**{
'name': 'file1',
'system': 'test.system',
'path': '/path/to/file',
'format': 'file'
})
base = BaseESFile('test_user',
system='test.system',
wrapped_doc=wrapped_doc)
object.__setattr__(base, '_wrapped', wrapped_doc)
base.delete()
mock_delete.assert_called_with()
def test_getter_and_setter(self):
wrapped_doc = IndexedFile(
**{
'name': 'folder1',
'system': 'test.system',
'path': '/path/to/folder',
'format': 'folder'
})
base = BaseESResource(wrapped_doc=wrapped_doc)
base.name = 'folder2'
self.assertEqual(base.name, 'folder2')
self.assertEqual(base._wrapped.name, 'folder2')
base.newAttr = 'this attr is not in the wrapped doc'
self.assertEqual(base.newAttr, 'this attr is not in the wrapped doc')
self.assertFalse(hasattr(base._wrapped, 'newAttr'))
def test_save(self, mock_save):
wrapped_doc = IndexedFile(**{
'name': 'file1',
'system': 'test.system',
'path': '/path/to/file'
})
base = BaseESFile('test_user',
system='test.system',
wrapped_doc=wrapped_doc)
# Need to set attrs manually because the custom setter/getter in BaseESResource are mocked
object.__setattr__(base, 'path', '/path/to/file')
object.__setattr__(base, '_wrapped', wrapped_doc)
base.save()
# self.mock_base_update.assert_called_with(**{'basePath': '/path/to'})
mock_save.assert_called_with()
def index(self, file_object, pems):
"""Indexes an Agave response file object (json) to an IndexedFile"""
res, search = self.get(file_object.system,
os.path.dirname(file_object.path.strip('/')),
os.path.basename(file_object.path.strip('/')))
if res.hits.total > 1:
for doc in res[1:]:
doc.delete(ignore=404)
if res.hits.total >= 1:
document = res[0]
file_object.pop('_links')
file_object.pop('permissions')
document.update(**file_object)
else:
document = IndexedFile(
name=os.path.basename(file_object.path.strip('/')),
path=os.path.dirname(file_object.path.strip('/')) or '/',
lastModified=file_object.lastModified.isoformat(),
length=file_object.length,
format=file_object.format,
mimeType=FileManager.mimetype_lookup(file_object,
settings.DEBUG),
type=file_object.type,
system=file_object.system,
)
if pems is None or not pems:
document.permissions = [{
'username': self.username,
'permission': {
'read': True,
'write': True,
'execute': True
}
}]
document.save()
if pems:
for pem in pems:
pem.pop('_links', None)
pem.pop('internalUsername', None)
document.update(permissions=pems)
return document
def test_from_path_1_hit(self, mock_search):
search_res = IndexedFile(**{
'name': 'res1',
'system': 'test.system',
'path': '/path/to/res1'
})
mock_res = MagicMock()
mock_res.hits.total = 1
mock_res.__getitem__.return_value = search_res
mock_search().filter().filter().execute.return_value = mock_res
doc_from_path = IndexedFile.from_path('test.system', '/path/to/res1')
mock_search().filter.assert_called_with(
'term', **{'system._exact': 'test.system'})
mock_search().filter().filter.assert_called_with(
'term', **{'path._exact': '/path/to/res1'})
self.assertEqual(doc_from_path, search_res)
def test_save(self, mock_save):
f = IndexedFile()
f.save()
mock_save.assert_called_with()
