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 )
