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)