class HistoryAsContainerTestCase( BaseTestCase, CreatesCollectionsMixin ):
def set_up_managers( self ):
super( HistoryAsContainerTestCase, self ).set_up_managers()
self.history_manager = HistoryManager( self.app )
self.hda_manager = hdas.HDAManager( self.app )
self.collection_manager = collections.DatasetCollectionManager( self.app )
def add_hda_to_history( self, history, **kwargs ):
dataset = self.hda_manager.dataset_manager.create()
hda = self.hda_manager.create( history=history, dataset=dataset, **kwargs )
return hda
def add_list_collection_to_history( self, history, hdas, name='test collection', **kwargs ):
hdca = self.collection_manager.create( self.trans, history, name, 'list',
element_identifiers=self.build_element_identifiers( hdas ) )
return hdca
def test_contents( self ):
user2 = self.user_manager.create( **user2_data )
history = self.history_manager.create( name='history', user=user2 )
self.log( "calling contents on an empty history should return an empty list" )
self.assertEqual( [], list( self.history_manager.contents( history ) ) )
self.log( "calling contents on an history with hdas should return those in order of their hids" )
hdas = [ self.add_hda_to_history( history, name=( 'hda-' + str( x ) ) ) for x in xrange( 3 ) ]
random.shuffle( hdas )
ordered_hda_contents = list( self.history_manager.contents( history ) )
self.assertEqual( map( lambda hda: hda.hid, ordered_hda_contents ), [ 1, 2, 3 ] )
self.log( "calling contents on an history with both hdas and collections should return both" )
hdca = self.add_list_collection_to_history( history, hdas )
all_contents = list( self.history_manager.contents( history ) )
self.assertEqual( all_contents, list( ordered_hda_contents ) + [ hdca ] )
def test_contained( self ):
user2 = self.user_manager.create( **user2_data )
history = self.history_manager.create( name='history', user=user2 )
self.log( "calling contained on an empty history should return an empty list" )
self.assertEqual( [], list( self.history_manager.contained( history ) ) )
self.log( "calling contained on an history with both hdas and collections should return only hdas" )
hdas = [ self.add_hda_to_history( history, name=( 'hda-' + str( x ) ) ) for x in xrange( 3 ) ]
self.add_list_collection_to_history( history, hdas )
self.assertEqual( list( self.history_manager.contained( history ) ), hdas )
def test_subcontainers( self ):
user2 = self.user_manager.create( **user2_data )
history = self.history_manager.create( name='history', user=user2 )
self.log( "calling subcontainers on an empty history should return an empty list" )
self.assertEqual( [], list( self.history_manager.subcontainers( history ) ) )
self.log( "calling subcontainers on an history with both hdas and collections should return only collections" )
hdas = [ self.add_hda_to_history( history, name=( 'hda-' + str( x ) ) ) for x in xrange( 3 ) ]
hdca = self.add_list_collection_to_history( history, hdas )
subcontainers = list( self.history_manager.subcontainers( history ) )
self.assertEqual( subcontainers, [ hdca ] )
class HistoryAsContainerTestCase( BaseTestCase, CreatesCollectionsMixin ):
def set_up_managers( self ):
super( HistoryAsContainerTestCase, self ).set_up_managers()
self.history_manager = HistoryManager( self.app )
self.hda_manager = hdas.HDAManager( self.app )
self.collection_manager = collections.DatasetCollectionManager( self.app )
def add_hda_to_history( self, history, **kwargs ):
dataset = self.hda_manager.dataset_manager.create()
hda = self.hda_manager.create( history=history, dataset=dataset, **kwargs )
return hda
def add_list_collection_to_history( self, history, hdas, name='test collection', **kwargs ):
hdca = self.collection_manager.create( self.trans, history, name, 'list',
element_identifiers=self.build_element_identifiers( hdas ) )
return hdca
def test_contents( self ):
user2 = self.user_manager.create( **user2_data )
history = self.history_manager.create( name='history', user=user2 )
self.log( "calling contents on an empty history should return an empty list" )
self.assertEqual( [], list( self.history_manager.contents( history ) ) )
self.log( "calling contents on an history with hdas should return those in order of their hids" )
hdas = [ self.add_hda_to_history( history, name=( 'hda-' + str( x ) ) ) for x in xrange( 3 ) ]
random.shuffle( hdas )
ordered_hda_contents = list( self.history_manager.contents( history ) )
self.assertEqual( map( lambda hda: hda.hid, ordered_hda_contents ), [ 1, 2, 3 ] )
self.log( "calling contents on an history with both hdas and collections should return both" )
hdca = self.add_list_collection_to_history( history, hdas )
all_contents = list( self.history_manager.contents( history ) )
self.assertEqual( all_contents, list( ordered_hda_contents ) + [ hdca ] )
def test_contained( self ):
user2 = self.user_manager.create( **user2_data )
history = self.history_manager.create( name='history', user=user2 )
self.log( "calling contained on an empty history should return an empty list" )
self.assertEqual( [], list( self.history_manager.contained( history ) ) )
self.log( "calling contained on an history with both hdas and collections should return only hdas" )
hdas = [ self.add_hda_to_history( history, name=( 'hda-' + str( x ) ) ) for x in xrange( 3 ) ]
self.add_list_collection_to_history( history, hdas )
self.assertEqual( list( self.history_manager.contained( history ) ), hdas )
def test_subcontainers( self ):
user2 = self.user_manager.create( **user2_data )
history = self.history_manager.create( name='history', user=user2 )
self.log( "calling subcontainers on an empty history should return an empty list" )
self.assertEqual( [], list( self.history_manager.subcontainers( history ) ) )
self.log( "calling subcontainers on an history with both hdas and collections should return only collections" )
hdas = [ self.add_hda_to_history( history, name=( 'hda-' + str( x ) ) ) for x in xrange( 3 ) ]
hdca = self.add_list_collection_to_history( history, hdas )
subcontainers = list( self.history_manager.subcontainers( history ) )
self.assertEqual( subcontainers, [ hdca ] )
class HDCATestCase( BaseTestCase, CreatesCollectionsMixin ):
def set_up_managers( self ):
super( HDCATestCase, self ).set_up_managers()
self.hdca_manager = hdcas.HDCAManager( self.app )
self.hda_manager = hdas.HDAManager( self.app )
self.history_manager = HistoryManager( self.app )
self.dataset_manager = DatasetManager( self.app )
self.collection_manager = collections.DatasetCollectionManager( self.app )
def _create_history( self, user_data=None, **kwargs ):
user_data = user_data or user2_data
owner = self.user_manager.create( **user_data )
return self.history_manager.create( user=owner, **kwargs )
def _create_hda( self, history, dataset=None, **kwargs ):
if not dataset:
dataset = self.hda_manager.dataset_manager.create()
hda = self.hda_manager.create( history=history, dataset=dataset, **kwargs )
return hda
def _create_list_hdca( self, hdas, history=None, name='test collection', **kwargs ):
if not history:
history = history or self._create_history()
for i, hda in enumerate( hdas ):
if not isinstance( hdas, self.hda_manager.model_class ):
hdas[ i ] = self._create_hda( history, **hda )
hdca = self.collection_manager.create( self.trans, history, name, 'list',
element_identifiers=self.build_element_identifiers( hdas ) )
return hdca
class HDCATestCase( BaseTestCase, CreatesCollectionsMixin ):
def set_up_managers( self ):
super( HDCATestCase, self ).set_up_managers()
self.hdca_manager = hdcas.HDCAManager( self.app )
self.hda_manager = hdas.HDAManager( self.app )
self.history_manager = HistoryManager( self.app )
self.dataset_manager = DatasetManager( self.app )
self.collection_manager = collections.DatasetCollectionManager( self.app )
def _create_history( self, user_data=None, **kwargs ):
user_data = user_data or user2_data
owner = self.user_manager.create( **user_data )
return self.history_manager.create( user=owner, **kwargs )
def _create_hda( self, history, dataset=None, **kwargs ):
if not dataset:
dataset = self.hda_manager.dataset_manager.create()
hda = self.hda_manager.create( history=history, dataset=dataset, **kwargs )
return hda
def _create_list_hdca( self, hdas, history=None, name='test collection', **kwargs ):
if not history:
history = history or self._create_history()
for i, hda in enumerate( hdas ):
if not isinstance( hdas, self.hda_manager.model_class ):
hdas[ i ] = self._create_hda( history, **hda )
hdca = self.collection_manager.create( self.trans, history, name, 'list',
element_identifiers=self.build_element_identifiers( hdas ) )
return hdca
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 HistoryManagerTestCase(BaseTestCase):
def set_up_managers(self):
super(HistoryManagerTestCase, self).set_up_managers()
self.history_mgr = HistoryManager(self.app)
def test_base(self):
user2 = self.user_mgr.create(self.trans, **user2_data)
user3 = self.user_mgr.create(self.trans, **user3_data)
self.log("should be able to create a new history")
history1 = self.history_mgr.create(self.trans,
name='history1',
user=user2)
self.assertIsInstance(history1, model.History)
self.assertEqual(history1.name, 'history1')
self.assertEqual(history1.user, user2)
self.assertEqual(
history1,
self.trans.sa_session.query(model.History).get(history1.id))
self.assertEqual(
history1,
self.trans.sa_session.query(
model.History).filter(model.History.name == 'history1').one())
self.assertEqual(
history1,
self.trans.sa_session.query(
model.History).filter(model.History.user == user2).one())
self.log("should be able to copy a history")
history2 = self.history_mgr.copy(self.trans, history1, user=user3)
self.assertIsInstance(history2, model.History)
self.assertEqual(history2.user, user3)
self.assertEqual(
history2,
self.trans.sa_session.query(model.History).get(history2.id))
self.assertEqual(history2.name, history1.name)
self.assertNotEqual(history2, history1)
self.log("should be able to query")
histories = self.trans.sa_session.query(model.History).all()
self.assertEqual(
self.history_mgr.one(self.trans,
filters=(model.History.id == history1.id)),
history1)
self.assertEqual(self.history_mgr.list(self.trans), histories)
self.assertEqual(self.history_mgr.by_id(self.trans, history1.id),
history1)
self.assertEqual(
self.history_mgr.by_ids(self.trans, [history2.id, history1.id]),
[history2, history1])
self.log("should be able to limit and offset")
self.assertEqual(self.history_mgr.list(self.trans, limit=1),
histories[0:1])
self.assertEqual(self.history_mgr.list(self.trans, offset=1),
histories[1:])
self.assertEqual(self.history_mgr.list(self.trans, limit=1, offset=1),
histories[1:2])
self.assertEqual(self.history_mgr.list(self.trans, limit=0), [])
self.assertEqual(self.history_mgr.list(self.trans, offset=3), [])
self.log("should be able to order")
history3 = self.history_mgr.create(self.trans,
name="history3",
user=user2)
name_first_then_time = (model.History.name,
sqlalchemy.desc(model.History.create_time))
self.assertEqual(
self.history_mgr.list(self.trans, order_by=name_first_then_time),
[history2, history1, history3])
def test_has_user(self):
owner = self.user_mgr.create(self.trans, **user2_data)
non_owner = self.user_mgr.create(self.trans, **user3_data)
item1 = self.history_mgr.create(self.trans, user=owner)
item2 = self.history_mgr.create(self.trans, user=owner)
item3 = self.history_mgr.create(self.trans, user=non_owner)
self.log("should be able to list items by user")
user_histories = self.history_mgr.by_user(self.trans, owner)
self.assertEqual(user_histories, [item1, item2])
query = self.history_mgr._query_by_user(self.trans, owner)
self.assertEqual(query.all(), user_histories)
def test_ownable(self):
owner = self.user_mgr.create(self.trans, **user2_data)
non_owner = self.user_mgr.create(self.trans, **user3_data)
item1 = self.history_mgr.create(self.trans, user=owner)
self.log("should be able to poll whether a given user owns an item")
self.assertTrue(self.history_mgr.is_owner(self.trans, item1, owner))
self.assertFalse(
self.history_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.history_mgr.error_unless_owner, self.trans,
item1, non_owner)
self.assertRaises(exceptions.ItemOwnershipException,
self.history_mgr.get_owned, self.trans, item1.id,
non_owner)
self.log(
"should not raise an error when checking ownership with owner")
self.assertEqual(
self.history_mgr.error_unless_owner(self.trans, item1, owner),
item1)
self.assertEqual(
self.history_mgr.get_owned(self.trans, item1.id, owner), item1)
self.log(
"should not raise an error when checking ownership with admin")
self.assertTrue(
self.history_mgr.is_owner(self.trans, item1, self.admin_user))
self.assertEqual(
self.history_mgr.error_unless_owner(self.trans, item1,
self.admin_user), item1)
self.assertEqual(
self.history_mgr.get_owned(self.trans, item1.id, self.admin_user),
item1)
def test_accessible(self):
owner = self.user_mgr.create(self.trans, **user2_data)
item1 = self.history_mgr.create(self.trans, user=owner)
non_owner = self.user_mgr.create(self.trans, **user3_data)
self.log("should be inaccessible by default except to owner")
self.assertTrue(
self.history_mgr.is_accessible(self.trans, item1, owner))
self.assertTrue(
self.history_mgr.is_accessible(self.trans, item1, self.admin_user))
self.assertFalse(
self.history_mgr.is_accessible(self.trans, item1, non_owner))
self.log(
"should raise an error when checking accessibility with non-owner")
self.assertRaises(exceptions.ItemAccessibilityException,
self.history_mgr.error_unless_accessible, self.trans,
item1, non_owner)
self.assertRaises(exceptions.ItemAccessibilityException,
self.history_mgr.get_accessible, self.trans,
item1.id, non_owner)
self.log(
"should not raise an error when checking ownership with owner")
self.assertEqual(
self.history_mgr.error_unless_accessible(self.trans, item1, owner),
item1)
self.assertEqual(
self.history_mgr.get_accessible(self.trans, item1.id, owner),
item1)
self.log(
"should not raise an error when checking ownership with admin")
self.assertTrue(
self.history_mgr.is_accessible(self.trans, item1, self.admin_user))
self.assertEqual(
self.history_mgr.error_unless_accessible(self.trans, item1,
self.admin_user), item1)
self.assertEqual(
self.history_mgr.get_accessible(self.trans, item1.id,
self.admin_user), item1)
def test_importable(self):
owner = self.user_mgr.create(self.trans, **user2_data)
self.trans.set_user(owner)
non_owner = self.user_mgr.create(self.trans, **user3_data)
item1 = self.history_mgr.create(self.trans, user=owner)
self.log("should not be importable by default")
self.assertFalse(item1.importable)
self.assertIsNone(item1.slug)
self.log(
"should be able to make importable (accessible by link) to all users"
)
accessible = self.history_mgr.make_importable(self.trans, item1)
self.assertEqual(accessible, item1)
self.assertIsNotNone(accessible.slug)
self.assertTrue(accessible.importable)
for user in self.user_mgr.list(self.trans):
self.assertTrue(
self.history_mgr.is_accessible(self.trans, accessible, user))
self.log("should be able to make non-importable/inaccessible again")
inaccessible = self.history_mgr.make_non_importable(
self.trans, accessible)
self.assertEqual(inaccessible, accessible)
self.assertIsNotNone(inaccessible.slug)
self.assertFalse(inaccessible.importable)
self.assertTrue(
self.history_mgr.is_accessible(self.trans, inaccessible, owner))
self.assertFalse(
self.history_mgr.is_accessible(self.trans, inaccessible,
non_owner))
self.assertTrue(
self.history_mgr.is_accessible(self.trans, inaccessible,
self.admin_user))
def test_published(self):
owner = self.user_mgr.create(self.trans, **user2_data)
self.trans.set_user(owner)
non_owner = self.user_mgr.create(self.trans, **user3_data)
item1 = self.history_mgr.create(self.trans, user=owner)
self.log("should not be published by default")
self.assertFalse(item1.published)
self.assertIsNone(item1.slug)
self.log("should be able to publish (listed publicly) to all users")
published = self.history_mgr.publish(self.trans, item1)
self.assertEqual(published, item1)
self.assertTrue(published.published)
# note: publishing sets importable to true as well
self.assertTrue(published.importable)
self.assertIsNotNone(published.slug)
for user in self.user_mgr.list(self.trans):
self.assertTrue(
self.history_mgr.is_accessible(self.trans, published, user))
self.log("should be able to make non-importable/inaccessible again")
unpublished = self.history_mgr.unpublish(self.trans, published)
self.assertEqual(unpublished, published)
self.assertFalse(unpublished.published)
# note: unpublishing does not make non-importable, you must explicitly do that separately
self.assertTrue(published.importable)
self.history_mgr.make_non_importable(self.trans, unpublished)
self.assertFalse(published.importable)
# note: slug still remains after unpublishing
self.assertIsNotNone(unpublished.slug)
self.assertTrue(
self.history_mgr.is_accessible(self.trans, unpublished, owner))
self.assertFalse(
self.history_mgr.is_accessible(self.trans, unpublished, non_owner))
self.assertTrue(
self.history_mgr.is_accessible(self.trans, unpublished,
self.admin_user))
def test_sharable(self):
owner = self.user_mgr.create(self.trans, **user2_data)
self.trans.set_user(owner)
item1 = self.history_mgr.create(self.trans, user=owner)
non_owner = self.user_mgr.create(self.trans, **user3_data)
#third_party = self.user_mgr.create( self.trans, **user4_data )
self.log("should be unshared by default")
self.assertEqual(self.history_mgr.get_share_assocs(self.trans, item1),
[])
self.assertEqual(item1.slug, None)
self.log("should be able to share with specific users")
share_assoc = self.history_mgr.share_with(self.trans, item1, non_owner)
self.assertIsInstance(share_assoc, model.HistoryUserShareAssociation)
self.assertTrue(
self.history_mgr.is_accessible(self.trans, item1, non_owner))
self.assertEqual(
len(self.history_mgr.get_share_assocs(self.trans, item1)), 1)
self.assertEqual(
len(
self.history_mgr.get_share_assocs(self.trans,
item1,
user=non_owner)), 1)
self.assertIsInstance(item1.slug, basestring)
self.log("should be able to unshare with specific users")
share_assoc = self.history_mgr.unshare_with(self.trans, item1,
non_owner)
self.assertIsInstance(share_assoc, model.HistoryUserShareAssociation)
self.assertFalse(
self.history_mgr.is_accessible(self.trans, item1, non_owner))
self.assertEqual(self.history_mgr.get_share_assocs(self.trans, item1),
[])
self.assertEqual(
self.history_mgr.get_share_assocs(self.trans,
item1,
user=non_owner), [])
#TODO: test slug formation
def test_anon(self):
anon_user = None
self.trans.set_user(anon_user)
self.log(
"should not allow access and owner for anon user on a history by another anon user (None)"
)
anon_history1 = self.history_mgr.create(self.trans, user=None)
self.assertFalse(
self.history_mgr.is_owner(self.trans, anon_history1, anon_user))
self.assertFalse(
self.history_mgr.is_accessible(self.trans, anon_history1,
anon_user))
self.log(
"should allow access and owner for anon user on a history if it's the session's current history"
)
anon_history2 = self.history_mgr.create(self.trans, user=anon_user)
self.trans.set_history(anon_history2)
self.assertTrue(
self.history_mgr.is_owner(self.trans, anon_history2, anon_user))
self.assertTrue(
self.history_mgr.is_accessible(self.trans, anon_history2,
anon_user))
self.log(
"should not allow owner or access for anon user on someone elses history"
)
owner = self.user_mgr.create(self.trans, **user2_data)
someone_elses = self.history_mgr.create(self.trans, user=owner)
self.assertFalse(
self.history_mgr.is_owner(self.trans, someone_elses, anon_user))
self.assertFalse(
self.history_mgr.is_accessible(self.trans, someone_elses,
anon_user))
self.log(
"should allow access for anon user if the history is published or importable"
)
self.history_mgr.make_importable(self.trans, someone_elses)
self.assertTrue(
self.history_mgr.is_accessible(self.trans, someone_elses,
anon_user))
self.history_mgr.publish(self.trans, someone_elses)
self.assertTrue(
self.history_mgr.is_accessible(self.trans, someone_elses,
anon_user))
def test_delete_and_purge(self):
user2 = self.user_mgr.create(self.trans, **user2_data)
self.trans.set_user(user2)
history1 = self.history_mgr.create(self.trans,
name='history1',
user=user2)
self.trans.set_history(history1)
self.assertFalse(history1.deleted)
self.history_mgr.delete(self.trans, history1)
self.assertTrue(history1.deleted)
self.history_mgr.undelete(self.trans, history1)
self.assertFalse(history1.deleted)
history2 = self.history_mgr.create(self.trans,
name='history2',
user=user2)
self.history_mgr.purge(self.trans, history1)
self.assertTrue(history1.purged)
def test_histories(self):
user2 = self.user_mgr.create(self.trans, **user2_data)
self.trans.set_user(user2)
history1 = self.history_mgr.create(self.trans,
name='history1',
user=user2)
self.trans.set_history(history1)
history2 = self.history_mgr.create(self.trans,
name='history2',
user=user2)
self.log("should be able to set or get the current history for a user")
self.assertEqual(self.history_mgr.get_current(self.trans), history1)
self.assertEqual(self.history_mgr.set_current(self.trans, history2),
history2)
self.assertEqual(self.history_mgr.get_current(self.trans), history2)
self.assertEqual(
self.history_mgr.set_current_by_id(self.trans, history1.id),
history1)
self.assertEqual(self.history_mgr.get_current(self.trans), history1)
class HistoryFiltersTestCase(BaseTestCase):
def set_up_managers(self):
super(HistoryFiltersTestCase, self).set_up_managers()
self.history_manager = HistoryManager(self.app)
self.filter_parser = HistoryFilters(self.app)
# ---- functional and orm filter splitting and resolution
def test_parse_filters(self):
filters = self.filter_parser.parse_filters([
('name', 'eq', 'wot'),
('deleted', 'eq', 'True'),
('annotation', 'has', 'hrrmm')
])
self.log('both orm and fn filters should be parsed and returned')
self.assertEqual(len(filters), 3)
self.log('values should be parsed')
self.assertIsInstance(filters[1].right, sqlalchemy.sql.elements.True_)
def test_parse_filters_invalid_filters(self):
self.log('should error on non-column attr')
self.assertRaises(exceptions.RequestParameterInvalidException, self.filter_parser.parse_filters, [
('merp', 'eq', 'wot'),
])
self.log('should error on non-whitelisted attr')
self.assertRaises(exceptions.RequestParameterInvalidException, self.filter_parser.parse_filters, [
('user_id', 'eq', 'wot'),
])
self.log('should error on non-whitelisted op')
self.assertRaises(exceptions.RequestParameterInvalidException, self.filter_parser.parse_filters, [
('name', 'lt', 'wot'),
])
self.log('should error on non-listed fn op')
self.assertRaises(exceptions.RequestParameterInvalidException, self.filter_parser.parse_filters, [
('annotation', 'like', 'wot'),
])
self.log('should error on val parsing error')
self.assertRaises(exceptions.RequestParameterInvalidException, self.filter_parser.parse_filters, [
('deleted', 'eq', 'true'),
])
def test_orm_filter_parsing(self):
user2 = self.user_manager.create(**user2_data)
history1 = self.history_manager.create(name='history1', user=user2)
history2 = self.history_manager.create(name='history2', user=user2)
history3 = self.history_manager.create(name='history3', user=user2)
filters = self.filter_parser.parse_filters([
('name', 'like', 'history%'),
])
histories = self.history_manager.list(filters=filters)
# for h in histories:
# print h.name
self.assertEqual(histories, [history1, history2, history3])
filters = self.filter_parser.parse_filters([('name', 'like', '%2'), ])
self.assertEqual(self.history_manager.list(filters=filters), [history2])
filters = self.filter_parser.parse_filters([('name', 'eq', 'history2'), ])
self.assertEqual(self.history_manager.list(filters=filters), [history2])
self.history_manager.update(history1, dict(deleted=True))
filters = self.filter_parser.parse_filters([('deleted', 'eq', 'True'), ])
self.assertEqual(self.history_manager.list(filters=filters), [history1])
filters = self.filter_parser.parse_filters([('deleted', 'eq', 'False'), ])
self.assertEqual(self.history_manager.list(filters=filters), [history2, history3])
self.assertEqual(self.history_manager.list(), [history1, history2, history3])
self.history_manager.update(history3, dict(deleted=True))
self.history_manager.update(history1, dict(importable=True))
self.history_manager.update(history2, dict(importable=True))
filters = self.filter_parser.parse_filters([
('deleted', 'eq', 'True'),
('importable', 'eq', 'True'),
])
self.assertEqual(self.history_manager.list(filters=filters), [history1])
self.assertEqual(self.history_manager.list(), [history1, history2, history3])
def test_fn_filter_parsing(self):
user2 = self.user_manager.create(**user2_data)
history1 = self.history_manager.create(name='history1', user=user2)
history2 = self.history_manager.create(name='history2', user=user2)
history3 = self.history_manager.create(name='history3', user=user2)
filters = self.filter_parser.parse_filters([('annotation', 'has', 'no play'), ])
anno_filter = filters[0]
history3.add_item_annotation(self.trans.sa_session, user2, history3, "All work and no play")
self.trans.sa_session.flush()
self.assertTrue(anno_filter(history3))
self.assertFalse(anno_filter(history2))
self.assertEqual(self.history_manager.list(filters=filters), [history3])
self.log('should allow combinations of orm and fn filters')
self.history_manager.update(history3, dict(importable=True))
self.history_manager.update(history2, dict(importable=True))
history1.add_item_annotation(self.trans.sa_session, user2, history1, "All work and no play")
self.trans.sa_session.flush()
shining_examples = self.history_manager.list(filters=self.filter_parser.parse_filters([
('importable', 'eq', 'True'),
('annotation', 'has', 'no play'),
]))
self.assertEqual(shining_examples, [history3])
def test_fn_filter_currying(self):
self.filter_parser.fn_filter_parsers = {
'name_len': {'op': {'lt': lambda i, v: len(i.name) < v}, 'val': int}
}
self.log('should be 2 filters now')
self.assertEqual(len(self.filter_parser.fn_filter_parsers), 1)
filters = self.filter_parser.parse_filters([
('name_len', 'lt', '4')
])
self.log('should have parsed out a single filter')
self.assertEqual(len(filters), 1)
filter_ = filters[0]
fake = galaxy_mock.OpenObject()
fake.name = '123'
self.log('123 should return true through the filter')
self.assertTrue(filter_(fake))
fake.name = '1234'
self.log('1234 should return false through the filter')
self.assertFalse(filter_(fake))
def test_list(self):
"""
Test limit and offset in conjunction with both orm and fn filtering.
"""
user2 = self.user_manager.create(**user2_data)
history1 = self.history_manager.create(name='history1', user=user2)
history2 = self.history_manager.create(name='history2', user=user2)
history3 = self.history_manager.create(name='history3', user=user2)
history4 = self.history_manager.create(name='history4', user=user2)
self.history_manager.delete(history1)
self.history_manager.delete(history2)
self.history_manager.delete(history3)
test_annotation = "testing"
history2.add_item_annotation(self.trans.sa_session, user2, history2, test_annotation)
self.trans.sa_session.flush()
history3.add_item_annotation(self.trans.sa_session, user2, history3, test_annotation)
self.trans.sa_session.flush()
history3.add_item_annotation(self.trans.sa_session, user2, history4, test_annotation)
self.trans.sa_session.flush()
all_histories = [history1, history2, history3, history4]
deleted_and_annotated = [history2, history3]
self.log("no offset, no limit should work")
self.assertEqual(self.history_manager.list(offset=None, limit=None), all_histories)
self.assertEqual(self.history_manager.list(), all_histories)
self.log("no offset, limit should work")
self.assertEqual(self.history_manager.list(limit=2), [history1, history2])
self.log("offset, no limit should work")
self.assertEqual(self.history_manager.list(offset=1), [history2, history3, history4])
self.log("offset, limit should work")
self.assertEqual(self.history_manager.list(offset=1, limit=1), [history2])
self.log("zero limit should return empty list")
self.assertEqual(self.history_manager.list(limit=0), [])
self.log("past len offset should return empty list")
self.assertEqual(self.history_manager.list(offset=len(all_histories)), [])
self.log("negative limit should return full list")
self.assertEqual(self.history_manager.list(limit=-1), all_histories)
self.log("negative offset should return full list")
self.assertEqual(self.history_manager.list(offset=-1), all_histories)
filters = [model.History.deleted == true()]
self.log("orm filtered, no offset, no limit should work")
found = self.history_manager.list(filters=filters)
self.assertEqual(found, [history1, history2, history3])
self.log("orm filtered, no offset, limit should work")
found = self.history_manager.list(filters=filters, limit=2)
self.assertEqual(found, [history1, history2])
self.log("orm filtered, offset, no limit should work")
found = self.history_manager.list(filters=filters, offset=1)
self.assertEqual(found, [history2, history3])
self.log("orm filtered, offset, limit should work")
found = self.history_manager.list(filters=filters, offset=1, limit=1)
self.assertEqual(found, [history2])
filters = self.filter_parser.parse_filters([('annotation', 'has', test_annotation)])
self.log("fn filtered, no offset, no limit should work")
found = self.history_manager.list(filters=filters)
self.assertEqual(found, [history2, history3, history4])
self.log("fn filtered, no offset, limit should work")
found = self.history_manager.list(filters=filters, limit=2)
self.assertEqual(found, [history2, history3])
self.log("fn filtered, offset, no limit should work")
found = self.history_manager.list(filters=filters, offset=1)
self.assertEqual(found, [history3, history4])
self.log("fn filtered, offset, limit should work")
found = self.history_manager.list(filters=filters, offset=1, limit=1)
self.assertEqual(found, [history3])
filters = self.filter_parser.parse_filters([
('deleted', 'eq', 'True'),
('annotation', 'has', test_annotation)
])
self.log("orm and fn filtered, no offset, no limit should work")
found = self.history_manager.list(filters=filters)
self.assertEqual(found, [history2, history3])
self.log("orm and fn filtered, no offset, limit should work")
found = self.history_manager.list(filters=filters, limit=1)
self.assertEqual(found, [history2])
self.log("orm and fn filtered, offset, no limit should work")
found = self.history_manager.list(filters=filters, offset=1)
self.assertEqual(found, [history3])
self.log("orm and fn filtered, offset, limit should work")
found = self.history_manager.list(filters=filters, offset=1, limit=1)
self.assertEqual(found, [history3])
self.log("orm and fn filtered, zero limit should return empty list")
found = self.history_manager.list(filters=filters, limit=0)
self.assertEqual(found, [])
self.log("orm and fn filtered, past len offset should return empty list")
found = self.history_manager.list(filters=filters, offset=len(deleted_and_annotated))
self.assertEqual(found, [])
self.log("orm and fn filtered, negative limit should return full list")
found = self.history_manager.list(filters=filters, limit=-1)
self.assertEqual(found, deleted_and_annotated)
self.log("orm and fn filtered, negative offset should return full list")
found = self.history_manager.list(filters=filters, offset=-1)
self.assertEqual(found, deleted_and_annotated)
class HistorySerializerTestCase(BaseTestCase):
def set_up_managers(self):
super(HistorySerializerTestCase, self).set_up_managers()
self.history_manager = HistoryManager(self.app)
self.hda_manager = hdas.HDAManager(self.app)
self.history_serializer = HistorySerializer(self.app)
def test_views(self):
user2 = self.user_manager.create(**user2_data)
history1 = self.history_manager.create(name='history1', user=user2)
self.log('should have a summary view')
summary_view = self.history_serializer.serialize_to_view(history1, view='summary')
self.assertKeys(summary_view, self.history_serializer.views['summary'])
self.log('should have a detailed view')
detailed_view = self.history_serializer.serialize_to_view(history1, view='detailed')
self.assertKeys(detailed_view, self.history_serializer.views['detailed'])
self.log('should have the summary view as default view')
default_view = self.history_serializer.serialize_to_view(history1, default_view='summary')
self.assertKeys(default_view, self.history_serializer.views['summary'])
self.log('should have a serializer for all serializable keys')
for key in self.history_serializer.serializable_keyset:
instantiated_attribute = getattr(history1, key, None)
if not ((key in self.history_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):
user2 = self.user_manager.create(**user2_data)
history1 = self.history_manager.create(name='history1', user=user2)
self.log('should be able to use keys with views')
serialized = self.history_serializer.serialize_to_view(history1,
view='summary', keys=['state_ids', 'user_id'])
self.assertKeys(serialized,
self.history_serializer.views['summary'] + ['state_ids', 'user_id'])
self.log('should be able to use keys on their own')
serialized = self.history_serializer.serialize_to_view(history1,
keys=['state_ids', 'user_id'])
self.assertKeys(serialized, ['state_ids', 'user_id'])
def test_sharable(self):
user2 = self.user_manager.create(**user2_data)
history1 = self.history_manager.create(name='history1', user=user2)
self.log('should have a serializer for all SharableModel keys')
sharable_attrs = ['user_id', 'username_and_slug', 'importable', 'published', 'slug']
serialized = self.history_serializer.serialize(history1, sharable_attrs)
self.assertKeys(serialized, sharable_attrs)
self.log('should return user_id for user with whom it\'s been shared if the requester is the owner')
non_owner = self.user_manager.create(**user3_data)
self.history_manager.share_with(history1, non_owner)
serialized = self.history_serializer.serialize(history1, ['users_shared_with'], user=user2)
self.assertKeys(serialized, ['users_shared_with'])
self.assertIsInstance(serialized['users_shared_with'], list)
self.assertEqual(serialized['users_shared_with'][0], self.app.security.encode_id(non_owner.id))
self.log('should not return users_shared_with if the requester is not the owner')
serialized = self.history_serializer.serialize(history1, ['users_shared_with'], user=non_owner)
self.assertFalse(hasattr(serialized, 'users_shared_with'))
def test_purgable(self):
user2 = self.user_manager.create(**user2_data)
history1 = self.history_manager.create(name='history1', user=user2)
self.log('deleted and purged should be returned in their default states')
keys = ['deleted', 'purged']
serialized = self.history_serializer.serialize(history1, keys)
self.assertEqual(serialized['deleted'], False)
self.assertEqual(serialized['purged'], False)
self.log('deleted and purged should return their current state')
self.history_manager.delete(history1)
serialized = self.history_serializer.serialize(history1, keys)
self.assertEqual(serialized['deleted'], True)
self.assertEqual(serialized['purged'], False)
self.history_manager.purge(history1)
serialized = self.history_serializer.serialize(history1, keys)
self.assertEqual(serialized['deleted'], True)
self.assertEqual(serialized['purged'], True)
def test_history_serializers(self):
user2 = self.user_manager.create(**user2_data)
history1 = self.history_manager.create(name='history1', user=user2)
all_keys = list(self.history_serializer.serializable_keyset)
serialized = self.history_serializer.serialize(history1, all_keys, user=user2)
self.log('everything serialized should be of the proper type')
self.assertIsInstance(serialized['size'], int)
self.assertIsInstance(serialized['nice_size'], string_types)
self.log('serialized should jsonify well')
self.assertIsJsonifyable(serialized)
def _history_state_from_states_and_deleted(self, user, hda_state_and_deleted_tuples):
history = self.history_manager.create(name='name', user=user)
for state, deleted in hda_state_and_deleted_tuples:
hda = self.hda_manager.create(history=history)
hda = self.hda_manager.update(hda, dict(state=state, deleted=deleted))
history_state = self.history_serializer.serialize(history, ['state'])['state']
return history_state
def test_state(self):
dataset_states = model.Dataset.states
user2 = self.user_manager.create(**user2_data)
ready_states = [(state, False) for state in [dataset_states.OK, dataset_states.OK]]
self.log('a history\'s serialized state should be running if any of its datasets are running')
self.assertEqual('running', self._history_state_from_states_and_deleted(user2,
ready_states + [(dataset_states.RUNNING, False)]))
self.assertEqual('running', self._history_state_from_states_and_deleted(user2,
ready_states + [(dataset_states.SETTING_METADATA, False)]))
self.assertEqual('running', self._history_state_from_states_and_deleted(user2,
ready_states + [(dataset_states.UPLOAD, False)]))
self.log('a history\'s serialized state should be queued if any of its datasets are queued')
self.assertEqual('queued', self._history_state_from_states_and_deleted(user2,
ready_states + [(dataset_states.QUEUED, False)]))
self.log('a history\'s serialized state should be error if any of its datasets are errored')
self.assertEqual('error', self._history_state_from_states_and_deleted(user2,
ready_states + [(dataset_states.ERROR, False)]))
self.assertEqual('error', self._history_state_from_states_and_deleted(user2,
ready_states + [(dataset_states.FAILED_METADATA, False)]))
self.log('a history\'s serialized state should be ok if *all* of its datasets are ok')
self.assertEqual('ok', self._history_state_from_states_and_deleted(user2, ready_states))
self.log('a history\'s serialized state should be not be affected by deleted datasets')
self.assertEqual('ok', self._history_state_from_states_and_deleted(user2,
ready_states + [(dataset_states.RUNNING, True)]))
def test_contents(self):
user2 = self.user_manager.create(**user2_data)
history1 = self.history_manager.create(name='history1', user=user2)
self.log('a history with no contents should be properly reflected in empty, etc.')
keys = ['empty', 'count', 'state_ids', 'state_details', 'state', 'hdas']
serialized = self.history_serializer.serialize(history1, keys)
self.assertEqual(serialized['state'], 'new')
self.assertEqual(serialized['empty'], True)
self.assertEqual(serialized['count'], 0)
self.assertEqual(sum(serialized['state_details'].values()), 0)
self.assertEqual(serialized['state_ids']['ok'], [])
self.assertIsInstance(serialized['hdas'], list)
self.log('a history with contents should be properly reflected in empty, etc.')
hda1 = self.hda_manager.create(history=history1, hid=1)
self.hda_manager.update(hda1, dict(state='ok'))
serialized = self.history_serializer.serialize(history1, keys)
self.assertEqual(serialized['state'], 'ok')
self.assertEqual(serialized['empty'], False)
self.assertEqual(serialized['count'], 1)
self.assertEqual(serialized['state_details']['ok'], 1)
self.assertIsInstance(serialized['state_ids']['ok'], list)
self.assertIsInstance(serialized['hdas'], list)
self.assertIsInstance(serialized['hdas'][0], string_types)
serialized = self.history_serializer.serialize(history1, ['contents'])
self.assertHasKeys(serialized['contents'][0], ['id', 'name', 'state', 'create_time'])
self.log('serialized should jsonify well')
self.assertIsJsonifyable(serialized)
def test_ratings(self):
user2 = self.user_manager.create(**user2_data)
user3 = self.user_manager.create(**user3_data)
manager = self.history_manager
serializer = self.history_serializer
item = manager.create(name='history1', user=user2)
self.log('serialization should reflect no ratings')
serialized = serializer.serialize(item, ['user_rating', 'community_rating'], user=user2)
self.assertEqual(serialized['user_rating'], None)
self.assertEqual(serialized['community_rating']['count'], 0)
self.assertEqual(serialized['community_rating']['average'], 0.0)
self.log('serialization should reflect ratings')
manager.rate(item, user2, 1)
manager.rate(item, user3, 4)
serialized = serializer.serialize(item, ['user_rating', 'community_rating'], user=user2)
self.assertEqual(serialized['user_rating'], 1)
self.assertEqual(serialized['community_rating']['count'], 2)
self.assertEqual(serialized['community_rating']['average'], 2.5)
self.assertIsJsonifyable(serialized)
self.log('serialization of user_rating without user should error')
self.assertRaises(base.ModelSerializingError,
serializer.serialize, item, ['user_rating'])
class HistoryManagerTestCase(BaseTestCase):
def set_up_managers(self):
super(HistoryManagerTestCase, self).set_up_managers()
self.history_manager = HistoryManager(self.app)
self.hda_manager = hdas.HDAManager(self.app)
def add_hda_to_history(self, history, **kwargs):
dataset = self.hda_manager.dataset_manager.create()
hda = self.hda_manager.create(history=history, dataset=dataset, **kwargs)
return hda
def test_base(self):
user2 = self.user_manager.create(**user2_data)
user3 = self.user_manager.create(**user3_data)
self.log("should be able to create a new history")
history1 = self.history_manager.create(name='history1', user=user2)
self.assertIsInstance(history1, model.History)
self.assertEqual(history1.name, 'history1')
self.assertEqual(history1.user, user2)
self.assertEqual(history1, self.trans.sa_session.query(model.History).get(history1.id))
self.assertEqual(history1,
self.trans.sa_session.query(model.History).filter(model.History.name == 'history1').one())
self.assertEqual(history1,
self.trans.sa_session.query(model.History).filter(model.History.user == user2).one())
history2 = self.history_manager.copy(history1, user=user3)
self.log("should be able to query")
histories = self.trans.sa_session.query(model.History).all()
self.assertEqual(self.history_manager.one(filters=(model.History.id == history1.id)), history1)
self.assertEqual(self.history_manager.list(), histories)
self.assertEqual(self.history_manager.by_id(history1.id), history1)
self.assertEqual(self.history_manager.by_ids([history2.id, history1.id]), [history2, history1])
self.log("should be able to limit and offset")
self.assertEqual(self.history_manager.list(limit=1), histories[0:1])
self.assertEqual(self.history_manager.list(offset=1), histories[1:])
self.assertEqual(self.history_manager.list(limit=1, offset=1), histories[1:2])
self.assertEqual(self.history_manager.list(limit=0), [])
self.assertEqual(self.history_manager.list(offset=3), [])
self.log("should be able to order")
history3 = self.history_manager.create(name="history3", user=user2)
name_first_then_time = (model.History.name, sqlalchemy.desc(model.History.create_time))
self.assertEqual(self.history_manager.list(order_by=name_first_then_time),
[history2, history1, history3])
def test_copy(self):
user2 = self.user_manager.create(**user2_data)
user3 = self.user_manager.create(**user3_data)
self.log("should be able to copy a history (and it's hdas)")
history1 = self.history_manager.create(name='history1', user=user2)
tags = [u'tag-one']
annotation = u'history annotation'
self.history_manager.set_tags(history1, tags, user=user2)
self.history_manager.annotate(history1, annotation, user=user2)
hda = self.add_hda_to_history(history1, name='wat')
hda_tags = [u'tag-one', u'tag-two']
hda_annotation = u'annotation'
self.hda_manager.set_tags(hda, hda_tags, user=user2)
self.hda_manager.annotate(hda, hda_annotation, user=user2)
history2 = self.history_manager.copy(history1, user=user3)
self.assertIsInstance(history2, model.History)
self.assertEqual(history2.user, user3)
self.assertEqual(history2, self.trans.sa_session.query(model.History).get(history2.id))
self.assertEqual(history2.name, history1.name)
self.assertNotEqual(history2, history1)
copied_hda = history2.datasets[0]
copied_hda_tags = self.hda_manager.get_tags(copied_hda)
self.assertEqual(sorted(hda_tags), sorted(copied_hda_tags))
copied_hda_annotation = self.hda_manager.annotation(copied_hda)
self.assertEqual(hda_annotation, copied_hda_annotation)
def test_has_user(self):
owner = self.user_manager.create(**user2_data)
non_owner = self.user_manager.create(**user3_data)
item1 = self.history_manager.create(user=owner)
item2 = self.history_manager.create(user=owner)
self.history_manager.create(user=non_owner)
self.log("should be able to list items by user")
user_histories = self.history_manager.by_user(owner)
self.assertEqual(user_histories, [item1, item2])
def test_ownable(self):
owner = self.user_manager.create(**user2_data)
non_owner = self.user_manager.create(**user3_data)
item1 = self.history_manager.create(user=owner)
self.log("should be able to poll whether a given user owns an item")
self.assertTrue(self.history_manager.is_owner(item1, owner))
self.assertFalse(self.history_manager.is_owner(item1, non_owner))
self.log("should raise an error when checking ownership with non-owner")
self.assertRaises(exceptions.ItemOwnershipException,
self.history_manager.error_unless_owner, item1, non_owner)
self.assertRaises(exceptions.ItemOwnershipException,
self.history_manager.get_owned, item1.id, non_owner)
self.log("should not raise an error when checking ownership with owner")
self.assertEqual(self.history_manager.error_unless_owner(item1, owner), item1)
self.assertEqual(self.history_manager.get_owned(item1.id, owner), item1)
self.log("should not raise an error when checking ownership with admin")
self.assertTrue(self.history_manager.is_owner(item1, self.admin_user))
self.assertEqual(self.history_manager.error_unless_owner(item1, self.admin_user), item1)
self.assertEqual(self.history_manager.get_owned(item1.id, self.admin_user), item1)
def test_accessible(self):
owner = self.user_manager.create(**user2_data)
item1 = self.history_manager.create(user=owner)
non_owner = self.user_manager.create(**user3_data)
self.log("should be inaccessible by default except to owner")
self.assertTrue(self.history_manager.is_accessible(item1, owner))
self.assertTrue(self.history_manager.is_accessible(item1, self.admin_user))
self.assertFalse(self.history_manager.is_accessible(item1, non_owner))
self.log("should raise an error when checking accessibility with non-owner")
self.assertRaises(exceptions.ItemAccessibilityException,
self.history_manager.error_unless_accessible, item1, non_owner)
self.assertRaises(exceptions.ItemAccessibilityException,
self.history_manager.get_accessible, item1.id, non_owner)
self.log("should not raise an error when checking ownership with owner")
self.assertEqual(self.history_manager.error_unless_accessible(item1, owner), item1)
self.assertEqual(self.history_manager.get_accessible(item1.id, owner), item1)
self.log("should not raise an error when checking ownership with admin")
self.assertTrue(self.history_manager.is_accessible(item1, self.admin_user))
self.assertEqual(self.history_manager.error_unless_accessible(item1, self.admin_user), item1)
self.assertEqual(self.history_manager.get_accessible(item1.id, self.admin_user), item1)
def test_importable(self):
owner = self.user_manager.create(**user2_data)
self.trans.set_user(owner)
non_owner = self.user_manager.create(**user3_data)
item1 = self.history_manager.create(user=owner)
self.log("should not be importable by default")
self.assertFalse(item1.importable)
self.assertIsNone(item1.slug)
self.log("should be able to make importable (accessible by link) to all users")
accessible = self.history_manager.make_importable(item1)
self.assertEqual(accessible, item1)
self.assertIsNotNone(accessible.slug)
self.assertTrue(accessible.importable)
for user in self.user_manager.list():
self.assertTrue(self.history_manager.is_accessible(accessible, user))
self.log("should be able to make non-importable/inaccessible again")
inaccessible = self.history_manager.make_non_importable(accessible)
self.assertEqual(inaccessible, accessible)
self.assertIsNotNone(inaccessible.slug)
self.assertFalse(inaccessible.importable)
self.assertTrue(self.history_manager.is_accessible(inaccessible, owner))
self.assertFalse(self.history_manager.is_accessible(inaccessible, non_owner))
self.assertTrue(self.history_manager.is_accessible(inaccessible, self.admin_user))
def test_published(self):
owner = self.user_manager.create(**user2_data)
self.trans.set_user(owner)
non_owner = self.user_manager.create(**user3_data)
item1 = self.history_manager.create(user=owner)
self.log("should not be published by default")
self.assertFalse(item1.published)
self.assertIsNone(item1.slug)
self.log("should be able to publish (listed publicly) to all users")
published = self.history_manager.publish(item1)
self.assertEqual(published, item1)
self.assertTrue(published.published)
# note: publishing sets importable to true as well
self.assertTrue(published.importable)
self.assertIsNotNone(published.slug)
for user in self.user_manager.list():
self.assertTrue(self.history_manager.is_accessible(published, user))
self.log("should be able to make non-importable/inaccessible again")
unpublished = self.history_manager.unpublish(published)
self.assertEqual(unpublished, published)
self.assertFalse(unpublished.published)
# note: unpublishing does not make non-importable, you must explicitly do that separately
self.assertTrue(published.importable)
self.history_manager.make_non_importable(unpublished)
self.assertFalse(published.importable)
# note: slug still remains after unpublishing
self.assertIsNotNone(unpublished.slug)
self.assertTrue(self.history_manager.is_accessible(unpublished, owner))
self.assertFalse(self.history_manager.is_accessible(unpublished, non_owner))
self.assertTrue(self.history_manager.is_accessible(unpublished, self.admin_user))
def test_sharable(self):
owner = self.user_manager.create(**user2_data)
self.trans.set_user(owner)
item1 = self.history_manager.create(user=owner)
non_owner = self.user_manager.create(**user3_data)
# third_party = self.user_manager.create( **user4_data )
self.log("should be unshared by default")
self.assertEqual(self.history_manager.get_share_assocs(item1), [])
self.assertEqual(item1.slug, None)
self.log("should be able to share with specific users")
share_assoc = self.history_manager.share_with(item1, non_owner)
self.assertIsInstance(share_assoc, model.HistoryUserShareAssociation)
self.assertTrue(self.history_manager.is_accessible(item1, non_owner))
self.assertEqual(
len(self.history_manager.get_share_assocs(item1)), 1)
self.assertEqual(
len(self.history_manager.get_share_assocs(item1, user=non_owner)), 1)
self.assertIsInstance(item1.slug, string_types)
self.log("should be able to unshare with specific users")
share_assoc = self.history_manager.unshare_with(item1, non_owner)
self.assertIsInstance(share_assoc, model.HistoryUserShareAssociation)
self.assertFalse(self.history_manager.is_accessible(item1, non_owner))
self.assertEqual(self.history_manager.get_share_assocs(item1), [])
self.assertEqual(
self.history_manager.get_share_assocs(item1, user=non_owner), [])
# TODO: test slug formation
def test_anon(self):
anon_user = None
self.trans.set_user(anon_user)
self.log("should not allow access and owner for anon user on a history by another anon user (None)")
anon_history1 = self.history_manager.create(user=None)
# do not set the trans.history!
self.assertFalse(self.history_manager.is_owner(anon_history1, anon_user, current_history=self.trans.history))
self.assertFalse(self.history_manager.is_accessible(anon_history1, anon_user, current_history=self.trans.history))
self.log("should allow access and owner for anon user on a history if it's the session's current history")
anon_history2 = self.history_manager.create(user=anon_user)
self.trans.set_history(anon_history2)
self.assertTrue(self.history_manager.is_owner(anon_history2, anon_user, current_history=self.trans.history))
self.assertTrue(self.history_manager.is_accessible(anon_history2, anon_user, current_history=self.trans.history))
self.log("should not allow owner or access for anon user on someone elses history")
owner = self.user_manager.create(**user2_data)
someone_elses = self.history_manager.create(user=owner)
self.assertFalse(self.history_manager.is_owner(someone_elses, anon_user, current_history=self.trans.history))
self.assertFalse(self.history_manager.is_accessible(someone_elses, anon_user, current_history=self.trans.history))
self.log("should allow access for anon user if the history is published or importable")
self.history_manager.make_importable(someone_elses)
self.assertTrue(self.history_manager.is_accessible(someone_elses, anon_user, current_history=self.trans.history))
self.history_manager.publish(someone_elses)
self.assertTrue(self.history_manager.is_accessible(someone_elses, anon_user, current_history=self.trans.history))
def test_delete_and_purge(self):
user2 = self.user_manager.create(**user2_data)
self.trans.set_user(user2)
history1 = self.history_manager.create(name='history1', user=user2)
self.trans.set_history(history1)
self.log("should allow deletion and undeletion")
self.assertFalse(history1.deleted)
self.history_manager.delete(history1)
self.assertTrue(history1.deleted)
self.history_manager.undelete(history1)
self.assertFalse(history1.deleted)
self.log("should allow purging")
history2 = self.history_manager.create(name='history2', user=user2)
self.history_manager.purge(history2)
self.assertTrue(history2.deleted)
self.assertTrue(history2.purged)
def test_current(self):
user2 = self.user_manager.create(**user2_data)
self.trans.set_user(user2)
history1 = self.history_manager.create(name='history1', user=user2)
self.trans.set_history(history1)
history2 = self.history_manager.create(name='history2', user=user2)
self.log("should be able to set or get the current history for a user")
self.assertEqual(self.history_manager.get_current(self.trans), history1)
self.assertEqual(self.history_manager.set_current(self.trans, history2), history2)
self.assertEqual(self.history_manager.get_current(self.trans), history2)
self.assertEqual(self.history_manager.set_current_by_id(self.trans, history1.id), history1)
self.assertEqual(self.history_manager.get_current(self.trans), history1)
def test_most_recently_used(self):
user2 = self.user_manager.create(**user2_data)
self.trans.set_user(user2)
history1 = self.history_manager.create(name='history1', user=user2)
self.trans.set_history(history1)
history2 = self.history_manager.create(name='history2', user=user2)
self.log("should be able to get the most recently used (updated) history for a given user")
self.assertEqual(self.history_manager.most_recent(user2), history2)
self.history_manager.update(history1, {'name': 'new name'})
self.assertEqual(self.history_manager.most_recent(user2), history1)
def test_rating(self):
user2 = self.user_manager.create(**user2_data)
manager = self.history_manager
item = manager.create(name='history1', user=user2)
self.log("should properly handle no ratings")
self.assertEqual(manager.rating(item, user2), None)
self.assertEqual(manager.ratings(item), [])
self.assertEqual(manager.ratings_avg(item), 0)
self.assertEqual(manager.ratings_count(item), 0)
self.log("should allow rating by user")
manager.rate(item, user2, 5)
self.assertEqual(manager.rating(item, user2), 5)
self.assertEqual(manager.ratings(item), [5])
self.assertEqual(manager.ratings_avg(item), 5)
self.assertEqual(manager.ratings_count(item), 1)
self.log("should allow updating")
manager.rate(item, user2, 4)
self.assertEqual(manager.rating(item, user2), 4)
self.assertEqual(manager.ratings(item), [4])
self.assertEqual(manager.ratings_avg(item), 4)
self.assertEqual(manager.ratings_count(item), 1)
self.log("should reflect multiple reviews")
user3 = self.user_manager.create(**user3_data)
self.assertEqual(manager.rating(item, user3), None)
manager.rate(item, user3, 1)
self.assertEqual(manager.rating(item, user3), 1)
self.assertEqual(manager.ratings(item), [4, 1])
self.assertEqual(manager.ratings_avg(item), 2.5)
self.assertEqual(manager.ratings_count(item), 2)
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 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 HistoryManagerTestCase( BaseTestCase ):
def set_up_managers( self ):
super( HistoryManagerTestCase, self ).set_up_managers()
self.history_mgr = HistoryManager( self.app )
def test_base( self ):
user2 = self.user_mgr.create( self.trans, **user2_data )
user3 = self.user_mgr.create( self.trans, **user3_data )
self.log( "should be able to create a new history" )
history1 = self.history_mgr.create( self.trans, name='history1', user=user2 )
self.assertIsInstance( history1, model.History )
self.assertEqual( history1.name, 'history1' )
self.assertEqual( history1.user, user2 )
self.assertEqual( history1, self.trans.sa_session.query( model.History ).get( history1.id ) )
self.assertEqual( history1,
self.trans.sa_session.query( model.History ).filter( model.History.name == 'history1' ).one() )
self.assertEqual( history1,
self.trans.sa_session.query( model.History ).filter( model.History.user == user2 ).one() )
self.log( "should be able to copy a history" )
history2 = self.history_mgr.copy( self.trans, history1, user=user3 )
self.assertIsInstance( history2, model.History )
self.assertEqual( history2.user, user3 )
self.assertEqual( history2, self.trans.sa_session.query( model.History ).get( history2.id ) )
self.assertEqual( history2.name, history1.name )
self.assertNotEqual( history2, history1 )
self.log( "should be able to query" )
histories = self.trans.sa_session.query( model.History ).all()
self.assertEqual( self.history_mgr.one( self.trans, filters=( model.History.id == history1.id ) ), history1 )
self.assertEqual( self.history_mgr.list( self.trans ), histories )
self.assertEqual( self.history_mgr.by_id( self.trans, history1.id ), history1 )
self.assertEqual( self.history_mgr.by_ids( self.trans, [ history2.id, history1.id ] ), [ history2, history1 ] )
self.log( "should be able to limit and offset" )
self.assertEqual( self.history_mgr.list( self.trans, limit=1 ), histories[0:1] )
self.assertEqual( self.history_mgr.list( self.trans, offset=1 ), histories[1:] )
self.assertEqual( self.history_mgr.list( self.trans, limit=1, offset=1 ), histories[1:2] )
self.assertEqual( self.history_mgr.list( self.trans, limit=0 ), [] )
self.assertEqual( self.history_mgr.list( self.trans, offset=3 ), [] )
self.log( "should be able to order" )
history3 = self.history_mgr.create( self.trans, name="history3", user=user2 )
name_first_then_time = ( model.History.name, sqlalchemy.desc( model.History.create_time ) )
self.assertEqual( self.history_mgr.list( self.trans, order_by=name_first_then_time ),
[ history2, history1, history3 ] )
def test_has_user( self ):
owner = self.user_mgr.create( self.trans, **user2_data )
non_owner = self.user_mgr.create( self.trans, **user3_data )
item1 = self.history_mgr.create( self.trans, user=owner )
item2 = self.history_mgr.create( self.trans, user=owner )
item3 = self.history_mgr.create( self.trans, user=non_owner )
self.log( "should be able to list items by user" )
user_histories = self.history_mgr.by_user( self.trans, owner )
self.assertEqual( user_histories, [ item1, item2 ] )
def test_ownable( self ):
owner = self.user_mgr.create( self.trans, **user2_data )
non_owner = self.user_mgr.create( self.trans, **user3_data )
item1 = self.history_mgr.create( self.trans, user=owner )
self.log( "should be able to poll whether a given user owns an item" )
self.assertTrue( self.history_mgr.is_owner( self.trans, item1, owner ) )
self.assertFalse( self.history_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.history_mgr.error_unless_owner, self.trans, item1, non_owner )
self.assertRaises( exceptions.ItemOwnershipException,
self.history_mgr.get_owned, self.trans, item1.id, non_owner )
self.log( "should not raise an error when checking ownership with owner" )
self.assertEqual( self.history_mgr.error_unless_owner( self.trans, item1, owner ), item1 )
self.assertEqual( self.history_mgr.get_owned( self.trans, item1.id, owner ), item1 )
self.log( "should not raise an error when checking ownership with admin" )
self.assertTrue( self.history_mgr.is_owner( self.trans, item1, self.admin_user ) )
self.assertEqual( self.history_mgr.error_unless_owner( self.trans, item1, self.admin_user ), item1 )
self.assertEqual( self.history_mgr.get_owned( self.trans, item1.id, self.admin_user ), item1 )
def test_accessible( self ):
owner = self.user_mgr.create( self.trans, **user2_data )
item1 = self.history_mgr.create( self.trans, user=owner )
non_owner = self.user_mgr.create( self.trans, **user3_data )
self.log( "should be inaccessible by default except to owner" )
self.assertTrue( self.history_mgr.is_accessible( self.trans, item1, owner ) )
self.assertTrue( self.history_mgr.is_accessible( self.trans, item1, self.admin_user ) )
self.assertFalse( self.history_mgr.is_accessible( self.trans, item1, non_owner ) )
self.log( "should raise an error when checking accessibility with non-owner" )
self.assertRaises( exceptions.ItemAccessibilityException,
self.history_mgr.error_unless_accessible, self.trans, item1, non_owner )
self.assertRaises( exceptions.ItemAccessibilityException,
self.history_mgr.get_accessible, self.trans, item1.id, non_owner )
self.log( "should not raise an error when checking ownership with owner" )
self.assertEqual( self.history_mgr.error_unless_accessible( self.trans, item1, owner ), item1 )
self.assertEqual( self.history_mgr.get_accessible( self.trans, item1.id, owner ), item1 )
self.log( "should not raise an error when checking ownership with admin" )
self.assertTrue( self.history_mgr.is_accessible( self.trans, item1, self.admin_user ) )
self.assertEqual( self.history_mgr.error_unless_accessible( self.trans, item1, self.admin_user ), item1 )
self.assertEqual( self.history_mgr.get_accessible( self.trans, item1.id, self.admin_user ), item1 )
def test_importable( self ):
owner = self.user_mgr.create( self.trans, **user2_data )
self.trans.set_user( owner )
non_owner = self.user_mgr.create( self.trans, **user3_data )
item1 = self.history_mgr.create( self.trans, user=owner )
self.log( "should not be importable by default" )
self.assertFalse( item1.importable )
self.assertIsNone( item1.slug )
self.log( "should be able to make importable (accessible by link) to all users" )
accessible = self.history_mgr.make_importable( self.trans, item1 )
self.assertEqual( accessible, item1 )
self.assertIsNotNone( accessible.slug )
self.assertTrue( accessible.importable )
for user in self.user_mgr.list( self.trans ):
self.assertTrue( self.history_mgr.is_accessible( self.trans, accessible, user ) )
self.log( "should be able to make non-importable/inaccessible again" )
inaccessible = self.history_mgr.make_non_importable( self.trans, accessible )
self.assertEqual( inaccessible, accessible )
self.assertIsNotNone( inaccessible.slug )
self.assertFalse( inaccessible.importable )
self.assertTrue( self.history_mgr.is_accessible( self.trans, inaccessible, owner ) )
self.assertFalse( self.history_mgr.is_accessible( self.trans, inaccessible, non_owner ) )
self.assertTrue( self.history_mgr.is_accessible( self.trans, inaccessible, self.admin_user ) )
def test_published( self ):
owner = self.user_mgr.create( self.trans, **user2_data )
self.trans.set_user( owner )
non_owner = self.user_mgr.create( self.trans, **user3_data )
item1 = self.history_mgr.create( self.trans, user=owner )
self.log( "should not be published by default" )
self.assertFalse( item1.published )
self.assertIsNone( item1.slug )
self.log( "should be able to publish (listed publicly) to all users" )
published = self.history_mgr.publish( self.trans, item1 )
self.assertEqual( published, item1 )
self.assertTrue( published.published )
# note: publishing sets importable to true as well
self.assertTrue( published.importable )
self.assertIsNotNone( published.slug )
for user in self.user_mgr.list( self.trans ):
self.assertTrue( self.history_mgr.is_accessible( self.trans, published, user ) )
self.log( "should be able to make non-importable/inaccessible again" )
unpublished = self.history_mgr.unpublish( self.trans, published )
self.assertEqual( unpublished, published )
self.assertFalse( unpublished.published )
# note: unpublishing does not make non-importable, you must explicitly do that separately
self.assertTrue( published.importable )
self.history_mgr.make_non_importable( self.trans, unpublished )
self.assertFalse( published.importable )
# note: slug still remains after unpublishing
self.assertIsNotNone( unpublished.slug )
self.assertTrue( self.history_mgr.is_accessible( self.trans, unpublished, owner ) )
self.assertFalse( self.history_mgr.is_accessible( self.trans, unpublished, non_owner ) )
self.assertTrue( self.history_mgr.is_accessible( self.trans, unpublished, self.admin_user ) )
def test_sharable( self ):
owner = self.user_mgr.create( self.trans, **user2_data )
self.trans.set_user( owner )
item1 = self.history_mgr.create( self.trans, user=owner )
non_owner = self.user_mgr.create( self.trans, **user3_data )
#third_party = self.user_mgr.create( self.trans, **user4_data )
self.log( "should be unshared by default" )
self.assertEqual( self.history_mgr.get_share_assocs( self.trans, item1 ), [] )
self.assertEqual( item1.slug, None )
self.log( "should be able to share with specific users" )
share_assoc = self.history_mgr.share_with( self.trans, item1, non_owner )
self.assertIsInstance( share_assoc, model.HistoryUserShareAssociation )
self.assertTrue( self.history_mgr.is_accessible( self.trans, item1, non_owner ) )
self.assertEqual(
len( self.history_mgr.get_share_assocs( self.trans, item1 ) ), 1 )
self.assertEqual(
len( self.history_mgr.get_share_assocs( self.trans, item1, user=non_owner ) ), 1 )
self.assertIsInstance( item1.slug, basestring )
self.log( "should be able to unshare with specific users" )
share_assoc = self.history_mgr.unshare_with( self.trans, item1, non_owner )
self.assertIsInstance( share_assoc, model.HistoryUserShareAssociation )
self.assertFalse( self.history_mgr.is_accessible( self.trans, item1, non_owner ) )
self.assertEqual( self.history_mgr.get_share_assocs( self.trans, item1 ), [] )
self.assertEqual(
self.history_mgr.get_share_assocs( self.trans, item1, user=non_owner ), [] )
#TODO: test slug formation
def test_anon( self ):
anon_user = None
self.trans.set_user( anon_user )
self.log( "should not allow access and owner for anon user on a history by another anon user (None)" )
anon_history1 = self.history_mgr.create( self.trans, user=None )
self.assertFalse( self.history_mgr.is_owner( self.trans, anon_history1, anon_user ) )
self.assertFalse( self.history_mgr.is_accessible( self.trans, anon_history1, anon_user ) )
self.log( "should allow access and owner for anon user on a history if it's the session's current history" )
anon_history2 = self.history_mgr.create( self.trans, user=anon_user )
self.trans.set_history( anon_history2 )
self.assertTrue( self.history_mgr.is_owner( self.trans, anon_history2, anon_user ) )
self.assertTrue( self.history_mgr.is_accessible( self.trans, anon_history2, anon_user ) )
self.log( "should not allow owner or access for anon user on someone elses history" )
owner = self.user_mgr.create( self.trans, **user2_data )
someone_elses = self.history_mgr.create( self.trans, user=owner )
self.assertFalse( self.history_mgr.is_owner( self.trans, someone_elses, anon_user ) )
self.assertFalse( self.history_mgr.is_accessible( self.trans, someone_elses, anon_user ) )
self.log( "should allow access for anon user if the history is published or importable" )
self.history_mgr.make_importable( self.trans, someone_elses )
self.assertTrue( self.history_mgr.is_accessible( self.trans, someone_elses, anon_user ) )
self.history_mgr.publish( self.trans, someone_elses )
self.assertTrue( self.history_mgr.is_accessible( self.trans, someone_elses, anon_user ) )
def test_delete_and_purge( self ):
user2 = self.user_mgr.create( self.trans, **user2_data )
self.trans.set_user( user2 )
history1 = self.history_mgr.create( self.trans, name='history1', user=user2 )
self.trans.set_history( history1 )
self.assertFalse( history1.deleted )
self.history_mgr.delete( self.trans, history1 )
self.assertTrue( history1.deleted )
self.history_mgr.undelete( self.trans, history1 )
self.assertFalse( history1.deleted )
history2 = self.history_mgr.create( self.trans, name='history2', user=user2 )
self.history_mgr.purge( self.trans, history1 )
self.assertTrue( history1.purged )
def test_histories( self ):
user2 = self.user_mgr.create( self.trans, **user2_data )
self.trans.set_user( user2 )
history1 = self.history_mgr.create( self.trans, name='history1', user=user2 )
self.trans.set_history( history1 )
history2 = self.history_mgr.create( self.trans, name='history2', user=user2 )
self.log( "should be able to set or get the current history for a user" )
self.assertEqual( self.history_mgr.get_current( self.trans ), history1 )
self.assertEqual( self.history_mgr.set_current( self.trans, history2 ), history2 )
self.assertEqual( self.history_mgr.get_current( self.trans ), history2 )
self.assertEqual( self.history_mgr.set_current_by_id( self.trans, history1.id ), history1 )
self.assertEqual( self.history_mgr.get_current( self.trans ), history1 )
class HistorySerializerTestCase( BaseTestCase ):
def set_up_managers( self ):
super( HistorySerializerTestCase, self ).set_up_managers()
self.history_mgr = HistoryManager( self.app )
self.hda_mgr = hdas.HDAManager( self.app )
self.history_serializer = HistorySerializer( self.app )
def test_views( self ):
user2 = self.user_mgr.create( self.trans, **user2_data )
history1 = self.history_mgr.create( self.trans, name='history1', user=user2 )
self.log( 'should have a summary view' )
summary_view = self.history_serializer.serialize_to_view( self.trans, history1, view='summary' )
self.assertKeys( summary_view, self.history_serializer.views[ 'summary' ] )
self.log( 'should have a detailed view' )
detailed_view = self.history_serializer.serialize_to_view( self.trans, history1, view='detailed' )
self.assertKeys( detailed_view, self.history_serializer.views[ 'detailed' ] )
self.log( 'should have the summary view as default view' )
default_view = self.history_serializer.serialize_to_view( self.trans, history1, default_view='summary' )
self.assertKeys( summary_view, self.history_serializer.views[ 'summary' ] )
self.log( 'should have a serializer for all serializable keys' )
need_no_serializers = ( basestring, bool, type( None ) )
for key in self.history_serializer.serializable_keyset:
instantiated_attribute = getattr( history1, key, None )
if not ( ( key in self.history_serializer.serializers )
or ( isinstance( instantiated_attribute, need_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 ):
user2 = self.user_mgr.create( self.trans, **user2_data )
history1 = self.history_mgr.create( self.trans, name='history1', user=user2 )
self.log( 'should be able to use keys with views' )
serialized = self.history_serializer.serialize_to_view( self.trans, history1,
view='summary', keys=[ 'state_ids', 'user_id' ] )
self.assertKeys( serialized,
self.history_serializer.views[ 'summary' ] + [ 'state_ids', 'user_id' ] )
self.log( 'should be able to use keys on their own' )
serialized = self.history_serializer.serialize_to_view( self.trans, history1,
keys=[ 'state_ids', 'user_id' ] )
self.assertKeys( serialized, [ 'state_ids', 'user_id' ] )
def test_sharable( self ):
user2 = self.user_mgr.create( self.trans, **user2_data )
history1 = self.history_mgr.create( self.trans, name='history1', user=user2 )
self.log( 'should have a serializer for all SharableModel keys' )
sharable_attrs = [ 'user_id', 'username_and_slug', 'importable', 'published', 'slug' ]
serialized = self.history_serializer.serialize( self.trans, history1, sharable_attrs )
self.assertKeys( serialized, sharable_attrs )
def test_purgable( self ):
user2 = self.user_mgr.create( self.trans, **user2_data )
history1 = self.history_mgr.create( self.trans, name='history1', user=user2 )
self.log( 'deleted and purged should be returned in their default states' )
keys = [ 'deleted', 'purged' ]
serialized = self.history_serializer.serialize( self.trans, history1, keys )
self.assertEqual( serialized[ 'deleted' ], False )
self.assertEqual( serialized[ 'purged' ], False )
self.log( 'deleted and purged should return their current state' )
self.history_mgr.delete( self.trans, history1 )
serialized = self.history_serializer.serialize( self.trans, history1, keys )
self.assertEqual( serialized[ 'deleted' ], True )
self.assertEqual( serialized[ 'purged' ], False )
self.history_mgr.purge( self.trans, history1 )
serialized = self.history_serializer.serialize( self.trans, history1, keys )
self.assertEqual( serialized[ 'deleted' ], True )
self.assertEqual( serialized[ 'purged' ], True )
def test_history_serializers( self ):
user2 = self.user_mgr.create( self.trans, **user2_data )
history1 = self.history_mgr.create( self.trans, name='history1', user=user2 )
serialized = self.history_serializer.serialize( self.trans, history1, [ 'size', 'nice_size' ])
self.assertIsInstance( serialized[ 'size' ], int )
self.assertIsInstance( serialized[ 'nice_size' ], basestring )
def test_contents( self ):
user2 = self.user_mgr.create( self.trans, **user2_data )
history1 = self.history_mgr.create( self.trans, name='history1', user=user2 )
self.log( 'a history with no contents should be properly reflected in empty, etc.' )
keys = [ 'empty', 'count', 'state_ids', 'state_details', 'state', 'hdas' ]
serialized = self.history_serializer.serialize( self.trans, history1, keys )
self.assertEqual( serialized[ 'state' ], 'new' )
self.assertEqual( serialized[ 'empty' ], True )
self.assertEqual( serialized[ 'count' ], 0 )
self.assertEqual( sum( serialized[ 'state_details' ].values() ), 0 )
self.assertEqual( serialized[ 'state_ids' ][ 'ok' ], [] )
self.assertIsInstance( serialized[ 'hdas' ], list )
self.log( 'a history with contents should be properly reflected in empty, etc.' )
hda1 = self.hda_mgr.create( self.trans, history=history1, hid=1 )
self.hda_mgr.update( self.trans, hda1, dict( state='ok' ) )
serialized = self.history_serializer.serialize( self.trans, history1, keys )
self.assertEqual( serialized[ 'state' ], 'ok' )
self.assertEqual( serialized[ 'empty' ], False )
self.assertEqual( serialized[ 'count' ], 1 )
self.assertEqual( serialized[ 'state_details' ][ 'ok' ], 1 )
self.assertIsInstance( serialized[ 'state_ids' ][ 'ok' ], list )
self.assertIsInstance( serialized[ 'hdas' ], list )
self.assertIsInstance( serialized[ 'hdas' ][0], basestring )
serialized = self.history_serializer.serialize( self.trans, history1, [ 'contents' ] )
self.assertHasKeys( serialized[ 'contents' ][0], [ 'id', 'name', 'peek', 'create_time' ])
class HistorySerializerTestCase(BaseTestCase):
def set_up_managers(self):
super(HistorySerializerTestCase, self).set_up_managers()
self.history_mgr = HistoryManager(self.app)
self.hda_mgr = hdas.HDAManager(self.app)
self.history_serializer = HistorySerializer(self.app)
def test_views(self):
user2 = self.user_mgr.create(self.trans, **user2_data)
history1 = self.history_mgr.create(self.trans,
name='history1',
user=user2)
self.log('should have a summary view')
summary_view = self.history_serializer.serialize_to_view(
self.trans, history1, view='summary')
self.assertKeys(summary_view, self.history_serializer.views['summary'])
self.log('should have a detailed view')
detailed_view = self.history_serializer.serialize_to_view(
self.trans, history1, view='detailed')
self.assertKeys(detailed_view,
self.history_serializer.views['detailed'])
self.log('should have the summary view as default view')
default_view = self.history_serializer.serialize_to_view(
self.trans, history1, default_view='summary')
self.assertKeys(summary_view, self.history_serializer.views['summary'])
self.log('should have a serializer for all serializable keys')
need_no_serializers = (basestring, bool, type(None))
for key in self.history_serializer.serializable_keyset:
instantiated_attribute = getattr(history1, key, None)
if not ((key in self.history_serializer.serializers) or
(isinstance(instantiated_attribute, need_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):
user2 = self.user_mgr.create(self.trans, **user2_data)
history1 = self.history_mgr.create(self.trans,
name='history1',
user=user2)
self.log('should be able to use keys with views')
serialized = self.history_serializer.serialize_to_view(
self.trans,
history1,
view='summary',
keys=['state_ids', 'user_id'])
self.assertKeys(
serialized, self.history_serializer.views['summary'] +
['state_ids', 'user_id'])
self.log('should be able to use keys on their own')
serialized = self.history_serializer.serialize_to_view(
self.trans, history1, keys=['state_ids', 'user_id'])
self.assertKeys(serialized, ['state_ids', 'user_id'])
def test_sharable(self):
user2 = self.user_mgr.create(self.trans, **user2_data)
history1 = self.history_mgr.create(self.trans,
name='history1',
user=user2)
self.log('should have a serializer for all SharableModel keys')
sharable_attrs = [
'user_id', 'username_and_slug', 'importable', 'published', 'slug'
]
serialized = self.history_serializer.serialize(self.trans, history1,
sharable_attrs)
self.assertKeys(serialized, sharable_attrs)
def test_purgable(self):
user2 = self.user_mgr.create(self.trans, **user2_data)
history1 = self.history_mgr.create(self.trans,
name='history1',
user=user2)
self.log(
'deleted and purged should be returned in their default states')
keys = ['deleted', 'purged']
serialized = self.history_serializer.serialize(self.trans, history1,
keys)
self.assertEqual(serialized['deleted'], False)
self.assertEqual(serialized['purged'], False)
self.log('deleted and purged should return their current state')
self.history_mgr.delete(self.trans, history1)
serialized = self.history_serializer.serialize(self.trans, history1,
keys)
self.assertEqual(serialized['deleted'], True)
self.assertEqual(serialized['purged'], False)
self.history_mgr.purge(self.trans, history1)
serialized = self.history_serializer.serialize(self.trans, history1,
keys)
self.assertEqual(serialized['deleted'], True)
self.assertEqual(serialized['purged'], True)
def test_history_serializers(self):
user2 = self.user_mgr.create(self.trans, **user2_data)
history1 = self.history_mgr.create(self.trans,
name='history1',
user=user2)
serialized = self.history_serializer.serialize(self.trans, history1,
['size', 'nice_size'])
self.assertIsInstance(serialized['size'], int)
self.assertIsInstance(serialized['nice_size'], basestring)
def test_contents(self):
user2 = self.user_mgr.create(self.trans, **user2_data)
history1 = self.history_mgr.create(self.trans,
name='history1',
user=user2)
self.log(
'a history with no contents should be properly reflected in empty, etc.'
)
keys = [
'empty', 'count', 'state_ids', 'state_details', 'state', 'hdas'
]
serialized = self.history_serializer.serialize(self.trans, history1,
keys)
self.assertEqual(serialized['state'], 'new')
self.assertEqual(serialized['empty'], True)
self.assertEqual(serialized['count'], 0)
self.assertEqual(sum(serialized['state_details'].values()), 0)
self.assertEqual(serialized['state_ids']['ok'], [])
self.assertIsInstance(serialized['hdas'], list)
self.log(
'a history with contents should be properly reflected in empty, etc.'
)
hda1 = self.hda_mgr.create(self.trans, history=history1, hid=1)
self.hda_mgr.update(self.trans, hda1, dict(state='ok'))
serialized = self.history_serializer.serialize(self.trans, history1,
keys)
self.assertEqual(serialized['state'], 'ok')
self.assertEqual(serialized['empty'], False)
self.assertEqual(serialized['count'], 1)
self.assertEqual(serialized['state_details']['ok'], 1)
self.assertIsInstance(serialized['state_ids']['ok'], list)
self.assertIsInstance(serialized['hdas'], list)
self.assertIsInstance(serialized['hdas'][0], basestring)
serialized = self.history_serializer.serialize(self.trans, history1,
['contents'])
self.assertHasKeys(serialized['contents'][0],
['id', 'name', 'peek', 'create_time'])
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)
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 HistorySerializerTestCase(BaseTestCase):
def assertHasKeys(self, obj, key_list):
self.assertEqual(sorted(obj.keys()), sorted(key_list))
def set_up_managers(self):
super(HistorySerializerTestCase, self).set_up_managers()
self.history_mgr = HistoryManager(self.app)
self.hda_mgr = hdas.HDAManager(self.app)
self.history_serializer = HistorySerializer(self.app)
def test_views(self):
user2 = self.user_mgr.create(self.trans, **user2_data)
history1 = self.history_mgr.create(self.trans,
name='history1',
user=user2)
self.log('should have a summary view')
summary_view = self.history_serializer.serialize_to_view(
self.trans, history1, view='summary')
self.assertHasKeys(summary_view,
self.history_serializer.views['summary'])
self.log('should have a detailed view')
detailed_view = self.history_serializer.serialize_to_view(
self.trans, history1, view='detailed')
self.assertHasKeys(detailed_view,
self.history_serializer.views['detailed'])
self.log('should have a extended view')
extended_view = self.history_serializer.serialize_to_view(
self.trans, history1, view='extended')
self.assertHasKeys(extended_view,
self.history_serializer.views['extended'])
self.log('should have the summary view as default view')
default_view = self.history_serializer.serialize_to_view(
self.trans, history1, default_view='summary')
self.assertHasKeys(summary_view,
self.history_serializer.views['summary'])
self.log('should have a serializer for all serializable keys')
need_no_serializers = (basestring, bool, type(None))
for key in self.history_serializer.serializable_keys:
instantiated_attribute = getattr(history1, key, None)
if not ((key in self.history_serializer.serializers) or
(isinstance(instantiated_attribute, need_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):
user2 = self.user_mgr.create(self.trans, **user2_data)
history1 = self.history_mgr.create(self.trans,
name='history1',
user=user2)
self.log('should be able to use keys with views')
serialized = self.history_serializer.serialize_to_view(
self.trans,
history1,
view='summary',
keys=['state_ids', 'user_id'])
self.assertHasKeys(
serialized, self.history_serializer.views['summary'] +
['state_ids', 'user_id'])
self.log('should be able to use keys on their own')
serialized = self.history_serializer.serialize_to_view(
self.trans, history1, keys=['state_ids', 'user_id'])
self.assertHasKeys(serialized, ['state_ids', 'user_id'])
def test_serializers(self):
# size
# nice size
pass
def test_contents(self):
user2 = self.user_mgr.create(self.trans, **user2_data)
history1 = self.history_mgr.create(self.trans,
name='history1',
user=user2)
self.log(
'a history with no contents should be properly reflected in empty, etc.'
)
keys = ['empty', 'count', 'state_ids', 'state_details', 'state']
serialized = self.history_serializer.serialize(self.trans, history1,
keys)
self.assertEqual(serialized['state'], 'new')
self.assertEqual(serialized['empty'], True)
self.assertEqual(serialized['count'], 0)
self.assertEqual(sum(serialized['state_details'].values()), 0)
self.assertEqual(serialized['state_ids']['ok'], [])
hda1 = self.hda_mgr.create(self.trans, history=history1, hid=1)
self.hda_mgr.update(self.trans, hda1, dict(state='ok'))
serialized = self.history_serializer.serialize(self.trans, history1,
keys)
self.assertEqual(serialized['state'], 'ok')
self.assertEqual(serialized['empty'], False)
self.assertEqual(serialized['count'], 1)
self.assertEqual(serialized['state_details']['ok'], 1)
self.assertIsInstance(serialized['state_ids']['ok'], list)
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 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'))
