def test_update_fileset_complete_with_images(self, client, db_fileset):
keys = ('uuid', 'name', 'reader', 'reader_software', 'reader_version',
'complete', 'import_uuid', 'progress')
d = sa_obj_to_dict(db_fileset, keys)
d_image = sa_obj_to_dict(ImageFactory(),
['uuid', 'name', 'pyramid_levels'])
d['complete'] = True
assert to_jsonapi(d) == client.update_fileset(db_fileset.uuid,
complete=True,
images=[d_image])
image = client.list_images_in_fileset(db_fileset.uuid)
d_image['fileset_uuid'] = db_fileset.uuid
d_image['repository_uuid'] = db_fileset.import_.repository_uuid
assert to_jsonapi([d_image]) == image
def test_list_filesets_in_import(self, client,
user_granted_read_hierarchy):
keys = ('uuid', 'name', 'reader', 'reader_software', 'reader_version',
'complete', 'import_uuid', 'progress')
d = sa_obj_to_dict(user_granted_read_hierarchy['fileset'], keys)
assert to_jsonapi([d]) == client.list_filesets_in_import(
user_granted_read_hierarchy['import_uuid'])
def test_update_fileset_complete(self, client, db_fileset):
keys = ('uuid', 'name', 'reader', 'reader_software', 'reader_version',
'complete', 'import_uuid', 'progress')
d = sa_obj_to_dict(db_fileset, keys)
d['complete'] = True
assert to_jsonapi(d) == client.update_fileset(db_fileset.uuid,
complete=True)
def test_update_repository_raw_storage(self, client, db_repository):
keys = ('uuid', 'name', 'raw_storage')
d = sa_obj_to_dict(db_repository, keys)
repository = client.update_repository(db_repository.uuid,
raw_storage='Destroy')
d['raw_storage'] = 'Destroy'
assert to_jsonapi(d) == repository
def test_to_jsonapi_included(self):
data = {'x': 1, 'y': 'foo'}
included = {'extras': [{'a': 'A'}]}
assert to_jsonapi(data, included) == {
'data': data,
'included': included
}
def test_create_membership(self, client, session, db_user, db_group):
keys = ['user_uuid', 'group_uuid', 'membership_type']
d = sa_obj_to_dict(MembershipFactory(), keys)
d['user_uuid'] = db_user.uuid
d['group_uuid'] = db_group.uuid
m = client.create_membership(db_group.uuid, db_user.uuid, 'Member')
assert to_jsonapi(d) == m
assert d == sa_obj_to_dict(session.query(Membership).one(), keys)
def test_create_repository(self, client, session, db_user):
keys = ('uuid', 'name', 'raw_storage')
d = sa_obj_to_dict(RepositoryFactory(), keys)
assert to_jsonapi(d) == client.create_repository(
user_uuid=db_user.uuid, **d)
repository = session.query(Repository).one()
assert d == sa_obj_to_dict(repository, keys)
assert db_user == repository.subjects[0]
def test_update_membership(self, client, session, db_user, db_group):
keys = ['user_uuid', 'group_uuid', 'membership_type']
db_membership = MembershipFactory(group=db_group,
user=db_user,
membership_type='Member')
session.add(db_membership)
session.commit()
d = sa_obj_to_dict(db_membership, keys)
d['membership_type'] = 'Owner'
assert to_jsonapi(d)['data'] == client.update_membership(
db_group.uuid, db_user.uuid, 'Owner')['data']
def test_list_repositories_for_user_implied(self, client, fixture_name,
request):
hierarchy = request.getfixturevalue(fixture_name)
grant_keys = ['subject_uuid', 'repository_uuid', 'permission']
repository_keys = ['uuid', 'name', 'raw_storage']
user_uuid = hierarchy['user_uuid']
d_grant = sa_obj_to_dict(hierarchy['grant'], grant_keys)
d_repository = sa_obj_to_dict(hierarchy['repository'], repository_keys)
assert to_jsonapi([d_grant], {'repositories': [d_repository]
}) == client.list_repositories_for_user(
user_uuid, implied=True)
def test_get_membership(self, client, db_membership):
membership_keys = ('user_uuid', 'group_uuid', 'membership_type')
group_keys = ('uuid', 'name')
user_keys = ('uuid', )
d_membership = sa_obj_to_dict(db_membership, membership_keys)
d_group = sa_obj_to_dict(db_membership.group, group_keys)
d_user = sa_obj_to_dict(db_membership.user, user_keys)
assert to_jsonapi(d_membership, {
'groups': [d_group],
'users': [d_user]
}) == client.get_membership(db_membership.group_uuid,
db_membership.user_uuid)
def test_list_repositories_for_user(self, client,
user_granted_read_hierarchy):
grant_keys = ['subject_uuid', 'repository_uuid', 'permission']
repository_keys = ['uuid', 'name', 'raw_storage']
user_uuid = user_granted_read_hierarchy['user_uuid']
d_grant = sa_obj_to_dict(user_granted_read_hierarchy['grant'],
grant_keys)
d_repository = sa_obj_to_dict(
user_granted_read_hierarchy['repository'], repository_keys)
assert to_jsonapi([d_grant],
{'repositories': [d_repository]
}) == client.list_repositories_for_user(user_uuid)
def test_create_image(self, client, session, db_fileset):
keys = ('uuid', 'name', 'pyramid_levels')
image = ImageFactory()
create_d = sa_obj_to_dict(image, keys)
d = sa_obj_to_dict(image, keys)
d['fileset_uuid'] = db_fileset.uuid
d['repository_uuid'] = None
assert to_jsonapi(d) == client.create_image(
fileset_uuid=db_fileset.uuid, **create_d)
image = session.query(Image).one()
keys += ('fileset_uuid', 'repository_uuid')
assert d == sa_obj_to_dict(image, keys)
assert db_fileset == image.fileset
def test_create_import(self, client, session, db_repository):
keys = ('uuid', 'name')
import_ = ImportFactory()
create_d = sa_obj_to_dict(import_, keys)
keys += ('complete', )
d = sa_obj_to_dict(import_, keys)
d['repository_uuid'] = db_repository.uuid
assert to_jsonapi(d) == client.create_import(
repository_uuid=db_repository.uuid, **create_d)
import_ = session.query(Import).one()
keys += ('repository_uuid', )
assert d == sa_obj_to_dict(import_, keys)
assert db_repository == import_.repository
def test_create_fileset(self, client, session, db_import_with_keys):
db_keys = [key.key for key in db_import_with_keys.keys[:2]]
keys = ('uuid', 'name', 'reader', 'reader_software', 'reader_version',
'progress')
fileset = FilesetFactory()
create_d = sa_obj_to_dict(fileset, keys)
keys += ('complete', )
d = sa_obj_to_dict(fileset, keys)
d['import_uuid'] = db_import_with_keys.uuid
assert to_jsonapi(d) == client.create_fileset(
import_uuid=db_import_with_keys.uuid, keys=db_keys, **create_d)
fileset = session.query(Fileset).one()
keys += ('import_uuid', )
assert d == sa_obj_to_dict(fileset, keys)
assert db_import_with_keys == fileset.import_
assert set(db_keys) == {key.key for key in fileset.keys}
def test_list_repositories_for_user_none(self, client, db_user):
assert to_jsonapi(
[], {'repositories': []}) == client.list_repositories_for_user(
db_user.uuid, implied=True)
def test_get_repository(self, client, db_repository):
keys = ('uuid', 'name', 'raw_storage')
d = sa_obj_to_dict(db_repository, keys)
assert to_jsonapi(d) == client.get_repository(db_repository.uuid)
def test_list_images_in_fileset(self, client, user_granted_read_hierarchy):
keys = ('uuid', 'name', 'pyramid_levels', 'fileset_uuid',
'repository_uuid')
d = sa_obj_to_dict(user_granted_read_hierarchy['image'], keys)
assert to_jsonapi([d]) == client.list_images_in_fileset(
user_granted_read_hierarchy['fileset_uuid'])
def test_get_image(self, client, db_image):
keys = ('uuid', 'name', 'pyramid_levels', 'fileset_uuid',
'repository_uuid')
d = sa_obj_to_dict(db_image, keys)
assert to_jsonapi(d, {'rendering_settings': []}) == client.get_image(
db_image.uuid)
def test_list_imports_in_repository(self, client,
user_granted_read_hierarchy):
keys = ('uuid', 'name', 'complete', 'repository_uuid')
d = sa_obj_to_dict(user_granted_read_hierarchy['import_'], keys)
assert to_jsonapi([d]) == client.list_imports_in_repository(
user_granted_read_hierarchy['repository_uuid'])
def test_get_user(self, client, db_user):
keys = ('uuid', )
d = sa_obj_to_dict(db_user, keys)
assert to_jsonapi(d) == client.get_user(db_user.uuid)
def test_list_keys_in_fileset(self, client, user_granted_read_hierarchy):
keys = ('key', 'import_uuid', 'fileset_uuid')
d = sa_obj_to_dict(user_granted_read_hierarchy['key'], keys)
assert to_jsonapi([d]) == client.list_keys_in_fileset(
user_granted_read_hierarchy['fileset_uuid'])
def test_create_group(self, client, session, db_user):
keys = ('uuid', 'name')
d = sa_obj_to_dict(GroupFactory(), keys)
assert to_jsonapi(d) == client.create_group(user_uuid=db_user.uuid,
**d)
assert d == sa_obj_to_dict(session.query(Group).one(), keys)
def test_get_fileset(self, client, db_fileset):
keys = ('uuid', 'name', 'reader', 'reader_software', 'reader_version',
'complete', 'import_uuid', 'progress')
d = sa_obj_to_dict(db_fileset, keys)
assert to_jsonapi(d) == client.get_fileset(db_fileset.uuid)
def test_get_group(self, client, db_group):
keys = ('uuid', 'name')
d = sa_obj_to_dict(db_group, keys)
assert to_jsonapi(d) == client.get_group(db_group.uuid)
def test_update_import_complete(self, client, db_import):
keys = ('uuid', 'name', 'complete', 'repository_uuid')
d = sa_obj_to_dict(db_import, keys)
import_ = client.update_import(db_import.uuid, complete=True)
d['complete'] = True
assert to_jsonapi(d) == import_
def test_to_jsonapi(self):
data = {'x': 1, 'y': 'foo'}
included = {}
assert to_jsonapi(data) == {'data': data, 'included': included}
def test_create_user(self, client, session):
keys = ('uuid', )
d = sa_obj_to_dict(UserFactory(), keys)
assert to_jsonapi(d) == client.create_user(**d)
assert d == sa_obj_to_dict(session.query(User).one(), keys)
def test_get_import(self, client, db_import):
keys = ('uuid', 'name', 'complete', 'repository_uuid')
d = sa_obj_to_dict(db_import, keys)
assert to_jsonapi(d) == client.get_import(db_import.uuid)
