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