Skip to content

Commit

Permalink
Remove unused dataset deserializer stuff.
Browse files Browse the repository at this point in the history 
An unfinished thread left in the code base. It was a fine idea but I don't think anyone is left to pick it up and run with it.
  • Loading branch information
@jmchilton
jmchilton committed Aug 10, 2018
1 parent f7176dc commit 6067fee
Show file tree
Hide file tree
Showing 2 changed files with 0 additions and 170 deletions.
51 changes: 0 additions & 51 deletions lib/galaxy/managers/datasets.py
View file
Expand Up @@ -222,57 +222,6 @@ def serialize_permissions(self, dataset, key, user=None, **context):
return permissions


class DatasetDeserializer(base.ModelDeserializer, deletable.PurgableDeserializerMixin):
model_manager_class = DatasetManager

def __init__(self, app):
super(DatasetDeserializer, self).__init__(app)
# TODO: this manager may make more sense inside rbac_secured
self.role_manager = roles.RoleManager(app)

def add_deserializers(self):
super(DatasetDeserializer, self).add_deserializers()
# not much to set here besides permissions and purged/deleted
deletable.PurgableDeserializerMixin.add_deserializers(self)

self.deserializers.update({
'permissions' : self.deserialize_permissions,
})

def deserialize_permissions(self, dataset, key, permissions, user=None, **context):
"""
Create permissions for each list of encoded role ids in the (validated)
`permissions` dictionary, where `permissions` is in the form::
{ 'manage': [ <role id 1>, ... ], 'access': [ <role id 2>, ... ] }
"""
self.manager.permissions.manage.error_unless_permitted(dataset, user)
self._validate_permissions(permissions, **context)
manage = self._list_of_roles_from_ids(permissions['manage'])
access = self._list_of_roles_from_ids(permissions['access'])
self.manager.permissions.set(dataset, manage, access, flush=False)
return permissions

def _validate_permissions(self, permissions, **context):
self.validate.type('permissions', permissions, dict)
for permission_key in ('manage', 'access'):
if(not isinstance(permissions.get(permission_key, None), list)):
msg = 'permissions requires "{0}" as a list of role ids'.format(permission_key)
raise exceptions.RequestParameterInvalidException(msg)

# TODO: push down into permissions?
manage_permissions = permissions['manage']
if len(manage_permissions) < 1:
raise exceptions.RequestParameterInvalidException('At least one managing role is required')

return permissions

def _list_of_roles_from_ids(self, id_list):
# TODO: this may make more sense inside rbac_secured
# note: no checking of valid roles is made
return self.role_manager.by_ids([self.app.security.decode_id(id_) for id_ in id_list])


# ============================================================================= AKA DatasetInstanceManager
class DatasetAssociationManager(base.ModelManager,
secured.AccessibleManagerMixin,
Expand Down
119 changes: 0 additions & 119 deletions test/unit/managers/test_DatasetManager.py
View file
Expand Up @@ -10,10 +10,8 @@
exceptions,
model
)
from galaxy.managers import rbac_secured
from galaxy.managers.base import SkipAttribute
from galaxy.managers.datasets import (
DatasetDeserializer,
DatasetManager,
DatasetSerializer
)
Expand Down Expand Up @@ -317,123 +315,6 @@ def test_serializers(self):
self.assertIsJsonifyable(serialized)


# =============================================================================
class DatasetDeserializerTestCase(BaseTestCase):

def set_up_managers(self):
super(DatasetDeserializerTestCase, self).set_up_managers()
self.dataset_manager = DatasetManager(self.app)
self.dataset_serializer = DatasetSerializer(self.app)
self.dataset_deserializer = DatasetDeserializer(self.app)
self.role_manager = RoleManager(self.app)

def test_deserialize_delete(self):
dataset = self.dataset_manager.create()

self.log('should raise when deserializing deleted from non-bool')
self.assertFalse(dataset.deleted)
self.assertRaises(exceptions.RequestParameterInvalidException,
self.dataset_deserializer.deserialize, dataset, data={'deleted': None})
self.assertFalse(dataset.deleted)
self.log('should be able to deserialize deleted from True')
self.dataset_deserializer.deserialize(dataset, data={'deleted': True})
self.assertTrue(dataset.deleted)
self.log('should be able to reverse by deserializing deleted from False')
self.dataset_deserializer.deserialize(dataset, data={'deleted': False})
self.assertFalse(dataset.deleted)

def test_deserialize_purge(self):
dataset = self.dataset_manager.create()

