class DatasetDeserializerTestCase(BaseTestCase):
def set_up_managers(self):
super(DatasetDeserializerTestCase, self).set_up_managers()
self.dataset_manager = DatasetManager(self.app)
self.dataset_deserializer = DatasetDeserializer(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)
class HDATestCase(BaseTestCase):
def set_up_managers(self):
super(HDATestCase, self).set_up_managers()
self.hda_manager = hdas.HDAManager(self.app)
self.history_manager = HistoryManager(self.app)
self.dataset_manager = DatasetManager(self.app)
def _create_vanilla_hda(self, user_data=None):
user_data = user_data or user2_data
owner = self.user_manager.create(**user_data)
history1 = self.history_manager.create(name="history1", user=owner)
dataset1 = self.dataset_manager.create()
return self.hda_manager.create(history=history1, dataset=dataset1)
class HDATestCase(BaseTestCase):
def set_up_managers(self):
super(HDATestCase, self).set_up_managers()
self.hda_manager = hdas.HDAManager(self.app)
self.history_manager = HistoryManager(self.app)
self.dataset_manager = DatasetManager(self.app)
def _create_vanilla_hda(self, user_data=None):
user_data = user_data or user2_data
owner = self.user_manager.create(**user_data)
history1 = self.history_manager.create(name='history1', user=owner)
dataset1 = self.dataset_manager.create()
return self.hda_manager.create(history=history1, dataset=dataset1)
class DatasetDeserializerTestCase( BaseTestCase ):
def set_up_managers( self ):
super( DatasetDeserializerTestCase, self ).set_up_managers()
self.dataset_manager = DatasetManager( self.app )
self.dataset_deserializer = DatasetDeserializer( 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 )
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 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'])
class DatasetSerializerTestCase(BaseTestCase):
def set_up_managers(self):
super(DatasetSerializerTestCase, self).set_up_managers()
self.dataset_manager = DatasetManager(self.app)
self.dataset_serializer = DatasetSerializer(self.app)
self.role_manager = RoleManager(self.app)
def test_views(self):
dataset = self.dataset_manager.create()
self.log('should have a summary view')
summary_view = self.dataset_serializer.serialize_to_view(
dataset, view='summary')
self.assertKeys(summary_view, self.dataset_serializer.views['summary'])
self.log('should have the summary view as default view')
self.dataset_serializer.serialize_to_view(dataset,
default_view='summary')
self.assertKeys(summary_view, self.dataset_serializer.views['summary'])
self.log('should have a serializer for all serializable keys')
for key in self.dataset_serializer.serializable_keyset:
instantiated_attribute = getattr(dataset, key, None)
if not ((key in self.dataset_serializer.serializers) or
(isinstance(instantiated_attribute,
self.TYPES_NEEDING_NO_SERIALIZERS))):
self.fail('no serializer for: %s (%s)' %
(key, instantiated_attribute))
else:
self.assertTrue(True, 'all serializable keys have a serializer')
def test_views_and_keys(self):
dataset = self.dataset_manager.create()
self.log('should be able to use keys with views')
serialized = self.dataset_serializer.serialize_to_view(
dataset,
# file_name is exposed using app.config.expose_dataset_path = True
view='summary',
keys=['file_name'])
self.assertKeys(
serialized,
self.dataset_serializer.views['summary'] + ['file_name'])
self.log('should be able to use keys on their own')
serialized = self.dataset_serializer.serialize_to_view(
dataset, keys=['purgable', 'file_size'])
self.assertKeys(serialized, ['purgable', 'file_size'])
def test_serialize_permissions(self):
dataset = self.dataset_manager.create()
who_manages = self.user_manager.create(**user2_data)
self.dataset_manager.permissions.manage.grant(dataset, who_manages)
self.log(
'serialized permissions should be returned for the user who can manage and be well formed'
)
permissions = self.dataset_serializer.serialize_permissions(
dataset, 'perms', user=who_manages)
self.assertIsInstance(permissions, dict)
self.assertKeys(permissions, ['manage', 'access'])
self.assertIsInstance(permissions['manage'], list)
self.assertIsInstance(permissions['access'], list)
manage_perms = permissions['manage']
self.assertTrue(len(manage_perms) == 1)
role_id = manage_perms[0]
self.assertEncodedId(role_id)
role_id = self.app.security.decode_id(role_id)
role = self.role_manager.get(self.trans, role_id)
self.assertTrue(
who_manages in [user_role.user for user_role in role.users])
# wat
self.log('permissions should be not returned for non-managing users')
not_my_supervisor = self.user_manager.create(**user3_data)
self.assertRaises(SkipAttribute,
self.dataset_serializer.serialize_permissions,
dataset,
'perms',
user=not_my_supervisor)
self.log('permissions should not be returned for anon users')
self.assertRaises(SkipAttribute,
self.dataset_serializer.serialize_permissions,
dataset,
'perms',
user=None)
def test_serializers(self):
# self.user_manager.create( **user2_data )
dataset = self.dataset_manager.create()
all_keys = list(self.dataset_serializer.serializable_keyset)
serialized = self.dataset_serializer.serialize(dataset, all_keys)
self.log('everything serialized should be of the proper type')
self.assertEncodedId(serialized['id'])
self.assertDate(serialized['create_time'])
self.assertDate(serialized['update_time'])
self.assertUUID(serialized['uuid'])
self.assertIsInstance(serialized['state'], basestring)
self.assertIsInstance(serialized['deleted'], bool)
self.assertIsInstance(serialized['purged'], bool)
self.assertIsInstance(serialized['purgable'], bool)
# # TODO: no great way to do these with mocked dataset
# self.assertIsInstance( serialized[ 'file_size' ], int )
# self.assertIsInstance( serialized[ 'total_size' ], int )
self.log('serialized should jsonify well')
self.assertIsJsonifyable(serialized)
class DatasetCollectionManagerTestCase(BaseTestCase, CreatesCollectionsMixin):
def set_up_managers(self):
super(DatasetCollectionManagerTestCase, self).set_up_managers()
self.dataset_manager = DatasetManager(self.app)
self.hda_manager = HDAManager(self.app)
self.history_manager = HistoryManager(self.app)
self.collection_manager = DatasetCollectionManager(self.app)
def test_create_simple_list(self):
owner = self.user_manager.create(**user2_data)
history = self.history_manager.create(name='history1', user=owner)
hda1 = self.hda_manager.create(name='one',
history=history,
dataset=self.dataset_manager.create())
hda2 = self.hda_manager.create(name='two',
history=history,
dataset=self.dataset_manager.create())
hda3 = self.hda_manager.create(name='three',
history=history,
dataset=self.dataset_manager.create())
self.log("should be able to create a new Collection via ids")
element_identifiers = self.build_element_identifiers(
[hda1, hda2, hda3])
hdca = self.collection_manager.create(
self.trans,
history,
'test collection',
'list',
element_identifiers=element_identifiers)
self.assertIsInstance(hdca, model.HistoryDatasetCollectionAssociation)
self.assertEqual(hdca.name, 'test collection')
self.assertEqual(hdca.hid, 4)
self.assertFalse(hdca.deleted)
self.assertTrue(hdca.visible)
# print 'hdca dir:'
# for k in dir( hdca ):
# print k, getattr( hdca, k, '(?)' )
self.log("should contain an underlying, well-formed DatasetCollection")
self.assertIsInstance(hdca.collection, model.DatasetCollection)
collection = hdca.collection
self.assertEqual(collection.collection_type, 'list')
self.assertEqual(collection.state, 'ok')
self.assertEqual(len(collection.dataset_instances), 3)
self.assertEqual(len(collection.elements), 3)
# print 'hdca.collection dir:'
# for k in dir( hdca.collection ):
# print k, getattr( hdca.collection, k, '(?)' )
# elements = collection.elements
# print 'hdca.collection element dir:'
# for k in dir( elements[0] ):
# print k, getattr( elements[0], k, '(?)' )
self.log("and that collection should have three well-formed Elements")
self.assertIsInstance(collection.elements[0],
model.DatasetCollectionElement)
self.assertEqual(collection.elements[0].element_identifier, 'one')
self.assertEqual(collection.elements[0].element_index, 0)
self.assertEqual(collection.elements[0].element_type, 'hda')
self.assertEqual(collection.elements[0].element_object, hda1)
self.assertIsInstance(collection.elements[1],
model.DatasetCollectionElement)
self.assertEqual(collection.elements[1].element_identifier, 'two')
self.assertEqual(collection.elements[1].element_index, 1)
self.assertEqual(collection.elements[1].element_type, 'hda')
self.assertEqual(collection.elements[1].element_object, hda2)
self.assertIsInstance(collection.elements[2],
model.DatasetCollectionElement)
self.assertEqual(collection.elements[2].element_identifier, 'three')
self.assertEqual(collection.elements[2].element_index, 2)
self.assertEqual(collection.elements[2].element_type, 'hda')
self.assertEqual(collection.elements[2].element_object, hda3)
self.log("should be able to create a new Collection via objects")
elements = dict(one=hda1, two=hda2, three=hda3)
hdca2 = self.collection_manager.create(self.trans,
history,
'test collection 2',
'list',
elements=elements)
self.assertIsInstance(hdca2, model.HistoryDatasetCollectionAssociation)
def test_update_from_dict(self):
owner = self.user_manager.create(**user2_data)
history = self.history_manager.create(name='history1', user=owner)
hda1 = self.hda_manager.create(name='one',
history=history,
dataset=self.dataset_manager.create())
hda2 = self.hda_manager.create(name='two',
history=history,
dataset=self.dataset_manager.create())
hda3 = self.hda_manager.create(name='three',
history=history,
dataset=self.dataset_manager.create())
elements = dict(one=hda1, two=hda2, three=hda3)
hdca = self.collection_manager.create(self.trans,
history,
'test collection',
'list',
elements=elements)
self.log("should be set from a dictionary")
self.collection_manager._set_from_dict(
self.trans,
hdca,
{
'deleted': True,
'visible': False,
'name': 'New Name',
# TODO: doesn't work
# 'tags' : [ 'one', 'two', 'three' ]
# 'annotations' : [?]
})
self.assertEqual(hdca.name, 'New Name')
self.assertTrue(hdca.deleted)
self.assertFalse(hdca.visible)
class HDAManagerTestCase(BaseTestCase):
def set_up_managers(self):
super(HDAManagerTestCase, self).set_up_managers()
self.history_mgr = HistoryManager(self.app)
self.dataset_mgr = DatasetManager(self.app)
self.hda_mgr = HDAManager(self.app)
def test_base(self):
hda_model = model.HistoryDatasetAssociation
owner = self.user_mgr.create(self.trans, **user2_data)
history1 = self.history_mgr.create(self.trans,
name='history1',
user=owner)
hda1 = self.hda_mgr.create(self.trans, history=history1, hid=1)
hda2 = self.hda_mgr.create(self.trans, history=history1, hid=2)
hda3 = self.hda_mgr.create(self.trans, history=history1, hid=3)
self.log("should be able to query")
hdas = self.trans.sa_session.query(hda_model).all()
self.assertEqual(self.hda_mgr.list(self.trans), hdas)
self.assertEqual(
self.hda_mgr.one(self.trans, filters=(hda_model.id == hda1.id)),
hda1)
self.assertEqual(self.hda_mgr.by_id(self.trans, hda1.id), hda1)
self.assertEqual(self.hda_mgr.by_ids(self.trans, [hda2.id, hda1.id]),
[hda2, hda1])
self.log("should be able to limit and offset")
self.assertEqual(self.hda_mgr.list(self.trans, limit=1), hdas[0:1])
self.assertEqual(self.hda_mgr.list(self.trans, offset=1), hdas[1:])
self.assertEqual(self.hda_mgr.list(self.trans, limit=1, offset=1),
hdas[1:2])
self.assertEqual(self.hda_mgr.list(self.trans, limit=0), [])
self.assertEqual(self.hda_mgr.list(self.trans, offset=3), [])
self.log("should be able to order")
self.assertEqual(
self.hda_mgr.list(self.trans,
order_by=sqlalchemy.desc(hda_model.create_time)),
[hda3, hda2, hda1])
def test_create(self):
owner = self.user_mgr.create(self.trans, **user2_data)
non_owner = self.user_mgr.create(self.trans, **user3_data)
history1 = self.history_mgr.create(self.trans,
name='history1',
user=owner)
dataset1 = self.dataset_mgr.create(self.trans)
self.log(
"should be able to create a new HDA with a specified history and dataset"
)
hda1 = self.hda_mgr.create(self.trans,
history=history1,
dataset=dataset1)
self.assertIsInstance(hda1, model.HistoryDatasetAssociation)
self.assertEqual(
hda1,
self.trans.sa_session.query(model.HistoryDatasetAssociation).get(
hda1.id))
self.assertEqual(hda1.history, history1)
self.assertEqual(hda1.dataset, dataset1)
self.assertEqual(hda1.hid, 1)
self.log(
"should be able to create a new HDA with only a specified history and no dataset"
)
hda2 = self.hda_mgr.create(self.trans, history=history1)
self.assertIsInstance(hda2, model.HistoryDatasetAssociation)
self.assertIsInstance(hda2.dataset, model.Dataset)
self.assertEqual(hda2.history, history1)
self.assertEqual(hda2.hid, 2)
self.log(
"should be able to create a new HDA with no history and no dataset"
)
hda3 = self.hda_mgr.create(self.trans, hid=None)
self.assertIsInstance(hda3, model.HistoryDatasetAssociation)
self.assertIsInstance(hda3.dataset,
model.Dataset,
msg="dataset will be auto created")
self.assertIsNone(hda3.history, msg="history will be None")
self.assertEqual(
hda3.hid,
None,
msg="should allow setting hid to None (or any other value)")
def test_copy_from_hda(self):
owner = self.user_mgr.create(self.trans, **user2_data)
history1 = self.history_mgr.create(self.trans,
name='history1',
user=owner)
dataset1 = self.dataset_mgr.create(self.trans)
hda1 = self.hda_mgr.create(self.trans,
history=history1,
dataset=dataset1)
self.log("should be able to copy an HDA")
hda2 = self.hda_mgr.copy(self.trans, hda1, history=history1)
self.assertIsInstance(hda2, model.HistoryDatasetAssociation)
self.assertEqual(
hda2,
self.trans.sa_session.query(model.HistoryDatasetAssociation).get(
hda2.id))
self.assertEqual(hda2.name, hda1.name)
self.assertEqual(hda2.history, hda1.history)
self.assertEqual(hda2.dataset, hda1.dataset)
self.assertNotEqual(hda2, hda1)
#def test_copy_from_ldda( self ):
# owner = self.user_mgr.create( self.trans, **user2_data )
# history1 = self.history_mgr.create( self.trans, name='history1', user=owner )
#
# self.log( "should be able to copy an HDA" )
# hda2 = self.hda_mgr.copy_ldda( self.trans, history1, hda1 )
def test_delete(self):
owner = self.user_mgr.create(self.trans, **user2_data)
history1 = self.history_mgr.create(self.trans,
name='history1',
user=owner)
dataset1 = self.dataset_mgr.create(self.trans)
item1 = self.hda_mgr.create(self.trans,
history=history1,
dataset=dataset1)
self.log("should be able to delete and undelete an hda")
self.assertFalse(item1.deleted)
self.assertEqual(self.hda_mgr.delete(self.trans, item1), item1)
self.assertTrue(item1.deleted)
self.assertEqual(self.hda_mgr.undelete(self.trans, item1), item1)
self.assertFalse(item1.deleted)
def test_purge_allowed(self):
self.trans.app.config.allow_user_dataset_purge = True
owner = self.user_mgr.create(self.trans, **user2_data)
history1 = self.history_mgr.create(self.trans,
name='history1',
user=owner)
dataset1 = self.dataset_mgr.create(self.trans)
item1 = self.hda_mgr.create(self.trans,
history=history1,
dataset=dataset1)
self.log("should purge an hda if config does allow")
self.assertFalse(item1.purged)
self.assertEqual(self.hda_mgr.purge(self.trans, item1), item1)
self.assertTrue(item1.purged)
def test_purge_not_allowed(self):
self.trans.app.config.allow_user_dataset_purge = False
owner = self.user_mgr.create(self.trans, **user2_data)
history1 = self.history_mgr.create(self.trans,
name='history1',
user=owner)
dataset1 = self.dataset_mgr.create(self.trans)
item1 = self.hda_mgr.create(self.trans,
history=history1,
dataset=dataset1)
self.log(
"should raise an error when purging an hda if config does not allow"
)
self.assertFalse(item1.purged)
self.assertRaises(exceptions.ConfigDoesNotAllowException,
self.hda_mgr.purge, self.trans, item1)
self.assertFalse(item1.purged)
def test_ownable(self):
owner = self.user_mgr.create(self.trans, **user2_data)
non_owner = self.user_mgr.create(self.trans, **user3_data)
history1 = self.history_mgr.create(self.trans,
name='history1',
user=owner)
dataset1 = self.dataset_mgr.create(self.trans)
item1 = self.hda_mgr.create(self.trans, history1, dataset1)
self.log("should be able to poll whether a given user owns an item")
self.assertTrue(self.hda_mgr.is_owner(self.trans, item1, owner))
self.assertFalse(self.hda_mgr.is_owner(self.trans, item1, non_owner))
self.log(
"should raise an error when checking ownership with non-owner")
self.assertRaises(exceptions.ItemOwnershipException,
self.hda_mgr.error_unless_owner, self.trans, item1,
non_owner)
self.log(
"should raise an error when checking ownership with anonymous")
self.assertRaises(exceptions.ItemOwnershipException,
self.hda_mgr.error_unless_owner, self.trans, item1,
None)
self.log(
"should not raise an error when checking ownership with owner")
self.assertEqual(
self.hda_mgr.error_unless_owner(self.trans, item1, owner), item1)
self.log(
"should not raise an error when checking ownership with admin")
self.assertEqual(
self.hda_mgr.error_unless_owner(self.trans, item1,
self.admin_user), item1)
def test_accessible(self):
owner = self.user_mgr.create(self.trans, **user2_data)
non_owner = self.user_mgr.create(self.trans, **user3_data)
history1 = self.history_mgr.create(self.trans,
name='history1',
user=owner)
dataset1 = self.dataset_mgr.create(self.trans)
item1 = self.hda_mgr.create(self.trans, history1, dataset1)
self.log(
"(by default, dataset permissions are lax) should be accessible to all"
)
for user in self.user_mgr.list(self.trans):
self.assertTrue(self.hda_mgr.is_accessible(self.trans, item1,
user))
#TODO: set perms on underlying dataset and then test accessible
def test_anon(self):
anon_user = None
self.trans.set_user(anon_user)
history1 = self.history_mgr.create(self.trans,
name='anon_history',
user=anon_user)
self.trans.set_history(history1)
dataset1 = self.dataset_mgr.create(self.trans)
item1 = self.hda_mgr.create(self.trans, history1, dataset1)
self.log(
"should not raise an error when checking ownership/access on anonymous' own dataset"
)
self.assertTrue(
self.hda_mgr.is_accessible(self.trans, item1, anon_user))
self.assertEqual(
self.hda_mgr.error_unless_owner(self.trans, item1, anon_user),
item1)
self.log(
"should raise an error when checking ownership on anonymous' dataset with other user"
)
non_owner = self.user_mgr.create(self.trans, **user3_data)
self.assertRaises(exceptions.ItemOwnershipException,
self.hda_mgr.error_unless_owner, self.trans, item1,
non_owner)
class DatasetSerializerTestCase(BaseTestCase):
def set_up_managers(self):
super(DatasetSerializerTestCase, self).set_up_managers()
self.dataset_manager = DatasetManager(self.app)
self.dataset_serializer = DatasetSerializer(self.app)
def test_views(self):
dataset = self.dataset_manager.create()
self.log('should have a summary view')
summary_view = self.dataset_serializer.serialize_to_view(
dataset, view='summary')
self.assertKeys(summary_view, self.dataset_serializer.views['summary'])
self.log('should have the summary view as default view')
default_view = self.dataset_serializer.serialize_to_view(
dataset, default_view='summary')
self.assertKeys(summary_view, self.dataset_serializer.views['summary'])
self.log('should have a serializer for all serializable keys')
for key in self.dataset_serializer.serializable_keyset:
instantiated_attribute = getattr(dataset, key, None)
if not ((key in self.dataset_serializer.serializers) or
(isinstance(instantiated_attribute,
self.TYPES_NEEDING_NO_SERIALIZERS))):
self.fail('no serializer for: %s (%s)' %
(key, instantiated_attribute))
else:
self.assertTrue(True, 'all serializable keys have a serializer')
def test_views_and_keys(self):
dataset = self.dataset_manager.create()
self.log('should be able to use keys with views')
serialized = self.dataset_serializer.serialize_to_view(
dataset, view='summary', keys=['permissions'])
self.assertKeys(
serialized,
self.dataset_serializer.views['summary'] + ['permissions'])
self.log('should be able to use keys on their own')
serialized = self.dataset_serializer.serialize_to_view(
dataset, keys=['purgable', 'file_size'])
self.assertKeys(serialized, ['purgable', 'file_size'])
def test_serialize_permissions(self):
dataset = self.dataset_manager.create()
self.log('serialized permissions should be well formed')
def test_serializers(self):
user2 = self.user_manager.create(**user2_data)
dataset = self.dataset_manager.create()
all_keys = list(self.dataset_serializer.serializable_keyset)
serialized = self.dataset_serializer.serialize(dataset, all_keys)
self.log('everything serialized should be of the proper type')
self.assertEncodedId(serialized['id'])
self.assertDate(serialized['create_time'])
self.assertDate(serialized['update_time'])
self.assertUUID(serialized['uuid'])
self.assertIsInstance(serialized['state'], basestring)
self.assertIsInstance(serialized['deleted'], bool)
self.assertIsInstance(serialized['purged'], bool)
self.assertIsInstance(serialized['purgable'], bool)
# # TODO: no great way to do these with mocked dataset
# self.assertIsInstance( serialized[ 'file_size' ], int )
# self.assertIsInstance( serialized[ 'total_size' ], int )
self.log('serialized should jsonify well')
self.assertIsJsonifyable(serialized)
class DatasetSerializerTestCase( BaseTestCase ):
def set_up_managers( self ):
super( DatasetSerializerTestCase, self ).set_up_managers()
self.dataset_manager = DatasetManager( self.app )
self.dataset_serializer = DatasetSerializer( self.app )
def test_views( self ):
dataset = self.dataset_manager.create()
self.log( 'should have a summary view' )
summary_view = self.dataset_serializer.serialize_to_view( dataset, view='summary' )
self.assertKeys( summary_view, self.dataset_serializer.views[ 'summary' ] )
self.log( 'should have the summary view as default view' )
default_view = self.dataset_serializer.serialize_to_view( dataset, default_view='summary' )
self.assertKeys( summary_view, self.dataset_serializer.views[ 'summary' ] )
self.log( 'should have a serializer for all serializable keys' )
for key in self.dataset_serializer.serializable_keyset:
instantiated_attribute = getattr( dataset, key, None )
if not ( ( key in self.dataset_serializer.serializers )
or ( isinstance( instantiated_attribute, self.TYPES_NEEDING_NO_SERIALIZERS ) ) ):
self.fail( 'no serializer for: %s (%s)' % ( key, instantiated_attribute ) )
else:
self.assertTrue( True, 'all serializable keys have a serializer' )
def test_views_and_keys( self ):
dataset = self.dataset_manager.create()
self.log( 'should be able to use keys with views' )
serialized = self.dataset_serializer.serialize_to_view( dataset,
view='summary', keys=[ 'permissions' ] )
self.assertKeys( serialized,
self.dataset_serializer.views[ 'summary' ] + [ 'permissions' ] )
self.log( 'should be able to use keys on their own' )
serialized = self.dataset_serializer.serialize_to_view( dataset,
keys=[ 'purgable', 'file_size' ] )
self.assertKeys( serialized, [ 'purgable', 'file_size' ] )
def test_serialize_permissions( self ):
dataset = self.dataset_manager.create()
self.log( 'serialized permissions should be well formed' )
def test_serializers( self ):
user2 = self.user_manager.create( **user2_data )
dataset = self.dataset_manager.create()
all_keys = list( self.dataset_serializer.serializable_keyset )
serialized = self.dataset_serializer.serialize( dataset, all_keys )
self.log( 'everything serialized should be of the proper type' )
self.assertEncodedId( serialized[ 'id' ] )
self.assertDate( serialized[ 'create_time' ] )
self.assertDate( serialized[ 'update_time' ] )
self.assertUUID( serialized[ 'uuid' ] )
self.assertIsInstance( serialized[ 'state' ], basestring )
self.assertIsInstance( serialized[ 'deleted' ], bool )
self.assertIsInstance( serialized[ 'purged' ], bool )
self.assertIsInstance( serialized[ 'purgable' ], bool )
# # TODO: no great way to do these with mocked dataset
# self.assertIsInstance( serialized[ 'file_size' ], int )
# self.assertIsInstance( serialized[ 'total_size' ], int )
self.log( 'serialized should jsonify well' )
self.assertIsJsonifyable( serialized )
class DatasetManagerTestCase( BaseTestCase ):
def set_up_managers( self ):
super( DatasetManagerTestCase, self ).set_up_managers()
self.dataset_mgr = DatasetManager( self.app )
def test_create( self ):
self.log( "should be able to create a new Dataset" )
dataset1 = self.dataset_mgr.create( self.trans )
self.assertIsInstance( dataset1, model.Dataset )
self.assertEqual( dataset1, self.trans.sa_session.query( model.Dataset ).get( dataset1.id ) )
def test_base( self ):
dataset1 = self.dataset_mgr.create( self.trans )
dataset2 = self.dataset_mgr.create( self.trans )
self.log( "should be able to query" )
datasets = self.trans.sa_session.query( model.Dataset ).all()
self.assertEqual( self.dataset_mgr.list( self.trans ), datasets )
self.assertEqual( self.dataset_mgr.one( self.trans, filters=( model.Dataset.id == dataset1.id ) ), dataset1 )
self.assertEqual( self.dataset_mgr.by_id( self.trans, dataset1.id ), dataset1 )
self.assertEqual( self.dataset_mgr.by_ids( self.trans, [ dataset2.id, dataset1.id ] ), [ dataset2, dataset1 ] )
self.log( "should be able to limit and offset" )
self.assertEqual( self.dataset_mgr.list( self.trans, limit=1 ), datasets[0:1] )
self.assertEqual( self.dataset_mgr.list( self.trans, offset=1 ), datasets[1:] )
self.assertEqual( self.dataset_mgr.list( self.trans, limit=1, offset=1 ), datasets[1:2] )
self.assertEqual( self.dataset_mgr.list( self.trans, limit=0 ), [] )
self.assertEqual( self.dataset_mgr.list( self.trans, offset=3 ), [] )
self.log( "should be able to order" )
self.assertEqual( self.dataset_mgr.list( self.trans, order_by=sqlalchemy.desc( model.Dataset.create_time ) ),
[ dataset2, dataset1 ] )
def test_delete( self ):
item1 = self.dataset_mgr.create( self.trans )
self.log( "should be able to delete and undelete an hda" )
self.assertFalse( item1.deleted )
self.assertEqual( self.dataset_mgr.delete( self.trans, item1 ), item1 )
self.assertTrue( item1.deleted )
self.assertEqual( self.dataset_mgr.undelete( self.trans, item1 ), item1 )
self.assertFalse( item1.deleted )
def test_purge_allowed( self ):
self.trans.app.config.allow_user_dataset_purge = True
item1 = self.dataset_mgr.create( self.trans )
self.log( "should purge an hda if config does allow" )
self.assertFalse( item1.purged )
self.assertEqual( self.dataset_mgr.purge( self.trans, item1 ), item1 )
self.assertTrue( item1.purged )
def test_purge_not_allowed( self ):
self.trans.app.config.allow_user_dataset_purge = False
item1 = self.dataset_mgr.create( self.trans )
self.log( "should raise an error when purging an hda if config does not allow" )
self.assertFalse( item1.purged )
self.assertRaises( exceptions.ConfigDoesNotAllowException, self.dataset_mgr.purge, self.trans, item1 )
self.assertFalse( item1.purged )
##TODO: I'm unclear as to how these work, so I'm kicking this down the road a bit....
#def test_access_permission( self ):
# owner = self.user_mgr.create( self.trans, **user2_data )
# dataset = self.dataset_mgr.create( self.trans )
# # giving one user access permission makes it non-public, removing access for anyone else
# self.dataset_mgr.give_access_permission( self.trans, dataset, owner )
#
# user3 = self.user_mgr.create( self.trans, **user3_data )
# user4 = self.user_mgr.create( self.trans,
# email='[email protected]', username='******', password=default_password )
#
# self.assertTrue( self.dataset_mgr.has_access_permission( self.trans, dataset, owner ) )
# self.assertFalse( self.dataset_mgr.has_access_permission( self.trans, dataset, user3 ) )
# self.assertFalse( self.dataset_mgr.has_access_permission( self.trans, dataset, user4 ) )
#
# # should be able to progressively add more roles without removing the previous
# self.dataset_mgr.give_access_permission( self.trans, dataset, user3 )
# self.assertTrue( self.dataset_mgr.has_access_permission( self.trans, dataset, user3 ) )
# self.assertTrue( self.dataset_mgr.has_access_permission( self.trans, dataset, owner ) )
# self.assertFalse( self.dataset_mgr.has_access_permission( self.trans, dataset, user4 ) )
#
# #self.assertTrue( self.dataset_mgr.is_accessible( self.trans, dataset, owner ) )
# #self.assertFalse( self.dataset_mgr.is_accessible( self.trans, dataset, non_owner ) )
def test_accessible( self ):
owner = self.user_mgr.create( self.trans, **user2_data )
non_owner = self.user_mgr.create( self.trans, **user3_data )
dataset = self.dataset_mgr.create( self.trans )
self.log( "(by default, dataset permissions are lax) should be accessible to all" )
for user in self.user_mgr.list( self.trans ):
self.assertTrue( self.dataset_mgr.is_accessible( self.trans, dataset, user ) )
class TagHandlerTestCase(BaseTestCase):
def set_up_managers(self):
super().set_up_managers()
self.hda_manager = hdas.HDAManager(self.app)
self.history_manager = HistoryManager(self.app)
self.dataset_manager = DatasetManager(self.app)
self.tag_handler = GalaxyTagHandler(self.trans.sa_session)
self.user = self.user_manager.create(**user2_data)
def _create_vanilla_hda(self, user=None):
owner = user or self.user
history1 = self.history_manager.create(name='history1', user=owner)
dataset1 = self.dataset_manager.create()
return self.hda_manager.create(history=history1, dataset=dataset1)
def _check_tag_list(self, tags, expected_tags):
self.assertEqual(len(tags), len(expected_tags))
actual_tags = []
for tag in tags:
if tag.user_value:
tag = f"{tag.user_tname}:{tag.user_value}"
else:
tag = tag.user_tname
actual_tags.append(tag)
expected = [unicodify(e) for e in expected_tags]
assert sorted(expected) == sorted(
actual_tags), f"{expected} vs {actual_tags}"
def test_apply_item_tags(self):
tag_strings = [
'tag1',
'tag1:value1',
'tag1:value1:value11',
'\x00tag1',
'tag1:\x00value1',
'tag1,tag2',
'...',
'.test',
'test.a.b',
]
expected_tags = [
['tag1'],
['tag1:value1'],
['tag1:value1:value11'],
['tag1'],
['tag1:value1'],
['tag1', 'tag2'],
[],
['test'],
['test.a.b'],
]
for tag_string, expected_tag in zip(tag_strings, expected_tags):
hda = self._create_vanilla_hda()
self.tag_handler.apply_item_tags(user=self.user,
item=hda,
tags_str=tag_string)
self._check_tag_list(hda.tags, expected_tag)
def test_set_tag_from_list(self):
hda = self._create_vanilla_hda()
tags = ['tag1', 'tag2']
self.tag_handler.set_tags_from_list(self.user, hda, tags)
self._check_tag_list(hda.tags, tags)
# Setting tags should erase previous tags
self.tag_handler.set_tags_from_list(self.user, hda, ['tag1'])
self._check_tag_list(hda.tags, expected_tags=['tag1'])
def test_add_tag_from_list(self):
hda = self._create_vanilla_hda()
tags = ['tag1', 'tag2']
self.tag_handler.add_tags_from_list(self.user, hda, tags)
self._check_tag_list(tags=hda.tags, expected_tags=tags)
# Adding tags should keep previous tags
self.tag_handler.add_tags_from_list(self.user, hda, ['tag3'])
self._check_tag_list(hda.tags, expected_tags=['tag1', 'tag2', 'tag3'])
def test_remove_tag_from_list(self):
hda = self._create_vanilla_hda()
tags = ['tag1', 'tag2', 'tag3']
self.tag_handler.set_tags_from_list(self.user, hda, tags)
self._check_tag_list(hda.tags, tags)
self.tag_handler.remove_tags_from_list(self.user, hda,
['tag1', 'tag3'])
self._check_tag_list(hda.tags, ['tag2'])
def test_delete_item_tags(self):
hda = self._create_vanilla_hda()
tags = ['tag1']
self.tag_handler.set_tags_from_list(self.user, hda, tags)
self.tag_handler.delete_item_tags(user=self.user, item=hda)
self.assertEqual(hda.tags, [])
def test_item_has_tag(self):
hda = self._create_vanilla_hda()
tags = ['tag1']
self.tag_handler.set_tags_from_list(self.user, hda, tags)
self.assertTrue(
self.tag_handler.item_has_tag(self.user, item=hda, tag='tag1'))
# ItemTagAssociation
self.assertTrue(
self.tag_handler.item_has_tag(self.user, item=hda,
tag=hda.tags[0]))
# Tag
self.assertTrue(
self.tag_handler.item_has_tag(self.user,
item=hda,
tag=hda.tags[0].tag))
self.assertFalse(
self.tag_handler.item_has_tag(self.user, item=hda, tag='tag2'))
class DatasetManagerTestCase(BaseTestCase):
def set_up_managers(self):
super(DatasetManagerTestCase, self).set_up_managers()
self.dataset_manager = DatasetManager(self.app)
def test_create(self):
self.log("should be able to create a new Dataset")
dataset1 = self.dataset_manager.create()
self.assertIsInstance(dataset1, model.Dataset)
self.assertEqual(
dataset1,
self.trans.sa_session.query(model.Dataset).get(dataset1.id))
def test_base(self):
dataset1 = self.dataset_manager.create()
dataset2 = self.dataset_manager.create()
self.log("should be able to query")
datasets = self.trans.sa_session.query(model.Dataset).all()
self.assertEqual(self.dataset_manager.list(), datasets)
self.assertEqual(
self.dataset_manager.one(
filters=(model.Dataset.id == dataset1.id)), dataset1)
self.assertEqual(self.dataset_manager.by_id(dataset1.id), dataset1)
self.assertEqual(
self.dataset_manager.by_ids([dataset2.id, dataset1.id]),
[dataset2, dataset1])
self.log("should be able to limit and offset")
self.assertEqual(self.dataset_manager.list(limit=1), datasets[0:1])
self.assertEqual(self.dataset_manager.list(offset=1), datasets[1:])
self.assertEqual(self.dataset_manager.list(limit=1, offset=1),
datasets[1:2])
self.assertEqual(self.dataset_manager.list(limit=0), [])
self.assertEqual(self.dataset_manager.list(offset=3), [])
self.log("should be able to order")
self.assertEqual(
self.dataset_manager.list(
order_by=sqlalchemy.desc(model.Dataset.create_time)),
[dataset2, dataset1])
def test_delete(self):
item1 = self.dataset_manager.create()
self.log("should be able to delete and undelete a dataset")
self.assertFalse(item1.deleted)
self.assertEqual(self.dataset_manager.delete(item1), item1)
self.assertTrue(item1.deleted)
self.assertEqual(self.dataset_manager.undelete(item1), item1)
self.assertFalse(item1.deleted)
def test_purge_allowed(self):
self.trans.app.config.allow_user_dataset_purge = True
item1 = self.dataset_manager.create()
self.log("should purge a dataset if config does allow")
self.assertFalse(item1.purged)
self.assertEqual(self.dataset_manager.purge(item1), item1)
self.assertTrue(item1.purged)
self.log("should delete a dataset when purging")
self.assertTrue(item1.deleted)
def test_purge_not_allowed(self):
self.trans.app.config.allow_user_dataset_purge = False
item1 = self.dataset_manager.create()
self.log(
"should raise an error when purging a dataset if config does not allow"
)
self.assertFalse(item1.purged)
self.assertRaises(exceptions.ConfigDoesNotAllowException,
self.dataset_manager.purge, item1)
self.assertFalse(item1.purged)
def test_create_with_no_permissions(self):
self.log(
"should be able to create a new Dataset without any permissions")
dataset = self.dataset_manager.create()
permissions = self.dataset_manager.permissions.get(dataset)
self.assertIsInstance(permissions, tuple)
self.assertEqual(len(permissions), 2)
manage_permissions, access_permissions = permissions
self.assertEqual(manage_permissions, [])
self.assertEqual(access_permissions, [])
user3 = self.user_manager.create(**user3_data)
self.log(
"a dataset without permissions shouldn't be manageable to just anyone"
)
self.assertFalse(
self.dataset_manager.permissions.manage.is_permitted(
dataset, user3))
self.log("a dataset without permissions should be accessible")
self.assertTrue(
self.dataset_manager.permissions.access.is_permitted(
dataset, user3))
def test_create_public_dataset(self):
self.log(
"should be able to create a new Dataset and give it some permissions that actually, you know, "
"might work if there's any justice in this universe")
owner = self.user_manager.create(**user2_data)
owner_private_role = self.user_manager.private_role(owner)
dataset = self.dataset_manager.create(
manage_roles=[owner_private_role])
permissions = self.dataset_manager.permissions.get(dataset)
self.assertIsInstance(permissions, tuple)
self.assertEqual(len(permissions), 2)
manage_permissions, access_permissions = permissions
self.assertIsInstance(manage_permissions, list)
self.assertIsInstance(manage_permissions[0], model.DatasetPermissions)
self.assertEqual(access_permissions, [])
user3 = self.user_manager.create(**user3_data)
self.log("a public dataset should be manageable to it's owner")
self.assertTrue(
self.dataset_manager.permissions.manage.is_permitted(
dataset, owner))
self.log("a public dataset shouldn't be manageable to just anyone")
self.assertFalse(
self.dataset_manager.permissions.manage.is_permitted(
dataset, user3))
self.log("a public dataset should be accessible")
self.assertTrue(
self.dataset_manager.permissions.access.is_permitted(
dataset, user3))
def test_create_private_dataset(self):
self.log(
"should be able to create a new Dataset and give it private permissions"
)
owner = self.user_manager.create(**user2_data)
owner_private_role = self.user_manager.private_role(owner)
dataset = self.dataset_manager.create(
manage_roles=[owner_private_role],
access_roles=[owner_private_role])
permissions = self.dataset_manager.permissions.get(dataset)
self.assertIsInstance(permissions, tuple)
self.assertEqual(len(permissions), 2)
manage_permissions, access_permissions = permissions
self.assertIsInstance(manage_permissions, list)
self.assertIsInstance(manage_permissions[0], model.DatasetPermissions)
self.assertIsInstance(access_permissions, list)
self.assertIsInstance(access_permissions[0], model.DatasetPermissions)
self.log("a private dataset should be manageable by it's owner")
self.assertTrue(
self.dataset_manager.permissions.manage.is_permitted(
dataset, owner))
self.log("a private dataset should be accessible to it's owner")
self.assertTrue(
self.dataset_manager.permissions.access.is_permitted(
dataset, owner))
user3 = self.user_manager.create(**user3_data)
self.log("a private dataset shouldn't be manageable to just anyone")
self.assertFalse(
self.dataset_manager.permissions.manage.is_permitted(
dataset, user3))
self.log("a private dataset shouldn't be accessible to just anyone")
self.assertFalse(
self.dataset_manager.permissions.access.is_permitted(
dataset, user3))
class DatasetManagerTestCase( BaseTestCase ):
def set_up_managers( self ):
super( DatasetManagerTestCase, self ).set_up_managers()
self.dataset_manager = DatasetManager( self.app )
def test_create( self ):
self.log( "should be able to create a new Dataset" )
dataset1 = self.dataset_manager.create()
self.assertIsInstance( dataset1, model.Dataset )
self.assertEqual( dataset1, self.trans.sa_session.query( model.Dataset ).get( dataset1.id ) )
def test_base( self ):
dataset1 = self.dataset_manager.create()
dataset2 = self.dataset_manager.create()
self.log( "should be able to query" )
datasets = self.trans.sa_session.query( model.Dataset ).all()
self.assertEqual( self.dataset_manager.list(), datasets )
self.assertEqual( self.dataset_manager.one( filters=( model.Dataset.id == dataset1.id ) ), dataset1 )
self.assertEqual( self.dataset_manager.by_id( dataset1.id ), dataset1 )
self.assertEqual( self.dataset_manager.by_ids( [ dataset2.id, dataset1.id ] ), [ dataset2, dataset1 ] )
self.log( "should be able to limit and offset" )
self.assertEqual( self.dataset_manager.list( limit=1 ), datasets[0:1] )
self.assertEqual( self.dataset_manager.list( offset=1 ), datasets[1:] )
self.assertEqual( self.dataset_manager.list( limit=1, offset=1 ), datasets[1:2] )
self.assertEqual( self.dataset_manager.list( limit=0 ), [] )
self.assertEqual( self.dataset_manager.list( offset=3 ), [] )
self.log( "should be able to order" )
self.assertEqual( self.dataset_manager.list( order_by=sqlalchemy.desc( model.Dataset.create_time ) ),
[ dataset2, dataset1 ] )
def test_delete( self ):
item1 = self.dataset_manager.create()
self.log( "should be able to delete and undelete a dataset" )
self.assertFalse( item1.deleted )
self.assertEqual( self.dataset_manager.delete( item1 ), item1 )
self.assertTrue( item1.deleted )
self.assertEqual( self.dataset_manager.undelete( item1 ), item1 )
self.assertFalse( item1.deleted )
def test_purge_allowed( self ):
self.trans.app.config.allow_user_dataset_purge = True
item1 = self.dataset_manager.create()
self.log( "should purge a dataset if config does allow" )
self.assertFalse( item1.purged )
self.assertEqual( self.dataset_manager.purge( item1 ), item1 )
self.assertTrue( item1.purged )
self.log( "should delete a dataset when purging" )
self.assertTrue( item1.deleted )
def test_purge_not_allowed( self ):
self.trans.app.config.allow_user_dataset_purge = False
item1 = self.dataset_manager.create()
self.log( "should raise an error when purging a dataset if config does not allow" )
self.assertFalse( item1.purged )
self.assertRaises( exceptions.ConfigDoesNotAllowException, self.dataset_manager.purge, item1 )
self.assertFalse( item1.purged )
def test_create_with_no_permissions( self ):
self.log( "should be able to create a new Dataset without any permissions" )
dataset = self.dataset_manager.create()
permissions = self.dataset_manager.permissions.get( dataset )
self.assertIsInstance( permissions, tuple )
self.assertEqual( len( permissions ), 2 )
manage_permissions, access_permissions = permissions
self.assertEqual( manage_permissions, [] )
self.assertEqual( access_permissions, [] )
user3 = self.user_manager.create( **user3_data )
self.log( "a dataset without permissions shouldn't be manageable to just anyone" )
self.assertFalse( self.dataset_manager.permissions.manage.is_permitted( dataset, user3 ) )
self.log( "a dataset without permissions should be accessible" )
self.assertTrue( self.dataset_manager.permissions.access.is_permitted( dataset, user3 ) )
def test_create_public_dataset( self ):
self.log( "should be able to create a new Dataset and give it some permissions that actually, you know, "
"might work if there's any justice in this universe" )
owner = self.user_manager.create( **user2_data )
owner_private_role = self.user_manager.private_role( owner )
dataset = self.dataset_manager.create( manage_roles=[ owner_private_role ] )
permissions = self.dataset_manager.permissions.get( dataset )
self.assertIsInstance( permissions, tuple )
self.assertEqual( len( permissions ), 2 )
manage_permissions, access_permissions = permissions
self.assertIsInstance( manage_permissions, list )
self.assertIsInstance( manage_permissions[0], model.DatasetPermissions )
self.assertEqual( access_permissions, [] )
user3 = self.user_manager.create( **user3_data )
self.log( "a public dataset should be manageable to it's owner" )
self.assertTrue( self.dataset_manager.permissions.manage.is_permitted( dataset, owner ) )
self.log( "a public dataset shouldn't be manageable to just anyone" )
self.assertFalse( self.dataset_manager.permissions.manage.is_permitted( dataset, user3 ) )
self.log( "a public dataset should be accessible" )
self.assertTrue( self.dataset_manager.permissions.access.is_permitted( dataset, user3 ) )
def test_create_private_dataset( self ):
self.log( "should be able to create a new Dataset and give it private permissions" )
owner = self.user_manager.create( **user2_data )
owner_private_role = self.user_manager.private_role( owner )
dataset = self.dataset_manager.create(
manage_roles=[ owner_private_role ], access_roles=[ owner_private_role ] )
permissions = self.dataset_manager.permissions.get( dataset )
self.assertIsInstance( permissions, tuple )
self.assertEqual( len( permissions ), 2 )
manage_permissions, access_permissions = permissions
self.assertIsInstance( manage_permissions, list )
self.assertIsInstance( manage_permissions[0], model.DatasetPermissions )
self.assertIsInstance( access_permissions, list )
self.assertIsInstance( access_permissions[0], model.DatasetPermissions )
self.log( "a private dataset should be manageable by it's owner" )
self.assertTrue( self.dataset_manager.permissions.manage.is_permitted( dataset, owner ) )
self.log( "a private dataset should be accessible to it's owner" )
self.assertTrue( self.dataset_manager.permissions.access.is_permitted( dataset, owner ) )
user3 = self.user_manager.create( **user3_data )
self.log( "a private dataset shouldn't be manageable to just anyone" )
self.assertFalse( self.dataset_manager.permissions.manage.is_permitted( dataset, user3 ) )
self.log( "a private dataset shouldn't be accessible to just anyone" )
self.assertFalse( self.dataset_manager.permissions.access.is_permitted( dataset, user3 ) )
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 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' ] )
class DatasetSerializerTestCase( BaseTestCase ):
def set_up_managers( self ):
super( DatasetSerializerTestCase, self ).set_up_managers()
self.dataset_manager = DatasetManager( self.app )
self.dataset_serializer = DatasetSerializer( self.app )
self.role_manager = RoleManager( self.app )
def test_views( self ):
dataset = self.dataset_manager.create()
self.log( 'should have a summary view' )
summary_view = self.dataset_serializer.serialize_to_view( dataset, view='summary' )
self.assertKeys( summary_view, self.dataset_serializer.views[ 'summary' ] )
self.log( 'should have the summary view as default view' )
self.dataset_serializer.serialize_to_view( dataset, default_view='summary' )
self.assertKeys( summary_view, self.dataset_serializer.views[ 'summary' ] )
self.log( 'should have a serializer for all serializable keys' )
for key in self.dataset_serializer.serializable_keyset:
instantiated_attribute = getattr( dataset, key, None )
if not ( ( key in self.dataset_serializer.serializers ) or
( isinstance( instantiated_attribute, self.TYPES_NEEDING_NO_SERIALIZERS ) ) ):
self.fail( 'no serializer for: %s (%s)' % ( key, instantiated_attribute ) )
else:
self.assertTrue( True, 'all serializable keys have a serializer' )
def test_views_and_keys( self ):
dataset = self.dataset_manager.create()
self.log( 'should be able to use keys with views' )
serialized = self.dataset_serializer.serialize_to_view( dataset,
# file_name is exposed using app.config.expose_dataset_path = True
view='summary', keys=[ 'file_name' ] )
self.assertKeys( serialized,
self.dataset_serializer.views[ 'summary' ] + [ 'file_name' ] )
self.log( 'should be able to use keys on their own' )
serialized = self.dataset_serializer.serialize_to_view( dataset,
keys=[ 'purgable', 'file_size' ] )
self.assertKeys( serialized, [ 'purgable', 'file_size' ] )
def test_serialize_permissions( self ):
dataset = self.dataset_manager.create()
who_manages = self.user_manager.create( **user2_data )
self.dataset_manager.permissions.manage.grant( dataset, who_manages )
self.log( 'serialized permissions should be returned for the user who can manage and be well formed' )
permissions = self.dataset_serializer.serialize_permissions( dataset, 'perms', user=who_manages )
self.assertIsInstance( permissions, dict )
self.assertKeys( permissions, [ 'manage', 'access' ] )
self.assertIsInstance( permissions[ 'manage' ], list )
self.assertIsInstance( permissions[ 'access' ], list )
manage_perms = permissions[ 'manage' ]
self.assertTrue( len( manage_perms ) == 1 )
role_id = manage_perms[0]
self.assertEncodedId( role_id )
role_id = self.app.security.decode_id( role_id )
role = self.role_manager.get( self.trans, role_id )
self.assertTrue( who_manages in [ user_role.user for user_role in role.users ])
# wat
self.log( 'permissions should be not returned for non-managing users' )
not_my_supervisor = self.user_manager.create( **user3_data )
self.assertRaises( SkipAttribute, self.dataset_serializer.serialize_permissions,
dataset, 'perms', user=not_my_supervisor )
self.log( 'permissions should not be returned for anon users' )
self.assertRaises( SkipAttribute, self.dataset_serializer.serialize_permissions,
dataset, 'perms', user=None )
def test_serializers( self ):
# self.user_manager.create( **user2_data )
dataset = self.dataset_manager.create()
all_keys = list( self.dataset_serializer.serializable_keyset )
serialized = self.dataset_serializer.serialize( dataset, all_keys )
self.log( 'everything serialized should be of the proper type' )
self.assertEncodedId( serialized[ 'id' ] )
self.assertDate( serialized[ 'create_time' ] )
self.assertDate( serialized[ 'update_time' ] )
self.assertUUID( serialized[ 'uuid' ] )
self.assertIsInstance( serialized[ 'state' ], basestring )
self.assertIsInstance( serialized[ 'deleted' ], bool )
self.assertIsInstance( serialized[ 'purged' ], bool )
self.assertIsInstance( serialized[ 'purgable' ], bool )
# # TODO: no great way to do these with mocked dataset
# self.assertIsInstance( serialized[ 'file_size' ], int )
# self.assertIsInstance( serialized[ 'total_size' ], int )
self.log( 'serialized should jsonify well' )
self.assertIsJsonifyable( serialized )
class TagManagerTestCase(BaseTestCase):
def set_up_managers(self):
super(TagManagerTestCase, self).set_up_managers()
self.hda_manager = hdas.HDAManager(self.app)
self.history_manager = HistoryManager(self.app)
self.dataset_manager = DatasetManager(self.app)
self.tag_manager = GalaxyTagManager(self.trans.sa_session)
self.user = self.user_manager.create(**user2_data)
def _create_vanilla_hda(self, user=None):
owner = user or self.user
history1 = self.history_manager.create(name='history1', user=owner)
dataset1 = self.dataset_manager.create()
return self.hda_manager.create(history=history1, dataset=dataset1)
def _check_tag_list(self, tags, expected_tags):
self.assertEqual(len(tags), len(expected_tags))
actual_tags = []
for tag in tags:
if tag.user_value:
tag = "%s:%s" % (tag.user_tname, tag.user_value)
else:
tag = tag.user_tname
actual_tags.append(tag)
expected = [unicodify(e) for e in expected_tags]
assert sorted(expected) == sorted(actual_tags), "%s vs %s" % (expected, actual_tags)
def test_apply_item_tags(self):
tag_strings = [
'tag1',
'tag1:value1',
'tag1:value1:value11',
'\x00tag1',
'tag1:\x00value1',
'tag1,tag2'
]
expected_tags = [
['tag1'],
['tag1:value1'],
['tag1:value1:value11'],
['tag1'],
['tag1:value1'],
['tag1', 'tag2']
]
for tag_string, expected_tag in zip(tag_strings, expected_tags):
hda = self._create_vanilla_hda()
self.tag_manager.apply_item_tags(user=self.user, item=hda, tags_str=tag_string)
self._check_tag_list(hda.tags, expected_tag)
def test_set_tag_from_list(self):
hda = self._create_vanilla_hda()
tags = ['tag1', 'tag2']
self.tag_manager.set_tags_from_list(self.user, hda, tags)
self._check_tag_list(hda.tags, tags)
# Setting tags should erase previous tags
self.tag_manager.set_tags_from_list(self.user, hda, ['tag1'])
self._check_tag_list(hda.tags, expected_tags=['tag1'])
def test_add_tag_from_list(self):
hda = self._create_vanilla_hda()
tags = ['tag1', 'tag2']
self.tag_manager.add_tags_from_list(self.user, hda, tags)
self._check_tag_list(tags=hda.tags, expected_tags=tags)
# Adding tags should keep previous tags
self.tag_manager.add_tags_from_list(self.user, hda, ['tag3'])
self._check_tag_list(hda.tags, expected_tags=['tag1', 'tag2', 'tag3'])
def test_remove_tag_from_list(self):
hda = self._create_vanilla_hda()
tags = ['tag1', 'tag2']
self.tag_manager.set_tags_from_list(self.user, hda, tags)
self._check_tag_list(hda.tags, tags)
self.tag_manager.remove_tags_from_list(self.user, hda, ['tag1'])
self._check_tag_list(hda.tags, ['tag2'])
def test_delete_item_tags(self):
hda = self._create_vanilla_hda()
tags = ['tag1']
self.tag_manager.set_tags_from_list(self.user, hda, tags)
self.tag_manager.delete_item_tags(user=self.user, item=hda)
self.assertEqual(hda.tags, [])
def test_item_has_tag(self):
hda = self._create_vanilla_hda()
tags = ['tag1']
self.tag_manager.set_tags_from_list(self.user, hda, tags)
self.assertTrue(self.tag_manager.item_has_tag(self.user, item=hda, tag='tag1'))
# ItemTagAssociation
self.assertTrue(self.tag_manager.item_has_tag(self.user, item=hda, tag=hda.tags[0]))
# Tag
self.assertTrue(self.tag_manager.item_has_tag(self.user, item=hda, tag=hda.tags[0].tag))
self.assertFalse(self.tag_manager.item_has_tag(self.user, item=hda, tag='tag2'))
class HDAManagerTestCase( BaseTestCase ):
def set_up_managers( self ):
super( HDAManagerTestCase, self ).set_up_managers()
self.history_mgr = HistoryManager( self.app )
self.dataset_mgr = DatasetManager( self.app )
self.hda_mgr = HDAManager( self.app )
def test_base( self ):
hda_model = model.HistoryDatasetAssociation
owner = self.user_mgr.create( self.trans, **user2_data )
history1 = self.history_mgr.create( self.trans, name='history1', user=owner )
hda1 = self.hda_mgr.create( self.trans, history=history1, hid=1 )
hda2 = self.hda_mgr.create( self.trans, history=history1, hid=2 )
hda3 = self.hda_mgr.create( self.trans, history=history1, hid=3 )
self.log( "should be able to query" )
hdas = self.trans.sa_session.query( hda_model ).all()
self.assertEqual( self.hda_mgr.list( self.trans ), hdas )
self.assertEqual( self.hda_mgr.one( self.trans, filters=( hda_model.id == hda1.id ) ), hda1 )
self.assertEqual( self.hda_mgr.by_id( self.trans, hda1.id ), hda1 )
self.assertEqual( self.hda_mgr.by_ids( self.trans, [ hda2.id, hda1.id ] ), [ hda2, hda1 ] )
self.log( "should be able to limit and offset" )
self.assertEqual( self.hda_mgr.list( self.trans, limit=1 ), hdas[0:1] )
self.assertEqual( self.hda_mgr.list( self.trans, offset=1 ), hdas[1:] )
self.assertEqual( self.hda_mgr.list( self.trans, limit=1, offset=1 ), hdas[1:2] )
self.assertEqual( self.hda_mgr.list( self.trans, limit=0 ), [] )
self.assertEqual( self.hda_mgr.list( self.trans, offset=3 ), [] )
self.log( "should be able to order" )
self.assertEqual( self.hda_mgr.list( self.trans, order_by=sqlalchemy.desc( hda_model.create_time ) ),
[ hda3, hda2, hda1 ] )
def test_create( self ):
owner = self.user_mgr.create( self.trans, **user2_data )
non_owner = self.user_mgr.create( self.trans, **user3_data )
history1 = self.history_mgr.create( self.trans, name='history1', user=owner )
dataset1 = self.dataset_mgr.create( self.trans )
self.log( "should be able to create a new HDA with a specified history and dataset" )
hda1 = self.hda_mgr.create( self.trans, history=history1, dataset=dataset1 )
self.assertIsInstance( hda1, model.HistoryDatasetAssociation )
self.assertEqual( hda1, self.trans.sa_session.query( model.HistoryDatasetAssociation ).get( hda1.id ) )
self.assertEqual( hda1.history, history1 )
self.assertEqual( hda1.dataset, dataset1 )
self.assertEqual( hda1.hid, 1 )
self.log( "should be able to create a new HDA with only a specified history and no dataset" )
hda2 = self.hda_mgr.create( self.trans, history=history1 )
self.assertIsInstance( hda2, model.HistoryDatasetAssociation )
self.assertIsInstance( hda2.dataset, model.Dataset )
self.assertEqual( hda2.history, history1 )
self.assertEqual( hda2.hid, 2 )
self.log( "should be able to create a new HDA with no history and no dataset" )
hda3 = self.hda_mgr.create( self.trans, hid=None )
self.assertIsInstance( hda3, model.HistoryDatasetAssociation )
self.assertIsInstance( hda3.dataset, model.Dataset, msg="dataset will be auto created" )
self.assertIsNone( hda3.history, msg="history will be None" )
self.assertEqual( hda3.hid, None, msg="should allow setting hid to None (or any other value)" )
def test_copy_from_hda( self ):
owner = self.user_mgr.create( self.trans, **user2_data )
history1 = self.history_mgr.create( self.trans, name='history1', user=owner )
dataset1 = self.dataset_mgr.create( self.trans )
hda1 = self.hda_mgr.create( self.trans, history=history1, dataset=dataset1 )
self.log( "should be able to copy an HDA" )
hda2 = self.hda_mgr.copy( self.trans, hda1, history=history1 )
self.assertIsInstance( hda2, model.HistoryDatasetAssociation )
self.assertEqual( hda2, self.trans.sa_session.query( model.HistoryDatasetAssociation ).get( hda2.id ) )
self.assertEqual( hda2.name, hda1.name )
self.assertEqual( hda2.history, hda1.history )
self.assertEqual( hda2.dataset, hda1.dataset )
self.assertNotEqual( hda2, hda1 )
#def test_copy_from_ldda( self ):
# owner = self.user_mgr.create( self.trans, **user2_data )
# history1 = self.history_mgr.create( self.trans, name='history1', user=owner )
#
# self.log( "should be able to copy an HDA" )
# hda2 = self.hda_mgr.copy_ldda( self.trans, history1, hda1 )
def test_delete( self ):
owner = self.user_mgr.create( self.trans, **user2_data )
history1 = self.history_mgr.create( self.trans, name='history1', user=owner )
dataset1 = self.dataset_mgr.create( self.trans )
item1 = self.hda_mgr.create( self.trans, history=history1, dataset=dataset1 )
self.log( "should be able to delete and undelete an hda" )
self.assertFalse( item1.deleted )
self.assertEqual( self.hda_mgr.delete( self.trans, item1 ), item1 )
self.assertTrue( item1.deleted )
self.assertEqual( self.hda_mgr.undelete( self.trans, item1 ), item1 )
self.assertFalse( item1.deleted )
def test_purge_allowed( self ):
self.trans.app.config.allow_user_dataset_purge = True
owner = self.user_mgr.create( self.trans, **user2_data )
history1 = self.history_mgr.create( self.trans, name='history1', user=owner )
dataset1 = self.dataset_mgr.create( self.trans )
item1 = self.hda_mgr.create( self.trans, history=history1, dataset=dataset1 )
self.log( "should purge an hda if config does allow" )
self.assertFalse( item1.purged )
self.assertEqual( self.hda_mgr.purge( self.trans, item1 ), item1 )
self.assertTrue( item1.purged )
def test_purge_not_allowed( self ):
self.trans.app.config.allow_user_dataset_purge = False
owner = self.user_mgr.create( self.trans, **user2_data )
history1 = self.history_mgr.create( self.trans, name='history1', user=owner )
dataset1 = self.dataset_mgr.create( self.trans )
item1 = self.hda_mgr.create( self.trans, history=history1, dataset=dataset1 )
self.log( "should raise an error when purging an hda if config does not allow" )
self.assertFalse( item1.purged )
self.assertRaises( exceptions.ConfigDoesNotAllowException, self.hda_mgr.purge, self.trans, item1 )
self.assertFalse( item1.purged )
def test_ownable( self ):
owner = self.user_mgr.create( self.trans, **user2_data )
non_owner = self.user_mgr.create( self.trans, **user3_data )
history1 = self.history_mgr.create( self.trans, name='history1', user=owner )
dataset1 = self.dataset_mgr.create( self.trans )
item1 = self.hda_mgr.create( self.trans, history1, dataset1 )
self.log( "should be able to poll whether a given user owns an item" )
self.assertTrue( self.hda_mgr.is_owner( self.trans, item1, owner ) )
self.assertFalse( self.hda_mgr.is_owner( self.trans, item1, non_owner ) )
self.log( "should raise an error when checking ownership with non-owner" )
self.assertRaises( exceptions.ItemOwnershipException,
self.hda_mgr.error_unless_owner, self.trans, item1, non_owner )
self.log( "should raise an error when checking ownership with anonymous" )
self.assertRaises( exceptions.ItemOwnershipException,
self.hda_mgr.error_unless_owner, self.trans, item1, None )
self.log( "should not raise an error when checking ownership with owner" )
self.assertEqual( self.hda_mgr.error_unless_owner( self.trans, item1, owner ), item1 )
self.log( "should not raise an error when checking ownership with admin" )
self.assertEqual( self.hda_mgr.error_unless_owner( self.trans, item1, self.admin_user ), item1 )
def test_accessible( self ):
owner = self.user_mgr.create( self.trans, **user2_data )
non_owner = self.user_mgr.create( self.trans, **user3_data )
history1 = self.history_mgr.create( self.trans, name='history1', user=owner )
dataset1 = self.dataset_mgr.create( self.trans )
item1 = self.hda_mgr.create( self.trans, history1, dataset1 )
self.log( "(by default, dataset permissions are lax) should be accessible to all" )
for user in self.user_mgr.list( self.trans ):
self.assertTrue( self.hda_mgr.is_accessible( self.trans, item1, user ) )
#TODO: set perms on underlying dataset and then test accessible
def test_anon( self ):
anon_user = None
self.trans.set_user( anon_user )
history1 = self.history_mgr.create( self.trans, name='anon_history', user=anon_user )
self.trans.set_history( history1 )
dataset1 = self.dataset_mgr.create( self.trans )
item1 = self.hda_mgr.create( self.trans, history1, dataset1 )
self.log( "should not raise an error when checking ownership/access on anonymous' own dataset" )
self.assertTrue( self.hda_mgr.is_accessible( self.trans, item1, anon_user ) )
self.assertEqual( self.hda_mgr.error_unless_owner( self.trans, item1, anon_user ), item1 )
self.log( "should raise an error when checking ownership on anonymous' dataset with other user" )
non_owner = self.user_mgr.create( self.trans, **user3_data )
self.assertRaises( exceptions.ItemOwnershipException,
self.hda_mgr.error_unless_owner, self.trans, item1, non_owner )
class DatasetCollectionManagerTestCase( BaseTestCase ):
def set_up_managers( self ):
super( DatasetCollectionManagerTestCase, self ).set_up_managers()
self.dataset_manager = DatasetManager( self.app )
self.hda_manager = HDAManager( self.app )
self.history_manager = HistoryManager( self.app )
self.collection_manager = DatasetCollectionManager( self.app )
def build_element_identifiers( self, elements ):
identifier_list = []
for element in elements:
src = 'hda'
# if isinstance( element, model.DatasetCollection ):
# src = 'collection'#?
# elif isinstance( element, model.LibraryDatasetDatasetAssociation ):
# src = 'ldda'#?
encoded_id = self.trans.security.encode_id( element.id )
identifier_list.append( dict( src=src, name=element.name, id=encoded_id ) )
return identifier_list
def test_create_simple_list( self ):
owner = self.user_manager.create( **user2_data )
history = self.history_manager.create( name='history1', user=owner )
hda1 = self.hda_manager.create( name='one',
history=history, dataset=self.dataset_manager.create() )
hda2 = self.hda_manager.create( name='two',
history=history, dataset=self.dataset_manager.create() )
hda3 = self.hda_manager.create( name='three',
history=history, dataset=self.dataset_manager.create() )
self.log( "should be able to create a new Collection via ids" )
element_identifiers = self.build_element_identifiers( [ hda1, hda2, hda3 ] )
hdca = self.collection_manager.create( self.trans, history, 'test collection', 'list',
element_identifiers=element_identifiers )
self.assertIsInstance( hdca, model.HistoryDatasetCollectionAssociation )
self.assertEqual( hdca.name, 'test collection' )
self.assertEqual( hdca.hid, 4 )
self.assertFalse( hdca.deleted )
self.assertTrue( hdca.visible )
# print 'hdca dir:'
# for k in dir( hdca ):
# print k, getattr( hdca, k, '(?)' )
self.log( "should contain an underlying, well-formed DatasetCollection" )
self.assertIsInstance( hdca.collection, model.DatasetCollection )
collection = hdca.collection
self.assertEqual( collection.collection_type, 'list' )
self.assertEqual( collection.state, 'ok' )
self.assertEqual( len( collection.dataset_instances ), 3 )
self.assertEqual( len( collection.elements ), 3 )
# print 'hdca.collection dir:'
# for k in dir( hdca.collection ):
# print k, getattr( hdca.collection, k, '(?)' )
# elements = collection.elements
# print 'hdca.collection element dir:'
# for k in dir( elements[0] ):
# print k, getattr( elements[0], k, '(?)' )
self.log( "and that collection should have three well-formed Elements" )
self.assertIsInstance( collection.elements[0], model.DatasetCollectionElement )
self.assertEqual( collection.elements[0].element_identifier, 'one' )
self.assertEqual( collection.elements[0].element_index, 0 )
self.assertEqual( collection.elements[0].element_type, 'hda' )
self.assertEqual( collection.elements[0].element_object, hda1 )
self.assertIsInstance( collection.elements[1], model.DatasetCollectionElement )
self.assertEqual( collection.elements[1].element_identifier, 'two' )
self.assertEqual( collection.elements[1].element_index, 1 )
self.assertEqual( collection.elements[1].element_type, 'hda' )
self.assertEqual( collection.elements[1].element_object, hda2 )
self.assertIsInstance( collection.elements[2], model.DatasetCollectionElement )
self.assertEqual( collection.elements[2].element_identifier, 'three' )
self.assertEqual( collection.elements[2].element_index, 2 )
self.assertEqual( collection.elements[2].element_type, 'hda' )
self.assertEqual( collection.elements[2].element_object, hda3 )
self.log( "should be able to create a new Collection via objects" )
elements = dict( one=hda1, two=hda2, three=hda3 )
hdca2 = self.collection_manager.create( self.trans, history, 'test collection 2', 'list', elements=elements )
self.assertIsInstance( hdca2, model.HistoryDatasetCollectionAssociation )
def test_update_from_dict( self ):
owner = self.user_manager.create( **user2_data )
history = self.history_manager.create( name='history1', user=owner )
hda1 = self.hda_manager.create( name='one',
history=history, dataset=self.dataset_manager.create() )
hda2 = self.hda_manager.create( name='two',
history=history, dataset=self.dataset_manager.create() )
hda3 = self.hda_manager.create( name='three',
history=history, dataset=self.dataset_manager.create() )
elements = dict( one=hda1, two=hda2, three=hda3 )
hdca = self.collection_manager.create( self.trans, history, 'test collection', 'list', elements=elements )
self.log( "should be set from a dictionary" )
self.collection_manager._set_from_dict( self.trans, hdca, {
'deleted' : True,
'visible' : False,
'name' : 'New Name',
# TODO: doesn't work
# 'tags' : [ 'one', 'two', 'three' ]
# 'annotations' : [?]
})
self.assertEqual( hdca.name, 'New Name' )
self.assertTrue( hdca.deleted )
self.assertFalse( hdca.visible )
class DatasetCollectionManagerTestCase(BaseTestCase, CreatesCollectionsMixin):
def set_up_managers(self):
super(DatasetCollectionManagerTestCase, self).set_up_managers()
self.dataset_manager = DatasetManager(self.app)
self.hda_manager = HDAManager(self.app)
self.history_manager = HistoryManager(self.app)
self.collection_manager = DatasetCollectionManager(self.app)
def test_create_simple_list(self):
owner = self.user_manager.create(**user2_data)
history = self.history_manager.create(name='history1', user=owner)
hda1 = self.hda_manager.create(name='one',
history=history, dataset=self.dataset_manager.create())
hda2 = self.hda_manager.create(name='two',
history=history, dataset=self.dataset_manager.create())
hda3 = self.hda_manager.create(name='three',
history=history, dataset=self.dataset_manager.create())
self.log("should be able to create a new Collection via ids")
element_identifiers = self.build_element_identifiers([hda1, hda2, hda3])
hdca = self.collection_manager.create(self.trans, history, 'test collection', 'list',
element_identifiers=element_identifiers)
self.assertIsInstance(hdca, model.HistoryDatasetCollectionAssociation)
self.assertEqual(hdca.name, 'test collection')
self.assertEqual(hdca.hid, 4)
self.assertFalse(hdca.deleted)
self.assertTrue(hdca.visible)
self.log("should contain an underlying, well-formed DatasetCollection")
self.assertIsInstance(hdca.collection, model.DatasetCollection)
collection = hdca.collection
self.assertEqual(collection.collection_type, 'list')
self.assertEqual(collection.state, 'ok')
self.assertEqual(len(collection.dataset_instances), 3)
self.assertEqual(len(collection.elements), 3)
self.log("and that collection should have three well-formed Elements")
self.assertIsInstance(collection.elements[0], model.DatasetCollectionElement)
self.assertEqual(collection.elements[0].element_identifier, 'one')
self.assertEqual(collection.elements[0].element_index, 0)
self.assertEqual(collection.elements[0].element_type, 'hda')
self.assertEqual(collection.elements[0].element_object, hda1)
self.assertIsInstance(collection.elements[1], model.DatasetCollectionElement)
self.assertEqual(collection.elements[1].element_identifier, 'two')
self.assertEqual(collection.elements[1].element_index, 1)
self.assertEqual(collection.elements[1].element_type, 'hda')
self.assertEqual(collection.elements[1].element_object, hda2)
self.assertIsInstance(collection.elements[2], model.DatasetCollectionElement)
self.assertEqual(collection.elements[2].element_identifier, 'three')
self.assertEqual(collection.elements[2].element_index, 2)
self.assertEqual(collection.elements[2].element_type, 'hda')
self.assertEqual(collection.elements[2].element_object, hda3)
self.log("should be able to create a new Collection via objects")
elements = dict(one=hda1, two=hda2, three=hda3)
hdca2 = self.collection_manager.create(self.trans, history, 'test collection 2', 'list', elements=elements)
self.assertIsInstance(hdca2, model.HistoryDatasetCollectionAssociation)
def test_update_from_dict(self):
owner = self.user_manager.create(**user2_data)
history = self.history_manager.create(name='history1', user=owner)
hda1 = self.hda_manager.create(name='one',
history=history, dataset=self.dataset_manager.create())
hda2 = self.hda_manager.create(name='two',
history=history, dataset=self.dataset_manager.create())
hda3 = self.hda_manager.create(name='three',
history=history, dataset=self.dataset_manager.create())
elements = dict(one=hda1, two=hda2, three=hda3)
hdca = self.collection_manager.create(self.trans, history, 'test collection', 'list', elements=elements)
self.log("should be set from a dictionary")
self.collection_manager._set_from_dict(self.trans, hdca, {
'deleted': True,
'visible': False,
'name': 'New Name',
# TODO: doesn't work
# 'tags' : [ 'one', 'two', 'three' ]
# 'annotations' : [?]
})
self.assertEqual(hdca.name, 'New Name')
self.assertTrue(hdca.deleted)
self.assertFalse(hdca.visible)
