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 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 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'])