self.log('should raise when deserializing purged from non-bool')
self.assertRaises(exceptions.RequestParameterInvalidException,
self.dataset_deserializer.deserialize, dataset, data={'purged': None})
self.assertFalse(dataset.purged)
self.log('should be able to deserialize purged from True')
self.dataset_deserializer.deserialize(dataset, data={'purged': True})
self.assertTrue(dataset.purged)
# TODO: should this raise an error?
self.log('should NOT be able to deserialize purged from False (will remain True)')
self.dataset_deserializer.deserialize(dataset, data={'purged': False})
self.assertTrue(dataset.purged)

def test_deserialize_permissions(self):
dataset = self.dataset_manager.create()
who_manages = self.user_manager.create(**user2_data)
self.dataset_manager.permissions.manage.grant(dataset, who_manages)
existing_permissions = self.dataset_serializer.serialize_permissions(dataset, 'permissions', user=who_manages)
existing_manage_permissions = existing_permissions['manage']

user3 = self.user_manager.create(**user3_data)

self.log('deserializing permissions from a non-dictionary should error')
not_a_dict = []
self.assertRaises(exceptions.RequestParameterInvalidException, self.dataset_deserializer.deserialize,
dataset, user=who_manages, data={'permissions': not_a_dict})

self.log('deserializing permissions from a malformed dictionary should error')
self.assertRaises(exceptions.RequestParameterInvalidException, self.dataset_deserializer.deserialize,
dataset, user=who_manages, data={'permissions': dict(nope=[], access=[])})

self.log('deserializing permissions with no manage roles should error')
self.assertRaises(exceptions.RequestParameterInvalidException, self.dataset_deserializer.deserialize,
dataset, user=who_manages, data={'permissions': dict(manage=[], access=[])})

self.log('deserializing permissions using a non-managing user should error')
self.assertRaises(rbac_secured.DatasetManagePermissionFailedException, self.dataset_deserializer.deserialize,
dataset, user=user3, data={'permissions': existing_permissions})

self.log('deserializing permissions using an anon user should error')
self.assertRaises(rbac_secured.DatasetManagePermissionFailedException, self.dataset_deserializer.deserialize,
dataset, user=None, data={'permissions': existing_permissions})

self.log('deserializing permissions with a single access should make the dataset private')
private_role = self.user_manager.private_role(who_manages)
private_role = private_role.to_dict(value_mapper={'id': self.app.security.encode_id})
permissions = dict(manage=existing_manage_permissions, access=[private_role['id']])
self.dataset_deserializer.deserialize(dataset, user=who_manages, data={
'permissions': permissions
})
self.assertFalse(self.dataset_manager.is_accessible(dataset, user=user3))

self.log('deserializing permissions manage should make the permissions available')
self.assertRaises(SkipAttribute, self.dataset_serializer.serialize_permissions,
dataset, 'perms', user=user3)
# now, have who_manages give a manage permission to user3
private_role = self.user_manager.private_role(user3)
new_manage_permissions = existing_manage_permissions + [self.app.security.encode_id(private_role.id)]
permissions = dict(manage=new_manage_permissions, access=[])
self.dataset_deserializer.deserialize(dataset, user=who_manages, data={
'permissions': permissions
})

# deserializing for user3 shouldn't throw a skip bc they can manage
permissions = self.dataset_serializer.serialize_permissions(dataset, 'perms', user=who_manages)
self.assertEqual(new_manage_permissions, permissions['manage'])

def test_deserialize_permissions_with_admin(self):
dataset = self.dataset_manager.create()
who_manages = self.user_manager.create(**user2_data)
self.dataset_manager.permissions.manage.grant(dataset, who_manages)
existing_permissions = self.dataset_serializer.serialize_permissions(dataset, 'permissions', user=who_manages)
existing_manage_permissions = existing_permissions['manage']

user3 = self.user_manager.create(**user3_data)
self.assertRaises(rbac_secured.DatasetManagePermissionFailedException, self.dataset_deserializer.deserialize,
dataset, user=user3, data={'permissions': existing_permissions})

self.log('deserializing permissions using an admin user should not error')
private_role = self.user_manager.private_role(who_manages)
private_role = private_role.to_dict(value_mapper={'id' : self.app.security.encode_id})
permissions = dict(manage=existing_manage_permissions, access=[private_role['id']])
self.dataset_deserializer.deserialize(dataset, user=who_manages, data={
'permissions': permissions
})

self.assertRaises(rbac_secured.DatasetManagePermissionFailedException, self.dataset_deserializer.deserialize,
dataset, user=user3, data={'permissions': existing_permissions})


# =============================================================================
# NOTE: that we test the DatasetAssociation* classes in either test_HDAManager or test_LDAManager
# (as part of those subclasses):
Expand Down

0 comments on commit 6067fee

Please sign in to comment.