class DatasetDeserializerTestCase(BaseTestCase): def set_up_managers(self): super(DatasetDeserializerTestCase, self).set_up_managers() self.dataset_manager = DatasetManager(self.app) self.dataset_serializer = DatasetSerializer(self.app) self.dataset_deserializer = DatasetDeserializer(self.app) self.role_manager = RoleManager(self.app) def test_deserialize_delete(self): dataset = self.dataset_manager.create() self.log('should raise when deserializing deleted from non-bool') self.assertFalse(dataset.deleted) self.assertRaises(exceptions.RequestParameterInvalidException, self.dataset_deserializer.deserialize, dataset, data={'deleted': None}) self.assertFalse(dataset.deleted) self.log('should be able to deserialize deleted from True') self.dataset_deserializer.deserialize(dataset, data={'deleted': True}) self.assertTrue(dataset.deleted) self.log( 'should be able to reverse by deserializing deleted from False') self.dataset_deserializer.deserialize(dataset, data={'deleted': False}) self.assertFalse(dataset.deleted) def test_deserialize_purge(self): dataset = self.dataset_manager.create() self.log('should raise when deserializing purged from non-bool') self.assertRaises(exceptions.RequestParameterInvalidException, self.dataset_deserializer.deserialize, dataset, data={'purged': None}) self.assertFalse(dataset.purged) self.log('should be able to deserialize purged from True') self.dataset_deserializer.deserialize(dataset, data={'purged': True}) self.assertTrue(dataset.purged) # TODO: should this raise an error? self.log( 'should NOT be able to deserialize purged from False (will remain True)' ) self.dataset_deserializer.deserialize(dataset, data={'purged': False}) self.assertTrue(dataset.purged) def test_deserialize_permissions(self): dataset = self.dataset_manager.create() who_manages = self.user_manager.create(**user2_data) self.dataset_manager.permissions.manage.grant(dataset, who_manages) existing_permissions = self.dataset_serializer.serialize_permissions( dataset, 'permissions', user=who_manages) existing_manage_permissions = existing_permissions['manage'] user3 = self.user_manager.create(**user3_data) self.log( 'deserializing permissions from a non-dictionary should error') not_a_dict = [] self.assertRaises(exceptions.RequestParameterInvalidException, self.dataset_deserializer.deserialize, dataset, user=who_manages, data={'permissions': not_a_dict}) self.log( 'deserializing permissions from a malformed dictionary should error' ) self.assertRaises(exceptions.RequestParameterInvalidException, self.dataset_deserializer.deserialize, dataset, user=who_manages, data={'permissions': dict(nope=[], access=[])}) self.log('deserializing permissions with no manage roles should error') self.assertRaises(exceptions.RequestParameterInvalidException, self.dataset_deserializer.deserialize, dataset, user=who_manages, data={'permissions': dict(manage=[], access=[])}) self.log( 'deserializing permissions using a non-managing user should error') self.assertRaises(rbac_secured.DatasetManagePermissionFailedException, self.dataset_deserializer.deserialize, dataset, user=user3, data={'permissions': existing_permissions}) self.log('deserializing permissions using an anon user should error') self.assertRaises(rbac_secured.DatasetManagePermissionFailedException, self.dataset_deserializer.deserialize, dataset, user=None, data={'permissions': existing_permissions}) self.log( 'deserializing permissions with a single access should make the dataset private' ) private_role = self.user_manager.private_role(who_manages) private_role = private_role.to_dict( value_mapper={'id': self.app.security.encode_id}) permissions = dict(manage=existing_manage_permissions, access=[private_role['id']]) self.dataset_deserializer.deserialize( dataset, user=who_manages, data={'permissions': permissions}) self.assertFalse( self.dataset_manager.is_accessible(dataset, user=user3)) self.log( 'deserializing permissions manage should make the permissions available' ) self.assertRaises(SkipAttribute, self.dataset_serializer.serialize_permissions, dataset, 'perms', user=user3) # now, have who_manages give a manage permission to user3 private_role = self.user_manager.private_role(user3) new_manage_permissions = existing_manage_permissions + [ self.app.security.encode_id(private_role.id) ] permissions = dict(manage=new_manage_permissions, access=[]) self.dataset_deserializer.deserialize( dataset, user=who_manages, data={'permissions': permissions}) # deserializing for user3 shouldn't throw a skip bc they can manage permissions = self.dataset_serializer.serialize_permissions( dataset, 'perms', user=who_manages) self.assertEqual(new_manage_permissions, permissions['manage']) def test_deserialize_permissions_with_admin(self): dataset = self.dataset_manager.create() who_manages = self.user_manager.create(**user2_data) self.dataset_manager.permissions.manage.grant(dataset, who_manages) existing_permissions = self.dataset_serializer.serialize_permissions( dataset, 'permissions', user=who_manages) existing_manage_permissions = existing_permissions['manage'] user3 = self.user_manager.create(**user3_data) self.assertRaises(rbac_secured.DatasetManagePermissionFailedException, self.dataset_deserializer.deserialize, dataset, user=user3, data={'permissions': existing_permissions}) self.log( 'deserializing permissions using an admin user should not error') private_role = self.user_manager.private_role(who_manages) private_role = private_role.to_dict( value_mapper={'id': self.app.security.encode_id}) permissions = dict(manage=existing_manage_permissions, access=[private_role['id']]) self.dataset_deserializer.deserialize( dataset, user=who_manages, data={'permissions': permissions}) self.assertRaises(rbac_secured.DatasetManagePermissionFailedException, self.dataset_deserializer.deserialize, dataset, user=user3, data={'permissions': existing_permissions})
class DatasetSerializerTestCase(BaseTestCase): def set_up_managers(self): super(DatasetSerializerTestCase, self).set_up_managers() self.dataset_manager = DatasetManager(self.app) self.dataset_serializer = DatasetSerializer(self.app) self.role_manager = RoleManager(self.app) def test_views(self): dataset = self.dataset_manager.create() self.log('should have a summary view') summary_view = self.dataset_serializer.serialize_to_view( dataset, view='summary') self.assertKeys(summary_view, self.dataset_serializer.views['summary']) self.log('should have the summary view as default view') self.dataset_serializer.serialize_to_view(dataset, default_view='summary') self.assertKeys(summary_view, self.dataset_serializer.views['summary']) self.log('should have a serializer for all serializable keys') for key in self.dataset_serializer.serializable_keyset: instantiated_attribute = getattr(dataset, key, None) if not ((key in self.dataset_serializer.serializers) or (isinstance(instantiated_attribute, self.TYPES_NEEDING_NO_SERIALIZERS))): self.fail('no serializer for: %s (%s)' % (key, instantiated_attribute)) else: self.assertTrue(True, 'all serializable keys have a serializer') def test_views_and_keys(self): dataset = self.dataset_manager.create() self.log('should be able to use keys with views') serialized = self.dataset_serializer.serialize_to_view( dataset, # file_name is exposed using app.config.expose_dataset_path = True view='summary', keys=['file_name']) self.assertKeys( serialized, self.dataset_serializer.views['summary'] + ['file_name']) self.log('should be able to use keys on their own') serialized = self.dataset_serializer.serialize_to_view( dataset, keys=['purgable', 'file_size']) self.assertKeys(serialized, ['purgable', 'file_size']) def test_serialize_permissions(self): dataset = self.dataset_manager.create() who_manages = self.user_manager.create(**user2_data) self.dataset_manager.permissions.manage.grant(dataset, who_manages) self.log( 'serialized permissions should be returned for the user who can manage and be well formed' ) permissions = self.dataset_serializer.serialize_permissions( dataset, 'perms', user=who_manages) self.assertIsInstance(permissions, dict) self.assertKeys(permissions, ['manage', 'access']) self.assertIsInstance(permissions['manage'], list) self.assertIsInstance(permissions['access'], list) manage_perms = permissions['manage'] self.assertTrue(len(manage_perms) == 1) role_id = manage_perms[0] self.assertEncodedId(role_id) role_id = self.app.security.decode_id(role_id) role = self.role_manager.get(self.trans, role_id) self.assertTrue( who_manages in [user_role.user for user_role in role.users]) self.log('permissions should be not returned for non-managing users') not_my_supervisor = self.user_manager.create(**user3_data) self.assertRaises(SkipAttribute, self.dataset_serializer.serialize_permissions, dataset, 'perms', user=not_my_supervisor) self.log('permissions should not be returned for anon users') self.assertRaises(SkipAttribute, self.dataset_serializer.serialize_permissions, dataset, 'perms', user=None) self.log('permissions should be returned for admin users') permissions = self.dataset_serializer.serialize_permissions( dataset, 'perms', user=self.admin_user) self.assertIsInstance(permissions, dict) self.assertKeys(permissions, ['manage', 'access']) def test_serializers(self): # self.user_manager.create( **user2_data ) dataset = self.dataset_manager.create() all_keys = list(self.dataset_serializer.serializable_keyset) serialized = self.dataset_serializer.serialize(dataset, all_keys) self.log('everything serialized should be of the proper type') self.assertEncodedId(serialized['id']) self.assertDate(serialized['create_time']) self.assertDate(serialized['update_time']) self.assertUUID(serialized['uuid']) self.assertIsInstance(serialized['state'], string_types) self.assertIsInstance(serialized['deleted'], bool) self.assertIsInstance(serialized['purged'], bool) self.assertIsInstance(serialized['purgable'], bool) # # TODO: no great way to do these with mocked dataset # self.assertIsInstance( serialized[ 'file_size' ], int ) # self.assertIsInstance( serialized[ 'total_size' ], int ) self.log('serialized should jsonify well') self.assertIsJsonifyable(serialized)
def set_up_managers(self): super(DatasetSerializerTestCase, self).set_up_managers() self.dataset_manager = DatasetManager(self.app) self.dataset_serializer = DatasetSerializer(self.app) self.role_manager = RoleManager(self.app)
def set_up_managers( self ): super( DatasetDeserializerTestCase, self ).set_up_managers() self.dataset_manager = DatasetManager( self.app ) self.dataset_serializer = DatasetSerializer( self.app ) self.dataset_deserializer = DatasetDeserializer( self.app ) self.role_manager = RoleManager( self.app )
class DatasetDeserializerTestCase( BaseTestCase ): def set_up_managers( self ): super( DatasetDeserializerTestCase, self ).set_up_managers() self.dataset_manager = DatasetManager( self.app ) self.dataset_serializer = DatasetSerializer( self.app ) self.dataset_deserializer = DatasetDeserializer( self.app ) self.role_manager = RoleManager( self.app ) def test_deserialize_delete( self ): dataset = self.dataset_manager.create() self.log( 'should raise when deserializing deleted from non-bool' ) self.assertFalse( dataset.deleted ) self.assertRaises( exceptions.RequestParameterInvalidException, self.dataset_deserializer.deserialize, dataset, data={ 'deleted': None } ) self.assertFalse( dataset.deleted ) self.log( 'should be able to deserialize deleted from True' ) self.dataset_deserializer.deserialize( dataset, data={ 'deleted': True } ) self.assertTrue( dataset.deleted ) self.log( 'should be able to reverse by deserializing deleted from False' ) self.dataset_deserializer.deserialize( dataset, data={ 'deleted': False } ) self.assertFalse( dataset.deleted ) def test_deserialize_purge( self ): dataset = self.dataset_manager.create() self.log( 'should raise when deserializing purged from non-bool' ) self.assertRaises( exceptions.RequestParameterInvalidException, self.dataset_deserializer.deserialize, dataset, data={ 'purged': None } ) self.assertFalse( dataset.purged ) self.log( 'should be able to deserialize purged from True' ) self.dataset_deserializer.deserialize( dataset, data={ 'purged': True } ) self.assertTrue( dataset.purged ) # TODO: should this raise an error? self.log( 'should NOT be able to deserialize purged from False (will remain True)' ) self.dataset_deserializer.deserialize( dataset, data={ 'purged': False } ) self.assertTrue( dataset.purged ) def test_deserialize_permissions( self ): dataset = self.dataset_manager.create() who_manages = self.user_manager.create( **user2_data ) self.dataset_manager.permissions.manage.grant( dataset, who_manages ) existing_permissions = self.dataset_serializer.serialize_permissions( dataset, 'permissions', user=who_manages ) existing_manage_permissions = existing_permissions[ 'manage' ] user3 = self.user_manager.create( **user3_data ) self.log( 'deserializing permissions from a non-dictionary should error' ) not_a_dict = [] self.assertRaises( exceptions.RequestParameterInvalidException, self.dataset_deserializer.deserialize, dataset, user=who_manages, data={ 'permissions': not_a_dict }) self.log( 'deserializing permissions from a malformed dictionary should error' ) self.assertRaises( exceptions.RequestParameterInvalidException, self.dataset_deserializer.deserialize, dataset, user=who_manages, data={ 'permissions': dict( nope=[], access=[] ) }) self.log( 'deserializing permissions with no manage roles should error' ) self.assertRaises( exceptions.RequestParameterInvalidException, self.dataset_deserializer.deserialize, dataset, user=who_manages, data={ 'permissions': dict( manage=[], access=[] ) }) self.log( 'deserializing permissions using a non-managing user should error' ) self.assertRaises( rbac_secured.DatasetManagePermissionFailedException, self.dataset_deserializer.deserialize, dataset, user=user3, data={ 'permissions': existing_permissions }) self.log( 'deserializing permissions with a single access should make the dataset private' ) private_role = self.user_manager.private_role( who_manages ) private_role = private_role.to_dict( value_mapper={ 'id' : self.app.security.encode_id } ) permissions = dict( manage=existing_manage_permissions, access=[ private_role[ 'id' ] ] ) self.dataset_deserializer.deserialize( dataset, user=who_manages, data={ 'permissions': permissions }) self.assertFalse( self.dataset_manager.is_accessible( dataset, user=user3 ) ) self.log( 'deserializing permissions manage should make the permissions available' ) self.assertRaises( SkipAttribute, self.dataset_serializer.serialize_permissions, dataset, 'perms', user=user3 ) # now, have who_manages give a manage permission to user3 private_role = self.user_manager.private_role( user3 ) new_manage_permissions = existing_manage_permissions + [ self.app.security.encode_id( private_role.id ) ] permissions = dict( manage=new_manage_permissions, access=[] ) self.dataset_deserializer.deserialize( dataset, user=who_manages, data={ 'permissions': permissions }) # deserializing for user3 shouldn't throw a skip bc they can manage permissions = self.dataset_serializer.serialize_permissions( dataset, 'perms', user=who_manages ) self.assertEqual( new_manage_permissions, permissions[ 'manage' ] )
class DatasetSerializerTestCase( BaseTestCase ): def set_up_managers( self ): super( DatasetSerializerTestCase, self ).set_up_managers() self.dataset_manager = DatasetManager( self.app ) self.dataset_serializer = DatasetSerializer( self.app ) self.role_manager = RoleManager( self.app ) def test_views( self ): dataset = self.dataset_manager.create() self.log( 'should have a summary view' ) summary_view = self.dataset_serializer.serialize_to_view( dataset, view='summary' ) self.assertKeys( summary_view, self.dataset_serializer.views[ 'summary' ] ) self.log( 'should have the summary view as default view' ) self.dataset_serializer.serialize_to_view( dataset, default_view='summary' ) self.assertKeys( summary_view, self.dataset_serializer.views[ 'summary' ] ) self.log( 'should have a serializer for all serializable keys' ) for key in self.dataset_serializer.serializable_keyset: instantiated_attribute = getattr( dataset, key, None ) if not ( ( key in self.dataset_serializer.serializers ) or ( isinstance( instantiated_attribute, self.TYPES_NEEDING_NO_SERIALIZERS ) ) ): self.fail( 'no serializer for: %s (%s)' % ( key, instantiated_attribute ) ) else: self.assertTrue( True, 'all serializable keys have a serializer' ) def test_views_and_keys( self ): dataset = self.dataset_manager.create() self.log( 'should be able to use keys with views' ) serialized = self.dataset_serializer.serialize_to_view( dataset, # file_name is exposed using app.config.expose_dataset_path = True view='summary', keys=[ 'file_name' ] ) self.assertKeys( serialized, self.dataset_serializer.views[ 'summary' ] + [ 'file_name' ] ) self.log( 'should be able to use keys on their own' ) serialized = self.dataset_serializer.serialize_to_view( dataset, keys=[ 'purgable', 'file_size' ] ) self.assertKeys( serialized, [ 'purgable', 'file_size' ] ) def test_serialize_permissions( self ): dataset = self.dataset_manager.create() who_manages = self.user_manager.create( **user2_data ) self.dataset_manager.permissions.manage.grant( dataset, who_manages ) self.log( 'serialized permissions should be returned for the user who can manage and be well formed' ) permissions = self.dataset_serializer.serialize_permissions( dataset, 'perms', user=who_manages ) self.assertIsInstance( permissions, dict ) self.assertKeys( permissions, [ 'manage', 'access' ] ) self.assertIsInstance( permissions[ 'manage' ], list ) self.assertIsInstance( permissions[ 'access' ], list ) manage_perms = permissions[ 'manage' ] self.assertTrue( len( manage_perms ) == 1 ) role_id = manage_perms[0] self.assertEncodedId( role_id ) role_id = self.app.security.decode_id( role_id ) role = self.role_manager.get( self.trans, role_id ) self.assertTrue( who_manages in [ user_role.user for user_role in role.users ]) # wat self.log( 'permissions should be not returned for non-managing users' ) not_my_supervisor = self.user_manager.create( **user3_data ) self.assertRaises( SkipAttribute, self.dataset_serializer.serialize_permissions, dataset, 'perms', user=not_my_supervisor ) self.log( 'permissions should not be returned for anon users' ) self.assertRaises( SkipAttribute, self.dataset_serializer.serialize_permissions, dataset, 'perms', user=None ) def test_serializers( self ): # self.user_manager.create( **user2_data ) dataset = self.dataset_manager.create() all_keys = list( self.dataset_serializer.serializable_keyset ) serialized = self.dataset_serializer.serialize( dataset, all_keys ) self.log( 'everything serialized should be of the proper type' ) self.assertEncodedId( serialized[ 'id' ] ) self.assertDate( serialized[ 'create_time' ] ) self.assertDate( serialized[ 'update_time' ] ) self.assertUUID( serialized[ 'uuid' ] ) self.assertIsInstance( serialized[ 'state' ], basestring ) self.assertIsInstance( serialized[ 'deleted' ], bool ) self.assertIsInstance( serialized[ 'purged' ], bool ) self.assertIsInstance( serialized[ 'purgable' ], bool ) # # TODO: no great way to do these with mocked dataset # self.assertIsInstance( serialized[ 'file_size' ], int ) # self.assertIsInstance( serialized[ 'total_size' ], int ) self.log( 'serialized should jsonify well' ) self.assertIsJsonifyable( serialized )
def set_up_managers(self): super().set_up_managers() self.dataset_manager = DatasetManager(self.app) self.dataset_serializer = DatasetSerializer(self.app, self.user_manager) self.role_manager = RoleManager(self.app)
class DatasetSerializerTestCase( BaseTestCase ): def set_up_managers( self ): super( DatasetSerializerTestCase, self ).set_up_managers() self.dataset_manager = DatasetManager( self.app ) self.dataset_serializer = DatasetSerializer( self.app ) def test_views( self ): dataset = self.dataset_manager.create() self.log( 'should have a summary view' ) summary_view = self.dataset_serializer.serialize_to_view( dataset, view='summary' ) self.assertKeys( summary_view, self.dataset_serializer.views[ 'summary' ] ) self.log( 'should have the summary view as default view' ) default_view = self.dataset_serializer.serialize_to_view( dataset, default_view='summary' ) self.assertKeys( summary_view, self.dataset_serializer.views[ 'summary' ] ) self.log( 'should have a serializer for all serializable keys' ) for key in self.dataset_serializer.serializable_keyset: instantiated_attribute = getattr( dataset, key, None ) if not ( ( key in self.dataset_serializer.serializers ) or ( isinstance( instantiated_attribute, self.TYPES_NEEDING_NO_SERIALIZERS ) ) ): self.fail( 'no serializer for: %s (%s)' % ( key, instantiated_attribute ) ) else: self.assertTrue( True, 'all serializable keys have a serializer' ) def test_views_and_keys( self ): dataset = self.dataset_manager.create() self.log( 'should be able to use keys with views' ) serialized = self.dataset_serializer.serialize_to_view( dataset, view='summary', keys=[ 'permissions' ] ) self.assertKeys( serialized, self.dataset_serializer.views[ 'summary' ] + [ 'permissions' ] ) self.log( 'should be able to use keys on their own' ) serialized = self.dataset_serializer.serialize_to_view( dataset, keys=[ 'purgable', 'file_size' ] ) self.assertKeys( serialized, [ 'purgable', 'file_size' ] ) def test_serialize_permissions( self ): dataset = self.dataset_manager.create() self.log( 'serialized permissions should be well formed' ) def test_serializers( self ): user2 = self.user_manager.create( **user2_data ) dataset = self.dataset_manager.create() all_keys = list( self.dataset_serializer.serializable_keyset ) serialized = self.dataset_serializer.serialize( dataset, all_keys ) self.log( 'everything serialized should be of the proper type' ) self.assertEncodedId( serialized[ 'id' ] ) self.assertDate( serialized[ 'create_time' ] ) self.assertDate( serialized[ 'update_time' ] ) self.assertUUID( serialized[ 'uuid' ] ) self.assertIsInstance( serialized[ 'state' ], basestring ) self.assertIsInstance( serialized[ 'deleted' ], bool ) self.assertIsInstance( serialized[ 'purged' ], bool ) self.assertIsInstance( serialized[ 'purgable' ], bool ) # # TODO: no great way to do these with mocked dataset # self.assertIsInstance( serialized[ 'file_size' ], int ) # self.assertIsInstance( serialized[ 'total_size' ], int ) self.log( 'serialized should jsonify well' ) self.assertIsJsonifyable( serialized )